@glowlabs-org/events-sdk 0.1.0

package/README.md

@@ -0,0 +1,295 @@
+# Glow Events SDK
+
+A TypeScript-first SDK for consuming and emitting typed events on the Glow platform, powered by RabbitMQ (fanout exchange). Provides runtime validation and type inference using Zod schemas.
+
+---
+
+## 🚀 Quick Start
+
+### 1. Install
+
+```bash
+npm install @glow/events-sdk
+```
+
+### 2. Available Events
+
+| Event Name     | Payload Type       | Description                      |
+| -------------- | ------------------ | -------------------------------- |
+| `AuditPushed`  | `AuditPushedEvent` | Emitted when an audit is pushed  |
+| `AuditSlashed` | `AuditSlashedId`   | Emitted when an audit is slashed |
+
+#### Event Payload Types
+
+```ts
+// AuditPushedEvent
+import type { AuditPushedEvent } from "@glow/events-sdk";
+// type AuditPushedEvent = {
+//   farmId: string;
+//   protocolFeeUSDPrice_12Decimals: string;
+//   tokenPrices: { token: string; priceWAD_usd12Decimals: string }[];
+//   expectedProduction_12Decimals: string;
+//   glowRewardSplits: { receiver: string; percent: number }[];
+//   cashRewardSplits: { receiver: string; percent: number }[];
+// }
+
+// AuditSlashedId
+// type AuditSlashedId = `0x${string}`;
+```
+
+---
+
+## ✨ Usage Example
+
+### Listen to Events
+
+```ts
+import { createGlowListener } from "@glow/events-sdk";
+
+async function main() {
+  const sdk = await createGlowListener({
+    username: "listener", // or "admin"
+    password: "your-password-here",
+    queueName: "my.precreated.queue", // REQUIRED: must be pre-created and bound by an admin
+    // Optionally specify a custom exchange:
+    // exchange: "glow.audit.v2.exchange",
+  });
+
+  sdk.on("AuditPushed", (event) => {
+    console.log("Received AuditPushed:", event.farmId);
+  });
+
+  sdk.on("AuditSlashed", (id) => {
+    console.log("Received AuditSlashed:", id);
+  });
+
+  await sdk.startListener();
+
+  // To stop listening:
+  // await sdk.stopListener();
+}
+
+main();
+```
+
+### Emit Events (Admin Only)
+
+```ts
+import { createGlowListener } from "@glow/events-sdk";
+
+async function main() {
+  const sdk = await createGlowListener({
+    username: "admin",
+    password: "your-password-here",
+    queueName: "my.precreated.queue", // REQUIRED: must be pre-created and bound by an admin
+    // Optionally specify a custom exchange:
+    // exchange: "glow.audit.v2.exchange",
+  });
+
+  await sdk.emitAuditPushed?.({
+    farmId: "0x...",
+    protocolFeeUSDPrice_12Decimals: "...",
+    tokenPrices: [],
+    expectedProduction_12Decimals: "...",
+    glowRewardSplits: [],
+    cashRewardSplits: [],
+  });
+
+  sdk.emitAuditSlashed?.("0x...");
+}
+
+main();
+```
+
+---
+
+## 📝 API Reference
+
+### `createGlowListener({ username, password, exchange?, queueName })`
+
+Returns a Promise resolving to an object with:
+
+- `.on(event, listener)` — Listen to typed events
+- `.off(event, listener)` — Remove a listener
+- `.emitAuditPushed(payload)` — Emit an AuditPushed event (if permitted)
+- `.emitAuditSlashed(id)` — Emit an AuditSlashed event (if permitted)
+- `.startListener()` — Start listening to events
+- `.stopListener()` — Stop listening to events
+
+#### Options
+
+- `username` (string, required)
+- `password` (string, required)
+- `exchange` (string, optional): RabbitMQ exchange name (default: `glow.audit.v1.exchange`)
+- `queueName` (string, required): Use a pre-created queue (must be set up by an admin)
+- **Naming Requirement:** Both `queueName` and `exchange` must be dot-separated (e.g., 'glow.audit.v1.exchange').
+
+---
+
+## 🔐 Permissions & Credentials
+
+- **Listener credentials:** Can only subscribe to events. Cannot emit events or create new queues.
+- **Admin credentials:** Can subscribe, emit events, and create/bind new queues and exchanges.
+
+If you try to emit with listener credentials, the SDK will throw an error.
+
+---
+
+## 🛠️ Advanced: Admin & Queue Management
+
+The SDK exposes helpers for programmatically creating, binding, and deleting exchanges and queues (admin credentials required). Use these for pre-creating queues for listeners, bootstrapping environments, or advanced queue management.
+
+### `createExchange(options)`
+
+### `bindQueueToExchange(options)`
+
+### `deleteExchange(options)`
+
+### `deleteQueue(options)`
+
+See the end of this README for full admin/queue management usage examples.
+
+---
+
+## 📚 More Details
+
+### Event Payload Zod Schema
+
+```ts
+import { z } from "zod";
+
+export const AuditPushedDataZ = z
+  .object({
+    farmId: z.string().regex(/^0x[0-9a-fA-F]{64}$/, "bytes32 hex string"),
+    protocolFeeUSDPrice_12Decimals: z
+      .string()
+      .regex(/^[0-9]+$/, "uint256 (decimal) − 12 implied decimals"),
+    tokenPrices: z.array(
+      z.object({
+        token: z.string().regex(/^0x[0-9a-fA-F]{40}$/, "ERC‑20 address"),
+        priceWAD_usd12Decimals: z.string().regex(/^[0-9]+$/),
+      })
+    ),
+    expectedProduction_12Decimals: z.string().regex(/^[0-9]+$/),
+    glowRewardSplits: z.array(
+      z.object({
+        receiver: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
+        percent: z.number().min(0).max(100),
+      })
+    ),
+    cashRewardSplits: z.array(
+      z.object({
+        receiver: z.string().regex(/^0x[0-9a-fA-F]{40}$/),
+        percent: z.number().min(0).max(100),
+      })
+    ),
+  })
+  .strict();
+
+export type AuditPushedData = z.infer<typeof AuditPushedDataZ>;
+```
+
+---
+
+## 🏗️ Admin: Exchange and Queue Management
+
+The SDK exposes helpers for programmatically creating, binding, and deleting exchanges and queues (admin credentials required). Use these for pre-creating queues for listeners, bootstrapping environments, or advanced queue management.
+
+### Usage Example
+
+```ts
+import {
+  createExchange,
+  bindQueueToExchange,
+  deleteExchange,
+  deleteQueue,
+} from "@glow/events-sdk";
+
+await createExchange({
+  username: "admin",
+  password: "your-password-here",
+  exchange: "glow.audit.v1.exchange",
+});
+
+await bindQueueToExchange({
+  username: "admin",
+  password: "your-password-here",
+  exchange: "glow.audit.v1.exchange",
+  queue: "glow-listener-queue",
+});
+
+await deleteExchange({
+  username: "admin",
+  password: "your-password-here",
+  exchange: "glow.audit.v1.exchange",
+});
+
+await deleteQueue({
+  username: "admin",
+  password: "your-password-here",
+  queue: "glow-listener-queue",
+});
+```
+
+---
+
+## 🔒 Strict Read-Only Listeners
+
+If your listener credentials only have `read` permission (no `configure`), you must consume from a pre-created queue. This is the most secure pattern for production.
+
+### 1. Admin: Pre-create and bind the queue
+
+```ts
+import { createAndBindQueue } from "@glow/events-sdk";
+
+await createAndBindQueue({
+  username: "admin",
+  password: "your-admin-password",
+  exchange: "glow.audit.v1.exchange",
+  queue: "my.precreated.queue",
+});
+```
+
+### 2. Listener: Consume from the pre-created queue
+
+```ts
+import { createGlowListener } from "@glow/events-sdk";
+
+const sdk = await createGlowListener({
+  username: "listener",
+  password: "your-listener-password",
+  queueName: "my.precreated.queue",
+  // Optionally specify a custom exchange:
+  // exchange: "glow.audit.v1.exchange",
+});
+```
+
+- The listener will only consume from the pre-created queue and will not attempt to create or bind anything.
+- This pattern is required for production environments with strict access control.
+
+---
+
+## 🧩 Advanced: Multiple Listeners/Producers
+
+You can create multiple listeners or producers in the same process, each with its own configuration (e.g., for different credentials, exchanges, or RabbitMQ URLs). This is useful for multi-tenant, multi-topic, or advanced scenarios. **Every listener receives every event for the bound exchange.**
+
+---
+
+## 🏗️ Build & Publish to npm
+
+To build and publish the SDK to npm:
+
+```bash
+make build
+make publish
+make clean
+```
+
+- The first time, run `npm login` to authenticate with npm.
+- For scoped packages (like `@glow/events-sdk`), the Makefile uses `--access public` for publishing.
+
+---
+
+## License
+
+MIT

