@glowlabs-org/events-sdk 1.0.0 → 1.0.2

package/README.md

@@ -24,8 +24,8 @@ The following zones are currently available:
 | 1       | Clean Grid Project |
 | 2       | Coming Soon Zone   |
 
-- Use `zoneId: 0` (with `zoneName: "All Zones"`) to emit to or listen to all zones.
-- The SDK types and runtime validation now officially support `zoneId: 0` and `zoneName: "All Zones"` everywhere (emitter, listener, event types).
+- Use `zoneId: 0` (with `zoneName: "All Zones"`) to listen to all zones. **Emitters must be constructed with a specific zoneId (not 0).**
+- The SDK types and runtime validation now officially support `zoneId: 0` and `zoneName: "All Zones"` everywhere for listeners, but not for emitters.
 
 ---
 
@@ -33,11 +33,13 @@ The following zones are currently available:
 
 Currently supported event types and versions:
 
-| Event Name         | Version | Payload Type              | Description                         |
-| ------------------ | ------- | ------------------------- | ----------------------------------- |
-| `audit.pushed`     | 1       | `AuditPushedV1Payload`    | Emitted when an audit is pushed     |
-| `audit.slashed`    | 1       | `AuditSlashedV1Payload`   | Emitted when a farm is slashed      |
-| `audit.pfees.paid` | 1       | `AuditPfeesPaidV1Payload` | Emitted when protocol fees are paid |
+| Event Name            | Version | Payload Type                  | Description                            |
+| --------------------- | ------- | ----------------------------- | -------------------------------------- |
+| `audit.pushed`        | 1       | `AuditPushedV1Payload`        | Emitted when an audit is pushed        |
+| `audit.slashed`       | 1       | `AuditSlashedV1Payload`       | Emitted when a farm is slashed         |
+| `audit.pfees.paid`    | 1       | `AuditPfeesPaidV1Payload`     | Paid (by applicationId)                |
+| `audit.pfees.paid`    | 2       | `AuditPfeesPaidV2Payload`     | Paid (by farmId)                       |
+| `application.created` | 1       | `ApplicationCreatedV1Payload` | Emitted when an application is created |
 
 ---
 
@@ -50,6 +52,7 @@ export interface AuditPushedV1Payload {
   farmId: string; // bytes32 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...)
 }
 ```
 
@@ -57,6 +60,7 @@ export interface AuditPushedV1Payload {
 
 - `farmId` must be a 32-byte hex string (e.g., `0x...`).
 - `protocolFeeUSDPrice_12Decimals` and `expectedProduction_12Decimals` must be decimal strings representing unsigned big integers.
+- `txHash` must be a 32-byte hex string (e.g., `0x...`).
 
 ### `audit.slashed` v1
 
@@ -64,6 +68,7 @@ export interface AuditPushedV1Payload {
 export interface AuditSlashedV1Payload {
   farmId: string; // bytes32 hex string (0x...)
   slasher: string; // Ethereum address (0x...)
+  txHash: string; // bytes32 hex string (0x...)
 }
 ```
 
