@glowlabs-org/events-sdk 1.0.8 → 1.0.10

package/README.md

@@ -54,14 +54,18 @@ Both `createGlowEventListener` and `createGlowEventEmitter` accept the following
 
 Currently supported event types and versions:
 
-| Event Name            | Version | Payload Type                  | Description                                         |
-| --------------------- | ------- | ----------------------------- | --------------------------------------------------- |
-| `audit.pushed`        | "v1"    | `AuditPushedV1Payload`        | Emitted when an audit is pushed                     |
-| `audit.slashed`       | "v1"    | `AuditSlashedV1Payload`       | Emitted when a farm is slashed                      |
-| `audit.pfees.paid`    | "v1"    | `AuditPfeesPaidV1Payload`     | Paid (by applicationId)                             |
-| `audit.pfees.paid`    | "v2"    | `AuditPfeesPaidV2Payload`     | Paid (by farmId)                                    |
-| `application.created` | "v1"    | `ApplicationCreatedV1Payload` | Emitted when an application is created              |
-| `audit.pushed`        | "v2"    | `AuditPushedV2Payload`        | Emitted when an audit is pushed (farmId is bytes16) |
+| Event Name                | Version    | Payload Type                          | Description                                         |
+| ------------------------- | ---------- | ------------------------------------- | --------------------------------------------------- |
+| `audit.pushed`            | "v1"       | `AuditPushedV1Payload`                | Emitted when an audit is pushed                     |
+| `audit.slashed`           | "v1"       | `AuditSlashedV1Payload`               | Emitted when a farm is slashed                      |
+| `audit.pfees.paid`        | "v1"       | `AuditPfeesPaidV1Payload`             | Paid (by applicationId)                             |
+| `audit.pfees.paid`        | "v2"       | `AuditPfeesPaidV2Payload`             | Paid (by farmId)                                    |
+| `audit.pfees.paid`        | "v2-alpha" | `AuditPfeesPaidV2AlphaPayload`        | Paid (by applicationId) + currency metadata         |
+| `application.created`     | "v1"       | `ApplicationCreatedV1Payload`         | Emitted when an application is created              |
+| `audit.pushed`            | "v2"       | `AuditPushedV2Payload`                | Emitted when an audit is pushed (farmId is bytes16) |
+| `audit.pushed`            | "v2-alpha" | `AuditPushedV2AlphaPayload`           | Same as v1 but without protocol fee                 |
+| `application.price.quote` | "v2-alpha" | `ApplicationPriceQuoteV2AlphaPayload` | Price quote for application                         |
+| `gctl.minted`             | "v2-alpha" | `GctlMintedV2AlphaPayload`            | GCTL minted amount and metadata                     |
 
 ---
 