package/dist/admin.d.ts

@@ -0,0 +1,38 @@
+import amqp from "amqplib";
+export interface CreateAndBindQueueOptions {
+    username: string;
+    password: string;
+    exchange: string;
+    queue: string;
+    exchangeType?: string;
+    queueOptions?: amqp.Options.AssertQueue;
+    exchangeOptions?: amqp.Options.AssertExchange;
+}
+/**
+ * Create a RabbitMQ exchange (admin credentials required).
+ *
+ * @param options - Connection and exchange options
+ * @returns Promise<void>
+ */
+export declare function createExchange({ username, password, exchange, exchangeType, exchangeOptions, }: Omit<CreateAndBindQueueOptions, "queue" | "queueOptions">): Promise<void>;
+/**
+ * Create a RabbitMQ queue and bind it to an exchange (admin credentials required).
+ *
+ * @param options - Connection, queue, and exchange options
+ * @returns Promise<void>
+ */
+export declare function bindQueueToExchange({ username, password, exchange, queue, exchangeType, queueOptions, exchangeOptions, }: CreateAndBindQueueOptions): Promise<void>;
+/**
+ * Delete a RabbitMQ exchange (admin credentials required).
+ *
+ * @param options - Connection and exchange options
+ * @returns Promise<void>
+ */
+export declare function deleteExchange({ username, password, exchange, }: Omit<CreateAndBindQueueOptions, "queue" | "queueOptions" | "exchangeType" | "exchangeOptions">): Promise<void>;
+/**
+ * Delete a RabbitMQ queue (admin credentials required).
+ *
+ * @param options - Connection and queue options
+ * @returns Promise<void>
+ */
+export declare function deleteQueue({ username, password, queue, }: Omit<CreateAndBindQueueOptions, "exchange" | "exchangeType" | "exchangeOptions" | "queueOptions">): Promise<void>;