@@ -71,14 +76,34 @@ export interface AuditSlashedV1Payload {
 
 - `farmId` must be a 32-byte hex string (e.g., `0x...`).
 - `slasher` must be a valid Ethereum address (0x...40 hex chars).
+- `txHash` must be a 32-byte hex string (e.g., `0x...`).
 
-### `audit.pfees.paid` v1
+### `audit.pfees.paid` v1 (by applicationId)
 
 ```ts
 export interface AuditPfeesPaidV1Payload {
+  applicationId: string; // bytes32 hex string (0x...)
+  payer: string; // Ethereum address (0x...)
+  amount_12Decimals: string; // uint256 (decimal) − 12 implied decimals
+  txHash: string; // bytes32 hex string (0x...)
+}
+```
+
+**Validation:**
+
+- `applicationId` must be a 32-byte hex string (e.g., `0x...`).
+- `payer` must be a valid Ethereum address (0x...40 hex chars).
+- `amount_12Decimals` must be a decimal string representing an unsigned big integer (12 implied decimals).
+- `txHash` must be a 32-byte hex string (e.g., `0x...`).
+
+### `audit.pfees.paid` v2 (by farmId)
+
+```ts
+export interface AuditPfeesPaidV2Payload {
   farmId: string; // bytes32 hex string (0x...)
   payer: string; // Ethereum address (0x...)
   amount_12Decimals: string; // uint256 (decimal) − 12 implied decimals
+  txHash: string; // bytes32 hex string (0x...)
 }
 ```
 
@@ -87,6 +112,27 @@ export interface AuditPfeesPaidV1Payload {
 - `farmId` must be a 32-byte hex string (e.g., `0x...`).
 - `payer` must be a valid Ethereum address (0x...40 hex chars).
 - `amount_12Decimals` must be a decimal string representing an unsigned big integer (12 implied decimals).
+- `txHash` must be a 32-byte hex string (e.g., `0x...`).
+
+### `application.created` v1
+
+```ts
+export interface ApplicationCreatedV1Payload {
+  gcaAddress: string; // Ethereum address (0x...)
+  lat: number;
+  lng: number;
+  estimatedCostOfPowerPerKWh: number;
+  estimatedKWhGeneratedPerYear: number;
+  installerCompanyName: string;
+}
+```
+
+**Validation:**
+
+- `gcaAddress` must be a valid Ethereum address (0x...40 hex chars).
+- `lat` and `lng` are numbers (coordinates).
+- `estimatedCostOfPowerPerKWh` and `estimatedKWhGeneratedPerYear` are numbers.
+- `installerCompanyName` is a string.
 
 ---
 
@@ -115,12 +161,33 @@ listener.onEvent("audit.slashed", 1, (event) => {
 listener.onEvent("audit.pfees.paid", 1, (event) => {
   console.log(
     "Received audit.pfees.paid v1:",
+    event.applicationId,
+    event.payer,
+    event.amount_12Decimals
+  );
+});
+
+listener.onEvent("audit.pfees.paid", 2, (event) => {
+  console.log(
+    "Received audit.pfees.paid v2:",
     event.farmId,
     event.payer,
     event.amount_12Decimals
   );
 });
 
+listener.onEvent("application.created", 1, (event) => {
+  console.log(
+    "Received application.created v1:",
+    event.gcaAddress,
+    event.lat,
+    event.lng,
+    event.estimatedCostOfPowerPerKWh,
+    event.estimatedKWhGeneratedPerYear,
+    event.installerCompanyName
+  );
+});
+
 await listener.start();
 // To stop listening:
 // await listener.stop();
@@ -131,10 +198,11 @@ await listener.start();
 ```ts
 import { createGlowEventEmitter } from "@glowlabs-org/events-sdk";
 
+// You must construct the emitter with a specific zoneId (not 0)
 const emitter = createGlowEventEmitter({
   username: "admin",
   password: "your-password-here",
-  zoneId: 1,
+  zoneId: 1, // must be a specific zone
 });
 
 await emitter.emit({
@@ -160,62 +228,47 @@ await emitter.emit({
   eventType: "audit.pfees.paid",
   schemaVersion: 1,
   payload: {
-    farmId: "0x...",
+    applicationId: "0x...",
     payer: "0x...",
     amount_12Decimals: "1000000000000",
   },
 });
 
-await emitter.disconnect();
-```
-
-### 🌐 Emitting or Listening to All Zones
-
-You can emit to or listen to **all zones at once** by passing `zoneId: 0` to the emitter or listener.
-
-#### Emit to All Zones
-
-```ts
-import { createGlowEventEmitter } from "@glowlabs-org/events-sdk";
-
-const emitter = createGlowEventEmitter({
-  username: "admin",
-  password: "your-password-here",
-  zoneId: 0, // special value for all zones
-});
-
-await emitter.emit({
-  eventType: "audit.pushed",
-  schemaVersion: 1,
-  payload: {
-    farmId: "0x...",
-    protocolFeeUSDPrice_12Decimals: "...",
-    expectedProduction_12Decimals: "...",
-  },
-});
-
 await emitter.emit({
-  eventType: "audit.slashed",
-  schemaVersion: 1,
+  eventType: "audit.pfees.paid",
+  schemaVersion: 2,
   payload: {
     farmId: "0x...",
-    slasher: "0x...",
+    payer: "0x...",
+    amount_12Decimals: "1000000000000",
   },
 });
 
 await emitter.emit({
-  eventType: "audit.pfees.paid",
+  eventType: "application.created",
   schemaVersion: 1,
   payload: {
-    farmId: "0x...",
-    payer: "0x...",
-    amount_12Decimals: "1000000000000",
+    gcaAddress: "0x...",
+    lat: 45.5017,
+    lng: -73.5673,
+    estimatedCostOfPowerPerKWh: 0.12,
+    estimatedKWhGeneratedPerYear: 10000,
+    installerCompanyName: "SolarCo",
   },
 });
 
 await emitter.disconnect();
 ```
 
+> **Note:**
+>
+> - 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.
+
+### 🌐 Listening to All Zones
+
+You can listen to **all zones at once** by passing `zoneId: 0` to the listener. **Emitters must always use a specific zone.**
+
 #### Listen to All Zones
 
 ```ts
@@ -243,12 +296,33 @@ listener.onEvent("audit.slashed", 1, (event) => {
 listener.onEvent("audit.pfees.paid", 1, (event) => {
   console.log(
     "Received audit.pfees.paid v1 from any zone:",
+    event.applicationId,
+    event.payer,
+    event.amount_12Decimals
+  );
+});
+
+listener.onEvent("audit.pfees.paid", 2, (event) => {
+  console.log(
+    "Received audit.pfees.paid v2 from any zone:",
     event.farmId,
     event.payer,
     event.amount_12Decimals
   );
 });
 
+listener.onEvent("application.created", 1, (event) => {
+  console.log(
+    "Received application.created v1 from any zone:",
+    event.gcaAddress,
+    event.lat,
+    event.lng,
+    event.estimatedCostOfPowerPerKWh,
+    event.estimatedKWhGeneratedPerYear,
+    event.installerCompanyName
+  );
+});
+
 await listener.start();
 // To stop listening:
 // await listener.stop();

package/dist/base-event.d.ts

@@ -4,29 +4,62 @@ export declare const baseEventZ: z.ZodObject<{
     id: z.ZodString;
     zoneId: z.ZodEffects<z.ZodNumber, number, number>;
     zoneName: z.ZodEnum<[string, ...string[]]>;
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodEffects<z.ZodNumber, 1 | 2, number>;
     eventType: z.ZodEnum<["audit.pushed", "audit.slashed", "audit.pfees.paid"]>;
     timeStamp: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     id: string;
     zoneId: number;
     zoneName: string;
-    schemaVersion: 1;
+    schemaVersion: 1 | 2;
     eventType: "audit.pushed" | "audit.slashed" | "audit.pfees.paid";
     timeStamp: number;
 }, {
     id: string;
     zoneId: number;
     zoneName: string;
-    schemaVersion: 1;
+    schemaVersion: number;
     eventType: "audit.pushed" | "audit.slashed" | "audit.pfees.paid";
     timeStamp: number;
 }>;
-export interface BaseEvent {
+export interface BaseEventAuditPushedV1 {
     id: string;
     zoneId: number;
     zoneName: ZoneName;
     schemaVersion: 1;
-    eventType: "audit.pushed" | "audit.slashed" | "audit.pfees.paid";
+    eventType: "audit.pushed";
+    timeStamp: number;
+}
+export interface BaseEventAuditSlashedV1 {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 1;
+    eventType: "audit.slashed";
+    timeStamp: number;
+}
+export interface BaseEventAuditPfeesPaidV1 {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 1;
+    eventType: "audit.pfees.paid";
+    timeStamp: number;
+}
+export interface BaseEventAuditPfeesPaidV2 {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 2;
+    eventType: "audit.pfees.paid";
+    timeStamp: number;
+}
+export interface BaseEventApplicationCreatedV1 {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 1;
+    eventType: "application.created";
     timeStamp: number;
 }
+export type BaseEvent = BaseEventAuditPushedV1 | BaseEventAuditSlashedV1 | BaseEventAuditPfeesPaidV1 | BaseEventAuditPfeesPaidV2 | BaseEventApplicationCreatedV1;

package/dist/base-event.js

@@ -11,7 +11,12 @@ exports.baseEventZ = zod_1.z.object({
         message: "Invalid zoneId",
     }),
     zoneName: zod_1.z.enum(zoneNames),
-    schemaVersion: zod_1.z.literal(1),
+    schemaVersion: zod_1.z
+        .number()
+        .int()
+        .refine((v) => v === 1 || v === 2, {
+        message: "Invalid schemaVersion",
+    }),
     eventType: zod_1.z.enum(["audit.pushed", "audit.slashed", "audit.pfees.paid"]),
     timeStamp: zod_1.z.number().int(),
 });

package/dist/emitter.d.ts

@@ -8,7 +8,6 @@ interface CreateGlowEventEmitterOptions {
 interface EmitEventArgs<T extends EventType, V extends EventVersion<T>> {
     eventType: T;
     schemaVersion: V;
-    zoneId: number;
     payload: EventPayload<T, V>;
 }
 export declare function createGlowEventEmitter({ username, password, zoneId, exchangePrefix, }: CreateGlowEventEmitterOptions): {

package/dist/emitter.js

@@ -11,8 +11,9 @@ const zones_1 = require("./zones");
 function createGlowEventEmitter({ username, password, zoneId, exchangePrefix = "glow.zone-", }) {
     let amqpConnection = null;
     let amqpChannel = null;
-    // Use a special exchange for all zones if zoneId is 0
-    const exchangeName = `${exchangePrefix}${zoneId}.events`;
+    // Exchanges for global and specific zone
+    const globalExchangeName = `${exchangePrefix}0.events`;
+    const zoneExchangeName = `${exchangePrefix}${zoneId}.events`;
     function buildAmqpUrl() {
         const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
         return url.toString();
@@ -23,16 +24,21 @@ function createGlowEventEmitter({ username, password, zoneId, exchangePrefix = "
             amqpChannel = (await amqpConnection.createChannel());
         }
         if (amqpChannel) {
-            await amqpChannel.assertExchange(exchangeName, "topic", {
+            await amqpChannel.assertExchange(globalExchangeName, "topic", {
+                durable: true,
+            });
+            await amqpChannel.assertExchange(zoneExchangeName, "topic", {
                 durable: true,
             });
         }
     }
     async function emit(args) {
-        const { eventType, schemaVersion, zoneId, payload } = args;
+        const { eventType, schemaVersion, payload } = args;
         const zoneName = zones_1.zoneMap[String(zoneId)];
         if (!zoneName)
             throw new Error(`Invalid zoneId: ${zoneId}`);
+        if (zoneId === 0)
+            throw new Error("Cannot emit events with zoneId 0. Use a specific zone emitter.");
         const event = {
             id: (0, uuid_1.v4)(),
             eventType,
@@ -46,7 +52,9 @@ function createGlowEventEmitter({ username, password, zoneId, exchangePrefix = "
         (0, utils_1.validateEventPayload)(event.eventType, event.schemaVersion, event);
         const routingKey = `${event.eventType}.v${event.schemaVersion}`;
         await connectIfNeeded();
-        amqpChannel.publish(exchangeName, routingKey, Buffer.from(JSON.stringify(event)), { persistent: true });
+        // 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 });
     }
     async function disconnect() {
         if (amqpConnection) {

package/dist/event-registry.js

@@ -4,13 +4,21 @@ exports.getEventSchema = getEventSchema;
 const audit_pushed_v1_1 = require("./schemas/audit-pushed.v1");
 const audit_slashed_v1_1 = require("./schemas/audit-slashed.v1");
 const audit_pfees_paid_v1_1 = require("./schemas/audit-pfees-paid.v1");
+const audit_pfees_paid_v2_1 = require("./schemas/audit-pfees-paid.v2");
 const base_event_1 = require("./base-event");
+const application_created_v1_1 = require("./schemas/application-created.v1");
 const eventTypeRegistry = {
     "audit.pushed:v1": base_event_1.baseEventZ.extend({ payload: audit_pushed_v1_1.auditPushedV1PayloadZ }),
     "audit.slashed:v1": base_event_1.baseEventZ.extend({ payload: audit_slashed_v1_1.auditSlashedV1PayloadZ }),
     "audit.pfees.paid:v1": base_event_1.baseEventZ.extend({
         payload: audit_pfees_paid_v1_1.auditPfeesPaidV1PayloadZ,
     }),
+    "audit.pfees.paid:v2": base_event_1.baseEventZ.extend({
+        payload: audit_pfees_paid_v2_1.auditPfeesPaidV2PayloadZ,
+    }),
+    "application.created:v1": base_event_1.baseEventZ.extend({
+        payload: application_created_v1_1.applicationCreatedV1PayloadZ,
+    }),
     // Add more event types/versions here
 };
 function getEventSchema(eventType, version) {

package/dist/schemas/application-created.v1.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const applicationCreatedV1PayloadZ: z.ZodObject<{
+    gcaAddress: z.ZodString;
+    lat: z.ZodNumber;
+    lng: z.ZodNumber;
+    estimatedCostOfPowerPerKWh: z.ZodNumber;
+    estimatedKWhGeneratedPerYear: z.ZodNumber;
+    installerCompanyName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    gcaAddress: string;
+    lat: number;
+    lng: number;
+    estimatedCostOfPowerPerKWh: number;
+    estimatedKWhGeneratedPerYear: number;
+    installerCompanyName: string;
+}, {
+    gcaAddress: string;
+    lat: number;
+    lng: number;
+    estimatedCostOfPowerPerKWh: number;
+    estimatedKWhGeneratedPerYear: number;
+    installerCompanyName: string;
+}>;
+export interface ApplicationCreatedV1Payload extends z.infer<typeof applicationCreatedV1PayloadZ> {
+}

package/dist/schemas/application-created.v1.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applicationCreatedV1PayloadZ = void 0;
+const zod_1 = require("zod");
+exports.applicationCreatedV1PayloadZ = zod_1.z.object({
+    gcaAddress: zod_1.z.string().regex(/^0x[a-fA-F0-9]{40}$/), // eth address
+    lat: zod_1.z.number(),
+    lng: zod_1.z.number(),
+    estimatedCostOfPowerPerKWh: zod_1.z.number(),
+    estimatedKWhGeneratedPerYear: zod_1.z.number(),
+    installerCompanyName: zod_1.z.string(),
+});

package/dist/schemas/audit-pfees-paid.v1.d.ts

@@ -1,14 +1,17 @@
 import { z } from "zod";
 export declare const auditPfeesPaidV1PayloadZ: z.ZodObject<{
-    farmId: z.ZodString;
+    applicationId: z.ZodString;
     payer: z.ZodString;
     amount_12Decimals: z.ZodString;
+    txHash: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    farmId: string;
+    txHash: string;
+    applicationId: string;
     payer: string;
     amount_12Decimals: string;
 }, {
-    farmId: string;
+    txHash: string;
+    applicationId: string;
     payer: string;
     amount_12Decimals: string;
 }>;

package/dist/schemas/audit-pfees-paid.v1.js

@@ -6,9 +6,10 @@ const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
 const ethAddress = /^0x[0-9a-fA-F]{40}$/;
 const uint256 = /^[0-9]+$/;
 exports.auditPfeesPaidV1PayloadZ = zod_1.z.object({
-    farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    applicationId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
     payer: zod_1.z.string().regex(ethAddress, "Ethereum address"),
     amount_12Decimals: zod_1.z
         .string()
         .regex(uint256, "uint256 (decimal) − 12 implied decimals"),
+    txHash: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
 });

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const auditPfeesPaidV2PayloadZ: z.ZodObject<{
+    farmId: z.ZodString;
+    payer: z.ZodString;
+    amount_12Decimals: z.ZodString;
+    txHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    farmId: string;
+    txHash: string;
+    payer: string;
+    amount_12Decimals: string;
+}, {
+    farmId: string;
+    txHash: string;
+    payer: string;
+    amount_12Decimals: string;
+}>;
+export type AuditPfeesPaidV2Payload = z.infer<typeof auditPfeesPaidV2PayloadZ>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditPfeesPaidV2PayloadZ = void 0;
+const zod_1 = require("zod");
+const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
+const ethAddress = /^0x[0-9a-fA-F]{40}$/;
+const uint256 = /^[0-9]+$/;
+exports.auditPfeesPaidV2PayloadZ = zod_1.z.object({
+    farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    payer: zod_1.z.string().regex(ethAddress, "Ethereum address"),
+    amount_12Decimals: zod_1.z
+        .string()
+        .regex(uint256, "uint256 (decimal) − 12 implied decimals"),
+    txHash: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+});

package/dist/schemas/audit-pushed.v1.d.ts

@@ -3,13 +3,16 @@ export declare const auditPushedV1PayloadZ: z.ZodObject<{
     farmId: z.ZodString;
     protocolFeeUSDPrice_12Decimals: z.ZodString;
     expectedProduction_12Decimals: z.ZodString;
+    txHash: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     farmId: string;
     protocolFeeUSDPrice_12Decimals: string;
     expectedProduction_12Decimals: string;
+    txHash: string;
 }, {
     farmId: string;
     protocolFeeUSDPrice_12Decimals: string;
     expectedProduction_12Decimals: string;
+    txHash: string;
 }>;
 export type AuditPushedV1Payload = z.infer<typeof auditPushedV1PayloadZ>;

package/dist/schemas/audit-pushed.v1.js

@@ -10,4 +10,5 @@ exports.auditPushedV1PayloadZ = zod_1.z.object({
         .string()
         .regex(uint256, "uint256 (decimal) − 12 implied decimals"),
     expectedProduction_12Decimals: zod_1.z.string().regex(uint256),
+    txHash: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
 });

package/dist/schemas/audit-slashed.v1.d.ts

@@ -2,11 +2,14 @@ import { z } from "zod";
 export declare const auditSlashedV1PayloadZ: z.ZodObject<{
     farmId: z.ZodString;
     slasher: z.ZodString;
+    txHash: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     farmId: string;
+    txHash: string;
     slasher: string;
 }, {
     farmId: string;
+    txHash: string;
     slasher: string;
 }>;
 export type AuditSlashedV1Payload = z.infer<typeof auditSlashedV1PayloadZ>;

package/dist/schemas/audit-slashed.v1.js

@@ -7,4 +7,5 @@ const ethAddress = /^0x[0-9a-fA-F]{40}$/;
 exports.auditSlashedV1PayloadZ = zod_1.z.object({
     farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
     slasher: zod_1.z.string().regex(ethAddress, "Ethereum address"),
+    txHash: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
 });

package/dist/types.d.ts

@@ -2,8 +2,16 @@ import type { BaseEvent } from "./base-event";
 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 { ApplicationCreatedV1Payload } from "./schemas/application-created.v1";
 export type EventType = BaseEvent["eventType"];
-export type EventVersion<T extends EventType> = T extends "audit.pushed" ? 1 : T extends "audit.slashed" ? 1 : T extends "audit.pfees.paid" ? 1 : never;
+type EventTypeToVersion = {
+    "audit.pushed": 1;
+    "audit.slashed": 1;
+    "audit.pfees.paid": 1 | 2;
+    "application.created": 1;
+};
+export type EventVersion<T extends EventType> = T extends keyof EventTypeToVersion ? EventTypeToVersion[T] : never;
 export interface EventPayloadMap {
     "audit.pushed": {
         1: AuditPushedV1Payload;
@@ -13,9 +21,14 @@ export interface EventPayloadMap {
     };
     "audit.pfees.paid": {
         1: AuditPfeesPaidV1Payload;
+        2: AuditPfeesPaidV2Payload;
+    };
+    "application.created": {
+        1: ApplicationCreatedV1Payload;
     };
 }
 export type EventPayload<T extends EventType, V extends EventVersion<T>> = T extends keyof EventPayloadMap ? V extends keyof EventPayloadMap[T] ? EventPayloadMap[T][V] : never : never;
 export interface GlowEvent<TPayload> extends Omit<BaseEvent, "payload"> {
     payload: TPayload;
 }
+export {};

package/package.json

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