@@ -156,15 +160,65 @@ export interface AuditPfeesPaidV2Payload {
 
 ### `audit.pushed` v2
 
-```ts
+````ts
 export interface AuditPushedV2Payload {
   farmId: string; // bytes16 hex string (0x...)
   protocolFeeUSDPrice_12Decimals: string; // uint256 (decimal) − 12 implied decimals
   expectedProduction_12Decimals: string; // uint256 (decimal) − 12 implied decimals
   txHash: string; // bytes32 hex string (0x...)
 }
+
+### `audit.pushed` v2-alpha
+
+```ts
+export interface AuditPushedV2AlphaPayload {
+  farmId: string; // UUID string
+  expectedProduction_12Decimals: string; // uint256 (decimal) − 12 implied decimals
+  txHash: string; // bytes32 hex string (0x...)
+}
+````
+
+### `audit.pfees.paid` v2-alpha
+
+```ts
+export type PaymentCurrency = "GCTL" | "USDC" | "USDG" | "GLW";
+export interface AuditPfeesPaidV2AlphaPayload {
+  applicationId: string; // UUID string
+  payer: string; // Ethereum address (0x...)
+  amount_6Decimals: string; // uint256 (decimal) − 6 implied decimals
+  txHash: string; // bytes32 hex string (0x...)
+  paymentCurrency: PaymentCurrency;
+  paymentEventType: string;
+  isSponsored: boolean;
+}
 ```
 
+### `application.price.quote` v2-alpha
+
+```ts
+export interface ApplicationPriceQuoteV2AlphaPayload {
+  applicationId: string; // UUID string
+  createdAt: string; // ISO-8601 datetime string
+  prices: { GCTL: string; GLW: string; USDC: string; USDG: string }; // uint256 decimal strings
+  signature: string; // bytes32 hex string (0x...)
+  gcaAddress: string; // Ethereum address (0x...)
+}
+```
+
+### `gctl.minted` v2-alpha
+
+```ts
+export interface GctlMintedV2AlphaPayload {
+  usdcAmount_6Decimals: string; // uint256 (decimal) − 6 implied decimals
+  gctlAmount_6Decimals: string; // uint256 (decimal) − 6 implied decimals
+  timestamp: string; // ISO-8601 datetime string
+  minter: string; // Ethereum address (0x...)
+  txHash: string; // bytes32 hex string (0x...)
+}
+```
+
+````
+
 **Validation:**
 
 - `farmId` must be a 16-byte hex string (e.g., `0x...`).
@@ -182,7 +236,7 @@ export interface ApplicationCreatedV1Payload {
   estimatedKWhGeneratedPerYear: number;
   installerCompanyName: string;
 }
-```
+````
 
 **Validation:**
 
@@ -341,7 +395,7 @@ await emitter.disconnect();
 >
 > - The emitter will automatically publish each event to both the global (zone 0) and the specific zone exchange.
 > - You cannot construct an emitter for zoneId: 0, and you cannot specify zoneId per emit call.
-> - `schemaVersion` is always a string (e.g., "v1", "v2").
+> - `schemaVersion` is always a string (e.g., "v1", "v2", "v2-alpha").
 > - **You can override the RabbitMQ host using the `host` option. Default is `turntable.proxy.rlwy.net:50784`.**
 
 ### 🌐 Listening to All Zones

package/dist/base-event.d.ts

@@ -4,21 +4,21 @@ export declare const baseEventZ: z.ZodObject<{
     id: z.ZodString;
     zoneId: z.ZodEffects<z.ZodNumber, number, number>;
     zoneName: z.ZodEnum<[string, ...string[]]>;
-    schemaVersion: z.ZodEnum<["v1", "v2"]>;
+    schemaVersion: z.ZodEnum<["v1", "v2", "v2-alpha"]>;
     eventType: z.ZodEnum<[EventType, ...EventType[]]>;
     timeStamp: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     id: string;
     zoneId: number;
     zoneName: string;
-    schemaVersion: "v1" | "v2";
+    schemaVersion: "v1" | "v2" | "v2-alpha";
     eventType: EventType;
     timeStamp: number;
 }, {
     id: string;
     zoneId: number;
     zoneName: string;
-    schemaVersion: "v1" | "v2";
+    schemaVersion: "v1" | "v2" | "v2-alpha";
     eventType: EventType;
     timeStamp: number;
 }>;
@@ -54,6 +54,14 @@ export interface BaseEventAuditPfeesPaidV2 {
     eventType: "audit.pfees.paid";
     timeStamp: number;
 }
+export interface BaseEventAuditPfeesPaidV2Alpha {
+    id: string;
+    zoneId: number;
+    zoneName: string;
+    schemaVersion: "v2-alpha";
+    eventType: "audit.pfees.paid";
+    timeStamp: number;
+}
 export interface BaseEventApplicationCreatedV1 {
     id: string;
     zoneId: number;
@@ -62,4 +70,20 @@ export interface BaseEventApplicationCreatedV1 {
     eventType: "application.created";
     timeStamp: number;
 }
-export type BaseEvent = BaseEventAuditPushedV1 | BaseEventAuditSlashedV1 | BaseEventAuditPfeesPaidV1 | BaseEventAuditPfeesPaidV2 | BaseEventApplicationCreatedV1;
+export interface BaseEventApplicationPriceQuoteV2Alpha {
+    id: string;
+    zoneId: number;
+    zoneName: string;
+    schemaVersion: "v2-alpha";
+    eventType: "application.price.quote";
+    timeStamp: number;
+}
+export interface BaseEventGctlMintedV2Alpha {
+    id: string;
+    zoneId: number;
+    zoneName: string;
+    schemaVersion: "v2-alpha";
+    eventType: "gctl.minted";
+    timeStamp: number;
+}
+export type BaseEvent = BaseEventAuditPushedV1 | BaseEventAuditSlashedV1 | BaseEventAuditPfeesPaidV1 | BaseEventAuditPfeesPaidV2 | BaseEventAuditPfeesPaidV2Alpha | BaseEventApplicationCreatedV1 | BaseEventApplicationPriceQuoteV2Alpha | BaseEventGctlMintedV2Alpha;

package/dist/base-event.js

@@ -12,7 +12,7 @@ exports.baseEventZ = zod_1.z.object({
         message: "Invalid zoneId",
     }),
     zoneName: zod_1.z.enum(zoneNames),
-    schemaVersion: zod_1.z.enum(["v1", "v2"]),
+    schemaVersion: zod_1.z.enum(["v1", "v2", "v2-alpha"]),
     eventType: zod_1.z.enum(Object.values(event_types_1.eventTypes)),
     timeStamp: zod_1.z.number().int(),
 });

package/dist/emitter.js

@@ -20,7 +20,12 @@ function createGlowEventEmitter({ username, password, zoneId, exchangePrefix = "
     async function connectIfNeeded() {
         if (!amqpConnection) {
             amqpConnection = (await amqplib_1.default.connect(buildUrl()));
-            amqpChannel = (await amqpConnection.createChannel());
+            // create a confirm channel so we can wait for broker acknowledgements
+            amqpChannel = (await amqpConnection.createConfirmChannel());
+            // if a message is unroutable this handler will fire
+            amqpChannel.on("return", (msg) => {
+                console.error("❌  UNROUTABLE:", msg.fields.routingKey);
+            });
         }
         if (amqpChannel) {
             await amqpChannel.assertExchange(globalExchangeName, "topic", {
@@ -52,8 +57,12 @@ function createGlowEventEmitter({ username, password, zoneId, exchangePrefix = "
         const routingKey = `${event.eventType}.${event.schemaVersion.toString()}`;
         await connectIfNeeded();
         // Emit to both the global and the specific zone exchange
-        amqpChannel.publish(globalExchangeName, routingKey, Buffer.from(JSON.stringify(event)), { persistent: true });
-        amqpChannel.publish(zoneExchangeName, routingKey, Buffer.from(JSON.stringify(event)), { persistent: true });
+        const globalPublish = amqpChannel.publish(globalExchangeName, routingKey, Buffer.from(JSON.stringify(event)), { persistent: true, mandatory: true });
+        const zonePublish = amqpChannel.publish(zoneExchangeName, routingKey, Buffer.from(JSON.stringify(event)), { persistent: true, mandatory: true });
+        console.log("globalPublish", globalPublish);
+        console.log("zonePublish", zonePublish);
+        // Wait for broker to acknowledge publishes; rejects on nack
+        await amqpChannel.waitForConfirms();
     }
     async function disconnect() {
         if (amqpConnection) {

package/dist/event-registry.d.ts

@@ -1,2 +1,2 @@
 import { z } from "zod";
-export declare function getEventSchema(eventType: string, version: "v1" | "v2"): z.ZodTypeAny;
+export declare function getEventSchema(eventType: string, version: "v1" | "v2" | "v2-alpha"): z.ZodTypeAny;

package/dist/event-registry.js

@@ -9,6 +9,10 @@ const base_event_1 = require("./base-event");
 const application_created_v1_1 = require("./schemas/application-created.v1");
 const event_types_1 = require("./event-types");
 const audit_pushed_v2_1 = require("./schemas/audit-pushed.v2");
+const application_price_quote_v2_alpha_1 = require("./schemas/application-price-quote.v2-alpha");
+const audit_pfees_paid_v2_alpha_1 = require("./schemas/audit-pfees-paid.v2-alpha");
+const audit_pushed_v2_alpha_1 = require("./schemas/audit-pushed.v2-alpha");
+const gctl_minted_v2_alpha_1 = require("./schemas/gctl-minted.v2-alpha");
 const eventTypeRegistry = {
     [`${event_types_1.eventTypes.auditPushed}:v1`]: base_event_1.baseEventZ.extend({
         payload: audit_pushed_v1_1.auditPushedV1PayloadZ,
@@ -22,12 +26,24 @@ const eventTypeRegistry = {
     [`${event_types_1.eventTypes.auditPfeesPaid}:v2`]: base_event_1.baseEventZ.extend({
         payload: audit_pfees_paid_v2_1.auditPfeesPaidV2PayloadZ,
     }),
+    [`${event_types_1.eventTypes.auditPfeesPaid}:v2-alpha`]: base_event_1.baseEventZ.extend({
+        payload: audit_pfees_paid_v2_alpha_1.auditPfeesPaidV2AlphaPayloadZ,
+    }),
     [`${event_types_1.eventTypes.applicationCreated}:v1`]: base_event_1.baseEventZ.extend({
         payload: application_created_v1_1.applicationCreatedV1PayloadZ,
     }),
     [`${event_types_1.eventTypes.auditPushed}:v2`]: base_event_1.baseEventZ.extend({
         payload: audit_pushed_v2_1.auditPushedV2PayloadZ,
     }),
+    [`${event_types_1.eventTypes.auditPushed}:v2-alpha`]: base_event_1.baseEventZ.extend({
+        payload: audit_pushed_v2_alpha_1.auditPushedV2AlphaPayloadZ,
+    }),
+    [`${event_types_1.eventTypes.applicationPriceQuote}:v2-alpha`]: base_event_1.baseEventZ.extend({
+        payload: application_price_quote_v2_alpha_1.applicationPriceQuoteV2AlphaPayloadZ,
+    }),
+    [`${event_types_1.eventTypes.gctlMinted}:v2-alpha`]: base_event_1.baseEventZ.extend({
+        payload: gctl_minted_v2_alpha_1.gctlMintedV2AlphaPayloadZ,
+    }),
     // Add more event types/versions here
 };
 function getEventSchema(eventType, version) {

package/dist/event-types.d.ts

@@ -3,5 +3,7 @@ export declare const eventTypes: {
     readonly auditSlashed: "audit.slashed";
     readonly auditPfeesPaid: "audit.pfees.paid";
     readonly applicationCreated: "application.created";
+    readonly applicationPriceQuote: "application.price.quote";
+    readonly gctlMinted: "gctl.minted";
 };
 export type EventType = (typeof eventTypes)[keyof typeof eventTypes];

package/dist/event-types.js

@@ -6,4 +6,6 @@ exports.eventTypes = {
     auditSlashed: "audit.slashed",
     auditPfeesPaid: "audit.pfees.paid",
     applicationCreated: "application.created",
+    applicationPriceQuote: "application.price.quote",
+    gctlMinted: "gctl.minted",
 };

package/dist/listener.js

@@ -52,6 +52,12 @@ function createGlowEventListener({ username, password, zoneId, queueName, exchan
             throw new Error("Queue not initialized");
         consumerTag = (await amqpChannel.consume(internalQueueName, (msg) => {
             if (msg) {
+                // Only process messages that originated from the exchange that matches the requested zoneId.
+                // This prevents duplicate handling when the queue is bound to multiple exchanges.
+                if (msg.fields.exchange !== exchangeName) {
+                    amqpChannel.ack(msg);
+                    return;
+                }
                 try {
                     const decoded = JSON.parse(msg.content.toString());
                     const [eventType, versionStr] = msg.fields.routingKey.split(".v");

package/dist/schemas/application-price-quote.v2-alpha.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const applicationPriceQuoteV2AlphaPayloadZ: z.ZodObject<{
+    applicationId: z.ZodString;
+    createdAt: z.ZodString;
+    prices: z.ZodObject<{
+        GCTL: z.ZodString;
+        GLW: z.ZodString;
+        USDC: z.ZodString;
+        USDG: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        GCTL: string;
+        GLW: string;
+        USDC: string;
+        USDG: string;
+    }, {
+        GCTL: string;
+        GLW: string;
+        USDC: string;
+        USDG: string;
+    }>;
+    signature: z.ZodString;
+    gcaAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    gcaAddress: string;
+    createdAt: string;
+    prices: {
+        GCTL: string;
+        GLW: string;
+        USDC: string;
+        USDG: string;
+    };
+    signature: string;
+}, {
+    applicationId: string;
+    gcaAddress: string;
+    createdAt: string;
+    prices: {
+        GCTL: string;
+        GLW: string;
+        USDC: string;
+        USDG: string;
+    };
+    signature: string;
+}>;
+export interface ApplicationPriceQuoteV2AlphaPayload extends z.infer<typeof applicationPriceQuoteV2AlphaPayloadZ> {
+}

package/dist/schemas/application-price-quote.v2-alpha.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applicationPriceQuoteV2AlphaPayloadZ = void 0;
+const zod_1 = require("zod");
+const patterns_1 = require("../patterns");
+exports.applicationPriceQuoteV2AlphaPayloadZ = zod_1.z.object({
+    applicationId: zod_1.z.string().uuid("UUID string"),
+    createdAt: zod_1.z.string().datetime(),
+    prices: zod_1.z.object({
+        GCTL: zod_1.z.string().regex(patterns_1.uint256),
+        GLW: zod_1.z.string().regex(patterns_1.uint256),
+        USDC: zod_1.z.string().regex(patterns_1.uint256),
+        USDG: zod_1.z.string().regex(patterns_1.uint256),
+    }),
+    signature: zod_1.z.string().regex(patterns_1.hexBytes32, "bytes32 hex string"),
+    gcaAddress: zod_1.z.string().regex(patterns_1.ethAddress, "Ethereum address"),
+});

package/dist/schemas/audit-pfees-paid.v2-alpha.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export type PaymentCurrency = "GCTL" | "USDC" | "USDG" | "GLW";
+export declare const auditPfeesPaidV2AlphaPayloadZ: z.ZodObject<{
+    applicationId: z.ZodString;
+    payer: z.ZodString;
+    amount_6Decimals: z.ZodString;
+    txHash: z.ZodString;
+} & {
+    paymentCurrency: z.ZodEnum<["GCTL", "USDC", "USDG", "GLW"]>;
+    paymentEventType: z.ZodString;
+    isSponsored: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    txHash: string;
+    applicationId: string;
+    payer: string;
+    amount_6Decimals: string;
+    paymentCurrency: "GCTL" | "GLW" | "USDC" | "USDG";
+    paymentEventType: string;
+    isSponsored: boolean;
+}, {
+    txHash: string;
+    applicationId: string;
+    payer: string;
+    amount_6Decimals: string;
+    paymentCurrency: "GCTL" | "GLW" | "USDC" | "USDG";
+    paymentEventType: string;
+    isSponsored: boolean;
+}>;
+export interface AuditPfeesPaidV2AlphaPayload extends z.infer<typeof auditPfeesPaidV2AlphaPayloadZ> {
+}

package/dist/schemas/audit-pfees-paid.v2-alpha.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditPfeesPaidV2AlphaPayloadZ = void 0;
+const zod_1 = require("zod");
+const audit_pfees_paid_v1_1 = require("./audit-pfees-paid.v1");
+exports.auditPfeesPaidV2AlphaPayloadZ = audit_pfees_paid_v1_1.auditPfeesPaidV1PayloadZ.extend({
+    paymentCurrency: zod_1.z.enum(["GCTL", "USDC", "USDG", "GLW"]),
+    paymentEventType: zod_1.z.string(),
+    isSponsored: zod_1.z.boolean(),
+});

package/dist/schemas/audit-pushed.v2-alpha.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const auditPushedV2AlphaPayloadZ: z.ZodObject<{
+    farmId: z.ZodString;
+    expectedProduction_12Decimals: z.ZodString;
+    txHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    farmId: string;
+    expectedProduction_12Decimals: string;
+    txHash: string;
+}, {
+    farmId: string;
+    expectedProduction_12Decimals: string;
+    txHash: string;
+}>;
+export type AuditPushedV2AlphaPayload = z.infer<typeof auditPushedV2AlphaPayloadZ>;

package/dist/schemas/audit-pushed.v2-alpha.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditPushedV2AlphaPayloadZ = void 0;
+const zod_1 = require("zod");
+const patterns_1 = require("../patterns");
+exports.auditPushedV2AlphaPayloadZ = zod_1.z.object({
+    farmId: zod_1.z.string().uuid(),
+    expectedProduction_12Decimals: zod_1.z.string().regex(patterns_1.uint256),
+    txHash: zod_1.z.string().regex(patterns_1.hexBytes32, "bytes32 hex string"),
+});

package/dist/schemas/gctl-minted.v2-alpha.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const gctlMintedV2AlphaPayloadZ: z.ZodObject<{
+    usdcAmount_6Decimals: z.ZodString;
+    gctlAmount_6Decimals: z.ZodString;
+    timestamp: z.ZodString;
+    minter: z.ZodString;
+    txHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    txHash: string;
+    usdcAmount_6Decimals: string;
+    gctlAmount_6Decimals: string;
+    timestamp: string;
+    minter: string;
+}, {
+    txHash: string;
+    usdcAmount_6Decimals: string;
+    gctlAmount_6Decimals: string;
+    timestamp: string;
+    minter: string;
+}>;
+export type GctlMintedV2AlphaPayload = z.infer<typeof gctlMintedV2AlphaPayloadZ>;

package/dist/schemas/gctl-minted.v2-alpha.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gctlMintedV2AlphaPayloadZ = void 0;
+const zod_1 = require("zod");
+const patterns_1 = require("../patterns");
+exports.gctlMintedV2AlphaPayloadZ = zod_1.z.object({
+    usdcAmount_6Decimals: zod_1.z
+        .string()
+        .regex(patterns_1.uint256, "uint256 (decimal) − 6 implied decimals"),
+    gctlAmount_6Decimals: zod_1.z
+        .string()
+        .regex(patterns_1.uint256, "uint256 (decimal) − 6 implied decimals"),
+    timestamp: zod_1.z.string().datetime(),
+    minter: zod_1.z.string().regex(patterns_1.ethAddress, "Ethereum address"),
+    txHash: zod_1.z.string().regex(patterns_1.hexBytes32, "bytes32 hex string"),
+});

package/dist/types.d.ts

@@ -3,15 +3,20 @@ import type { AuditPushedV1Payload } from "./schemas/audit-pushed.v1";
 import type { AuditSlashedV1Payload } from "./schemas/audit-slashed.v1";
 import type { AuditPfeesPaidV1Payload } from "./schemas/audit-pfees-paid.v1";
 import type { AuditPfeesPaidV2Payload } from "./schemas/audit-pfees-paid.v2";
+import type { AuditPfeesPaidV2AlphaPayload } from "./schemas/audit-pfees-paid.v2-alpha";
 import type { ApplicationCreatedV1Payload } from "./schemas/application-created.v1";
+import type { ApplicationPriceQuoteV2AlphaPayload } from "./schemas/application-price-quote.v2-alpha";
 import type { AuditPushedV2Payload } from "./schemas/audit-pushed.v2";
+import type { AuditPushedV2AlphaPayload } from "./schemas/audit-pushed.v2-alpha";
 import { eventTypes, EventType } from "./event-types";
+import type { GctlMintedV2AlphaPayload } from "./schemas/gctl-minted.v2-alpha";
 export { EventType, eventTypes };
-export type EventVersion = "v1" | "v2";
+export type EventVersion = "v1" | "v2" | "v2-alpha";
 export interface EventPayloadMap {
     [eventTypes.auditPushed]: {
         v1: AuditPushedV1Payload;
         v2: AuditPushedV2Payload;
+        "v2-alpha": AuditPushedV2AlphaPayload;
     };
     [eventTypes.auditSlashed]: {
         v1: AuditSlashedV1Payload;
@@ -19,10 +24,17 @@ export interface EventPayloadMap {
     [eventTypes.auditPfeesPaid]: {
         v1: AuditPfeesPaidV1Payload;
         v2: AuditPfeesPaidV2Payload;
+        "v2-alpha": AuditPfeesPaidV2AlphaPayload;
     };
     [eventTypes.applicationCreated]: {
         v1: ApplicationCreatedV1Payload;
     };
+    [eventTypes.applicationPriceQuote]: {
+        "v2-alpha": ApplicationPriceQuoteV2AlphaPayload;
+    };
+    [eventTypes.gctlMinted]: {
+        "v2-alpha": GctlMintedV2AlphaPayload;
+    };
 }
 export type EventPayload<T extends EventType, V extends keyof EventPayloadMap[T]> = T extends keyof EventPayloadMap ? V extends keyof EventPayloadMap[T] ? EventPayloadMap[T][V] : never : never;
 export interface GlowEvent<TPayload> extends Omit<BaseEvent, "payload"> {

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+import type { EventVersion } from "./types";
 /**
  * Validates that the zoneName matches the zoneId using the zoneMap.
  * Throws an error if the values are inconsistent.
@@ -7,7 +8,7 @@ export declare function validateZoneNameAndId(zoneId: number, zoneName: string):
  * Validates the event payload against the schema for the given eventType and schemaVersion.
  * Throws an error if the schema does not exist or the payload is invalid.
  */
-export declare function validateEventPayload(eventType: string, schemaVersion: "v1" | "v2", payload: any): void;
+export declare function validateEventPayload(eventType: string, schemaVersion: EventVersion, payload: any): void;
 /**
  * Processes a message object as the listener would, validating zone and schema.
  * Throws if validation fails, returns the parsed event otherwise.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glowlabs-org/events-sdk",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Typed event SDK for Glow, powered by RabbitMQ and Zod.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",