package/dist/admin.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExchange = createExchange;
+exports.bindQueueToExchange = bindQueueToExchange;
+exports.deleteExchange = deleteExchange;
+exports.deleteQueue = deleteQueue;
+const amqplib_1 = __importDefault(require("amqplib"));
+function validateName(name, type) {
+    // Require at least two segments separated by dots, only alphanumerics, dashes, underscores, and dots
+    const pattern = /^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/;
+    if (!pattern.test(name)) {
+        throw new Error(`${type} name '${name}' is invalid. Must be dot-separated (e.g., 'glow.audit.v1.exchange').`);
+    }
+}
+/**
+ * Create a RabbitMQ exchange (admin credentials required).
+ *
+ * @param options - Connection and exchange options
+ * @returns Promise<void>
+ */
+async function createExchange({ username, password, exchange, exchangeType = "fanout", exchangeOptions = { durable: true }, }) {
+    validateName(exchange, "exchange");
+    const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+    const conn = await amqplib_1.default.connect(url.toString());
+    const channel = await conn.createChannel();
+    await channel.assertExchange(exchange, exchangeType, exchangeOptions);
+    await channel.close();
+    await conn.close();
+}
+/**
+ * Create a RabbitMQ queue and bind it to an exchange (admin credentials required).
+ *
+ * @param options - Connection, queue, and exchange options
+ * @returns Promise<void>
+ */
+async function bindQueueToExchange({ username, password, exchange, queue, exchangeType = "fanout", queueOptions = { durable: false }, exchangeOptions = { durable: true }, }) {
+    validateName(exchange, "exchange");
+    validateName(queue, "queue");
+    const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+    const conn = await amqplib_1.default.connect(url.toString());
+    const channel = await conn.createChannel();
+    await channel.assertExchange(exchange, exchangeType, exchangeOptions);
+    await channel.assertQueue(queue, queueOptions);
+    await channel.bindQueue(queue, exchange, "");
+    await channel.close();
+    await conn.close();
+}
+/**
+ * Delete a RabbitMQ exchange (admin credentials required).
+ *
+ * @param options - Connection and exchange options
+ * @returns Promise<void>
+ */
+async function deleteExchange({ username, password, exchange, }) {
+    validateName(exchange, "exchange");
+    const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+    const conn = await amqplib_1.default.connect(url.toString());
+    const channel = await conn.createChannel();
+    await channel.deleteExchange(exchange);
+    await channel.close();
+    await conn.close();
+}
+/**
+ * Delete a RabbitMQ queue (admin credentials required).
+ *
+ * @param options - Connection and queue options
+ * @returns Promise<void>
+ */
+async function deleteQueue({ username, password, queue, }) {
+    validateName(queue, "queue");
+    const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+    const conn = await amqplib_1.default.connect(url.toString());
+    const channel = await conn.createChannel();
+    await channel.deleteQueue(queue);
+    await channel.close();
+    await conn.close();
+}

package/dist/consumer.d.ts

@@ -0,0 +1,14 @@
+import { AuditPushedDataZ } from "./schemas/auditPushed";
+import { z } from "zod";
+export declare function createAuditPushedConsumer({ username, password, onEvent, skipAssertExchange, queueName, skipAssertQueue, exchange, }: {
+    username: string;
+    password: string;
+    onEvent: (evt: z.infer<typeof AuditPushedDataZ>) => void;
+    skipAssertExchange?: boolean;
+    queueName?: string;
+    skipAssertQueue?: boolean;
+    exchange?: string;
+}): {
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+};

package/dist/consumer.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuditPushedConsumer = createAuditPushedConsumer;
+const amqplib_1 = __importDefault(require("amqplib"));
+const auditPushed_1 = require("./schemas/auditPushed");
+const EXCHANGE = "glow.audit.v1.exchange";
+function createAuditPushedConsumer({ username, password, onEvent, skipAssertExchange = false, queueName, skipAssertQueue = false, exchange = "glow.audit.v1.exchange", }) {
+    // amqplib types are not always compatible with runtime objects, so we use 'as any' as a workaround
+    let connection = null;
+    let channel = null;
+    let internalQueueName;
+    let consumerTag = null;
+    function buildAmqpUrl() {
+        const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+        return url.toString();
+    }
+    async function connect() {
+        if (!connection) {
+            connection = (await amqplib_1.default.connect(buildAmqpUrl()));
+            channel = (await connection.createChannel());
+        }
+        if (channel) {
+            // Strict read-only: skip all asserts/binds, just use the provided queueName
+            if (skipAssertQueue) {
+                if (!queueName) {
+                    throw new Error("[Glow SDK] In strict read-only mode (skipAssertQueue: true), you must provide a queueName.");
+                }
+                internalQueueName = queueName;
+                // Do not assert or bind anything
+                return;
+            }
+            // Default pattern: assert exchange, create/bind queue
+            if (!skipAssertExchange) {
+                await channel.assertExchange(exchange, "fanout", { durable: true });
+            }
+            const q = await channel.assertQueue(queueName !== null && queueName !== void 0 ? queueName : "", {
+                exclusive: !queueName,
+            });
+            internalQueueName = q.queue;
+            await channel.bindQueue(internalQueueName, exchange, "");
+        }
+    }
+    async function start() {
+        try {
+            await connect();
+            if (!internalQueueName)
+                throw new Error("Queue not initialized");
+            const { consumerTag: tag } = await channel.consume(internalQueueName, (msg) => {
+                if (msg) {
+                    try {
+                        const decoded = JSON.parse(msg.content.toString());
+                        onEvent(auditPushed_1.AuditPushedDataZ.parse(decoded));
+                        channel.ack(msg);
+                    }
+                    catch (error) {
+                        console.error("Failed to process audit pushed event:", error);
+                        channel.nack(msg, false, false);
+                    }
+                }
+            }, { noAck: false });
+            consumerTag = tag;
+        }
+        catch (error) {
+            console.error("Failed to start audit pushed consumer:", error);
+            throw error;
+        }
+    }
+    async function stop() {
+        if (channel && consumerTag && internalQueueName) {
+            await channel.cancel(consumerTag);
+            consumerTag = null;
+        }
+        if (connection) {
+            await connection.close();
+            connection = null;
+            channel = null;
+            internalQueueName = undefined;
+        }
+    }
+    return { start, stop };
+}

package/dist/glow-listener.d.ts

@@ -0,0 +1,31 @@
+import type { GlowListener } from "./types";
+/**
+ * Options for creating a GlowListener instance.
+ *
+ * - Use admin credentials to emit events and create/bind queues/exchanges.
+ * - Use listener credentials for read-only event consumption (with pre-created queues).
+ * - Specify a custom exchange for multi-exchange support.
+ */
+interface GlowListenerOptions {
+    /** Username for RabbitMQ authentication (admin or listener) */
+    username: string;
+    /** Password for RabbitMQ authentication */
+    password: string;
+    /**
+     * The pre-created queue to use for the listener. Must be set up by an admin.
+     */
+    queueName: string;
+    /**
+     * The pre-created exchange to use. Must be set up by an admin. Defaults to 'glow.audit.v1.exchange'.
+     */
+    exchange?: string;
+}
+/**
+ * Create a GlowListener instance for consuming and emitting typed events on the Glow platform.
+ *
+ * - Use admin credentials to emit events and manage queues/exchanges.
+ * - Use listener credentials for read-only event consumption.
+ * - Supports specifying a custom exchange for multi-exchange scenarios.
+ */
+export declare function createGlowListener({ username, password, queueName, exchange, }: GlowListenerOptions): Promise<GlowListener>;
+export type { GlowListener } from "./types";

package/dist/glow-listener.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlowListener = createGlowListener;
+const typed_emitter_1 = require("./typed-emitter");
+const consumer_1 = require("./consumer");
+const producer_1 = require("./producer");
+function validateName(name, type) {
+    // Require at least two segments separated by dots, only alphanumerics, dashes, underscores, and dots
+    const pattern = /^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/;
+    if (!pattern.test(name)) {
+        throw new Error(`${type} name '${name}' is invalid. Must be dot-separated (e.g., 'glow.audit.v1.exchange').`);
+    }
+}
+/**
+ * Create a GlowListener instance for consuming and emitting typed events on the Glow platform.
+ *
+ * - Use admin credentials to emit events and manage queues/exchanges.
+ * - Use listener credentials for read-only event consumption.
+ * - Supports specifying a custom exchange for multi-exchange scenarios.
+ */
+async function createGlowListener({ username, password, queueName, exchange = "glow.audit.v1.exchange", }) {
+    validateName(queueName, "queue");
+    validateName(exchange, "exchange");
+    const emitter = (0, typed_emitter_1.createTypedEmitter)();
+    // RabbitMQ consumer instance
+    const consumer = (0, consumer_1.createAuditPushedConsumer)({
+        username,
+        password,
+        onEvent: (event) => {
+            emitter.emit("AuditPushed", event);
+        },
+        skipAssertExchange: true,
+        queueName,
+        skipAssertQueue: true,
+        exchange,
+    });
+    // RabbitMQ producer instance (only if emit permission)
+    const producer = (0, producer_1.createAuditPushedProducer)({ username, password, exchange });
+    function emitAuditSlashed(id) {
+        emitter.emit("AuditSlashed", id); // Local event only
+    }
+    async function emitAuditPushed(data) {
+        try {
+            await producer.emit(data);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async function startListener() {
+        try {
+            await consumer.start();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async function stopListener() {
+        try {
+            await consumer.stop();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    return {
+        on: emitter.on,
+        off: emitter.off,
+        emitAuditPushed,
+        emitAuditSlashed,
+        startListener,
+        stopListener,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./producer";
+export * from "./consumer";
+export * from "./schemas/auditPushed";
+export * from "./glow-listener";
+export * from "./types";
+export * from "./admin";

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./producer"), exports);
+__exportStar(require("./consumer"), exports);
+__exportStar(require("./schemas/auditPushed"), exports);
+__exportStar(require("./glow-listener"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./admin"), exports);

package/dist/producer.d.ts

@@ -0,0 +1,8 @@
+export declare function createAuditPushedProducer({ username, password, exchange, }: {
+    username: string;
+    password: string;
+    exchange?: string;
+}): {
+    emit: (data: unknown) => Promise<void>;
+    disconnect: () => Promise<void>;
+};

package/dist/producer.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuditPushedProducer = createAuditPushedProducer;
+const amqplib_1 = __importDefault(require("amqplib"));
+const auditPushed_1 = require("./schemas/auditPushed");
+function createAuditPushedProducer({ username, password, exchange = "glow.audit.v1.exchange", }) {
+    // amqplib types are not always compatible with runtime objects, so we use 'as any' as a workaround
+    let connection = null;
+    let channel = null;
+    function buildAmqpUrl() {
+        const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+        return url.toString();
+    }
+    async function connect() {
+        if (!connection) {
+            connection = (await amqplib_1.default.connect(buildAmqpUrl()));
+            channel = (await connection.createChannel());
+        }
+        if (channel) {
+            await channel.assertExchange(exchange, "fanout", { durable: true });
+        }
+    }
+    async function emit(data) {
+        try {
+            const payload = auditPushed_1.AuditPushedDataZ.parse(data);
+            await connect();
+            channel.publish(exchange, "", // routingKey is ignored for fanout
+            Buffer.from(JSON.stringify(payload)), { persistent: true });
+        }
+        catch (error) {
+            console.error("Failed to emit audit pushed event:", error);
+            throw error;
+        }
+    }
+    async function disconnect() {
+        if (connection) {
+            await connection.close();
+            connection = null;
+            channel = null;
+        }
+    }
+    return { emit, disconnect };
+}

package/dist/schemas/auditPushed.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export declare const AuditPushedDataZ: z.ZodObject<{
+    farmId: z.ZodString;
+    protocolFeeUSDPrice_12Decimals: z.ZodString;
+    tokenPrices: z.ZodArray<z.ZodObject<{
+        token: z.ZodString;
+        priceWAD_usd12Decimals: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        token: string;
+        priceWAD_usd12Decimals: string;
+    }, {
+        token: string;
+        priceWAD_usd12Decimals: string;
+    }>, "many">;
+    expectedProduction_12Decimals: z.ZodString;
+    glowRewardSplits: z.ZodArray<z.ZodObject<{
+        receiver: z.ZodString;
+        percent: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        receiver: string;
+        percent: number;
+    }, {
+        receiver: string;
+        percent: number;
+    }>, "many">;
+    cashRewardSplits: z.ZodArray<z.ZodObject<{
+        receiver: z.ZodString;
+        percent: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        receiver: string;
+        percent: number;
+    }, {
+        receiver: string;
+        percent: number;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    farmId: string;
+    protocolFeeUSDPrice_12Decimals: string;
+    tokenPrices: {
+        token: string;
+        priceWAD_usd12Decimals: string;
+    }[];
+    expectedProduction_12Decimals: string;
+    glowRewardSplits: {
+        receiver: string;
+        percent: number;
+    }[];
+    cashRewardSplits: {
+        receiver: string;
+        percent: number;
+    }[];
+}, {
+    farmId: string;
+    protocolFeeUSDPrice_12Decimals: string;
+    tokenPrices: {
+        token: string;
+        priceWAD_usd12Decimals: string;
+    }[];
+    expectedProduction_12Decimals: string;
+    glowRewardSplits: {
+        receiver: string;
+        percent: number;
+    }[];
+    cashRewardSplits: {
+        receiver: string;
+        percent: number;
+    }[];
+}>;
+export type AuditPushedData = z.infer<typeof AuditPushedDataZ>;

package/dist/schemas/auditPushed.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditPushedDataZ = void 0;
+const zod_1 = require("zod");
+/* ────────────────────────────────────────────────────────── *
+ *  Helper regexes for on‑chain primitives                   *
+ * ────────────────────────────────────────────────────────── */
+const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
+const ethAddress = /^0x[0-9a-fA-F]{40}$/;
+const uint256 = /^[0-9]+$/; // unsigned big‑int as decimal string
+/* ────────────────────────────────────────────────────────── *
+ *  AuditPushed data payload                                 *
+ * ────────────────────────────────────────────────────────── */
+exports.AuditPushedDataZ = zod_1.z
+    .object({
+    farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    protocolFeeUSDPrice_12Decimals: zod_1.z
+        .string()
+        .regex(uint256, "uint256 (decimal) − 12 implied decimals"),
+    tokenPrices: zod_1.z.array(zod_1.z.object({
+        token: zod_1.z.string().regex(ethAddress, "ERC‑20 address"),
+        priceWAD_usd12Decimals: zod_1.z.string().regex(uint256),
+    })),
+    // might be removed
+    // payers: z.array(
+    //   z.object({
+    //     payer: z.string().regex(ethAddress, "payer address"),
+    //     amountToPay_USD12Decimals: z.string().regex(uint256),
+    //   })
+    // ),
+    expectedProduction_12Decimals: zod_1.z.string().regex(uint256),
+    glowRewardSplits: zod_1.z.array(zod_1.z.object({
+        receiver: zod_1.z.string().regex(ethAddress),
+        percent: zod_1.z.number().min(0).max(100),
+    })),
+    cashRewardSplits: zod_1.z.array(zod_1.z.object({
+        receiver: zod_1.z.string().regex(ethAddress),
+        percent: zod_1.z.number().min(0).max(100),
+    })),
+})
+    .strict()
+    .describe("Glow AuditPushed event payload");

package/dist/typed-emitter.d.ts

@@ -0,0 +1,7 @@
+type Listener<T extends any[]> = (...args: T) => void;
+export declare function createTypedEmitter<TEvents extends Record<string, any[]>>(): {
+    on: <K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>) => () => void;
+    off: <K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>) => void;
+    emit: <K extends keyof TEvents>(event: K, ...args: TEvents[K]) => void;
+};
+export {};

package/dist/typed-emitter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypedEmitter = createTypedEmitter;
+function createTypedEmitter() {
+    const listeners = {};
+    function on(event, listener) {
+        (listeners[event] || (listeners[event] = [])).push(listener);
+        return () => off(event, listener);
+    }
+    function off(event, listener) {
+        listeners[event] = (listeners[event] || []).filter((l) => l !== listener);
+    }
+    function emit(event, ...args) {
+        (listeners[event] || []).forEach((listener) => listener(...args));
+    }
+    return { on, off, emit };
+}

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+import type { AuditPushedData } from "./schemas/auditPushed";
+export type AuditPushedEvent = AuditPushedData;
+export type AuditSlashedId = `0x${string}`;
+export interface GlowEvents {
+    AuditPushed: [AuditPushedEvent];
+    AuditSlashed: [AuditSlashedId];
+    [key: string]: any[];
+}
+export type SdkPermission = "listen" | "emit";
+export interface SdkAuthConfig {
+    username: string;
+    password: string;
+    permissions: SdkPermission[];
+}
+export type GlowListenerEvent = "AuditPushed" | "AuditSlashed";
+export interface GlowListener {
+    on: <K extends GlowListenerEvent>(event: K, listener: (...args: GlowEvents[K]) => void) => () => void;
+    off: <K extends GlowListenerEvent>(event: K, listener: (...args: GlowEvents[K]) => void) => void;
+    emitAuditPushed?: (data: AuditPushedEvent) => Promise<void>;
+    emitAuditSlashed?: (id: AuditSlashedId) => void;
+    startListener: () => Promise<void>;
+    stopListener: () => Promise<void>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@glowlabs-org/events-sdk",
+  "version": "0.1.0",
+  "description": "Typed event SDK for Glow, powered by Redpanda/Kafka and Zod.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/glowlabs-org/glow-events.git"
+  },
+  "author": "Lironie <julien@glowlabs.org>",
+  "license": "MIT",
+  "keywords": [
+    "kafka",
+    "redpanda",
+    "events",
+    "sdk",
+    "zod",
+    "typescript",
+    "glow"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@kafkajs/confluent-schema-registry": "^3.8.0",
+    "amqplib": "^0.10.8",
+    "json-schema": "^0.4.0",
+    "kafkajs": "^2.2.4",
+    "uuid": "^11.1.0",
+    "zod": "^3.24.4",
+    "zod-to-json-schema": "^3.24.5"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.7",
+    "@types/json-schema": "^7.0.15",
+    "typescript": "^5.8.3"
+  }
+}