@omen.foundation/game-sdk 1.0.16 → 1.0.18

package/README.md

@@ -12,6 +12,12 @@ The SDK supports two modes:
 npm install @omen.foundation/game-sdk
 ```
 
+For **real-time updates** (balance & inventory), also install Ably:
+
+```bash
+npm install ably
+```
+
 ## Quick Start
 
 ### Client Mode (OAuth Authentication)
@@ -188,6 +194,51 @@ if (sdk.isAuthenticated()) {
 await sdk.logout();
 ```
 
+### Real-Time Updates (Balance & Inventory)
+
+So your game stays in sync when the user spends or receives OmenX / NFTs on the website or in another client, subscribe to the per-wallet Ably channel. The SDK provides the channel name, event names, and a subscribe helper with idempotency (eventId dedupe).
+
+**Requires:** `ably` installed in your app. Use the same Ably API key as the OmenX frontend (subscribe capability for `wallet:*`).
+
+```typescript
+import { subscribeWalletRealtime, getWalletChannelName, REALTIME_EVENTS } from '@omen.foundation/game-sdk';
+import * as Ably from 'ably';
+
+// After user logs in and you have their wallet address:
+const ably = new Ably.Realtime({ key: 'YOUR_ABLY_API_KEY' });
+
+const unsubscribe = subscribeWalletRealtime(ably, walletAddress, {
+  onBalance: (payload) => {
+    // Refetch balances (e.g. call your backend or GetPlayerBalances)
+    refetchBalances();
+  },
+  onInventory: (payload) => {
+    // Refetch inventory / NFTs (backend cache is source of truth)
+    refetchInventory();
+  },
+});
+
+// When user logs out or wallet changes:
+unsubscribe();
+```
+
+With React and `ably/react`, pass the client from `useAbly()`:
+
+```typescript
+import { useAbly } from 'ably/react';
+import { subscribeWalletRealtime } from '@omen.foundation/game-sdk';
+
+// Inside your component, after wallet is available:
+const ably = useAbly();
+useEffect(() => {
+  if (!walletAddress || !ably) return;
+  return subscribeWalletRealtime(ably, walletAddress, {
+    onBalance: () => refetchBalances(),
+    onInventory: () => refetchInventory(),
+  });
+}, [ably, walletAddress]);
+```
+
 ## API Reference
 
 See the [full documentation](./docs/README.md) for detailed API reference.

package/dist/index.d.mts

@@ -276,13 +276,15 @@ declare class OmenXServerSDK {
      * NFT Template Operations
      */
     /**
-     * Get all NFT templates for a game
+     * Get all NFT templates for the authenticated game (game is derived from API key).
+     * gameId is optional and ignored by the API; included for backward compatibility.
      */
-    getNftTemplates(gameId: string): Promise<any>;
+    getNftTemplates(_gameId?: string): Promise<any>;
     /**
-     * Get NFT contract address for a game
+     * Get NFT contract address for the authenticated game (game is derived from API key).
+     * gameId is optional and ignored by the API; included for backward compatibility.
      */
-    getNftContract(gameId: string): Promise<any>;
+    getNftContract(_gameId?: string): Promise<any>;
     /**
      * Mint NFTs (single or batch)
      */
@@ -344,6 +346,151 @@ declare class OmenXServerSDK {
             phaseIndex?: number;
         };
     }>;
+    /**
+     * Quests API (game quests only).
+     * Requires scope: quests:read for getQuestsForPlayer; quests:write for assign, progress, complete, claim.
+     */
+    /** Get assigned quests for a player. Optional questType filter. */
+    getQuestsForPlayer(wallet: string, options?: {
+        questType?: 'daily' | 'weekly' | 'monthly' | 'oneTime';
+    }): Promise<{
+        success: boolean;
+        data: {
+            quests: any[];
+        };
+    }>;
+    /** Assign quests of a type to a player. Use idempotencyKey for safe retries. */
+    assignQuests(wallet: string, questType: 'daily' | 'weekly' | 'monthly' | 'oneTime', count: number, options?: {
+        idempotencyKey?: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            assigned: number;
+            assignmentIds?: string[];
+        };
+    }>;
+    /** Report progress for a quest step. Quest auto-completes when all steps meet targets. */
+    reportQuestProgress(wallet: string, questKey: string, value: number, options?: {
+        stepKey?: string;
+    }): Promise<{
+        success: boolean;
+        data?: object;
+    }>;
+    /** Mark a quest complete (all steps set to targets). */
+    completeQuest(wallet: string, questKey: string): Promise<{
+        success: boolean;
+        data?: object;
+    }>;
+    /** Claim VIP reward for a completed quest (from game pool). Use idempotencyKey for safe retries. */
+    claimQuestReward(wallet: string, questKey: string, options?: {
+        idempotencyKey?: string;
+    }): Promise<{
+        success: boolean;
+        data?: {
+            pointsGranted?: number;
+        };
+    }>;
+    /**
+     * Reset or wipe a player's quest state for this game. Requires quests:write.
+     * - wipe: delete all quest assignments for this game for the player.
+     * - reset: delete assignments for the specified questKey only (questKey required).
+     */
+    resetPlayerQuests(wallet: string, action: 'wipe' | 'reset', questKey?: string): Promise<{
+        success: boolean;
+        data: {
+            action: string;
+            deleted: number;
+            questKey?: string;
+        };
+    }>;
+}
+
+/**
+ * Real-time wallet updates (balance & inventory) for game clients.
+ * Subscribe to the per-wallet Ably channel so the game stays in sync when the user
+ * spends or receives OmenX / NFTs on the website or in another client.
+ *
+ * Two options:
+ * 1. subscribeWalletRealtimeWithOmenXAuth – no API key needed; SDK gets a scoped token from the OmenX platform using your access token.
+ * 2. subscribeWalletRealtime – pass your own Ably Realtime instance (e.g. from an API key or your own token).
+ */
+/** Payload for balance and inventory events. Use eventId for idempotency (ignore if already processed). */
+interface RealtimeWalletPayload {
+    eventId: string;
+    timestamp: number;
+    reason?: string;
+}
+/** Ably channel name prefix. Full channel = "wallet:" + normalized wallet address. */
+declare const WALLET_CHANNEL_PREFIX = "wallet:";
+/** Event names published by the OmenX backend on the wallet channel. */
+declare const REALTIME_EVENTS: {
+    /** Currency balance changed. Refetch via GetPlayerBalances or your balance API. */
+    readonly balance: "balance";
+    /** NFT/inventory changed. Refetch via GetPlayerNfts or your inventory API (cache is source of truth). */
+    readonly inventory: "inventory";
+};
+/**
+ * Get the Ably channel name for a wallet. Use this when subscribing with your Ably client.
+ */
+declare function getWalletChannelName(walletAddress: string): string;
+/**
+ * Minimal Ably Realtime interface so the SDK works with any Ably.Realtime instance.
+ * The app provides the real Ably client from AblyProvider or new Ably.Realtime({ key }).
+ */
+interface AblyRealtimeLike {
+    channels: {
+        get(name: string): {
+            subscribe(eventOrCallback: string | ((message: {
+                name: string;
+                data: unknown;
+            }) => void), callback?: (message: {
+                name: string;
+                data: unknown;
+            }) => void): void;
+            unsubscribe(eventOrCallback?: string | ((message: {
+                name: string;
+                data: unknown;
+            }) => void), callback?: (message: {
+                name: string;
+                data: unknown;
+            }) => void): void;
+        };
+    };
+}
+/**
+ * Subscribe to real-time balance and inventory events for a wallet.
+ * Call when the user logs in; call the returned unsubscribe when they log out or wallet changes.
+ *
+ * Uses eventId to dedupe (ignores already-seen events). Refetch in your app on each callback.
+ *
+ * @param ably - Ably Realtime instance (e.g. from useAbly() or new Ably.Realtime({ key }))
+ * @param walletAddress - Current player wallet (0x...)
+ * @param callbacks - onBalance and/or onInventory; each receives the payload (eventId, timestamp, reason?)
+ * @returns Unsubscribe function
+ */
+declare function subscribeWalletRealtime(ably: AblyRealtimeLike, walletAddress: string, callbacks: {
+    onBalance?: (payload: RealtimeWalletPayload) => void;
+    onInventory?: (payload: RealtimeWalletPayload) => void;
+}): () => void;
+/** Options for subscribing via OmenX platform token (no Ably API key required). */
+interface SubscribeWalletRealtimeWithOmenXAuthOptions {
+    /** Base URL of the OmenX API (e.g. https://api.omen.foundation). No trailing slash. */
+    apiBaseUrl: string;
+    /** Returns the current OmenX access token (from your OAuth flow). Called when Ably needs to authenticate. */
+    getAccessToken: () => Promise<string | null>;
+    /** Wallet address (0x...) to subscribe to. Must match the wallet in the access token. */
+    walletAddress: string;
+    onBalance?: (payload: RealtimeWalletPayload) => void;
+    onInventory?: (payload: RealtimeWalletPayload) => void;
 }
+/**
+ * Subscribe to real-time balance and inventory for a wallet using OmenX platform auth.
+ * The SDK fetches a short-lived, subscribe-only Ably token from the OmenX API using your
+ * access token. No Ably API key or .env is required – ideal for third-party developers.
+ *
+ * Requires the app to have `ably` installed (peer dependency). Call when the user is
+ * logged in; call the returned function on logout or wallet change.
+ */
+declare function subscribeWalletRealtimeWithOmenXAuth(options: SubscribeWalletRealtimeWithOmenXAuthOptions): () => void;
 
-export { type ApiCallOptions, type AuthData, type OAuthOptions, OmenXGameSDK, type OmenXGameSDKConfig, OmenXServerSDK, type UserInfo, type VipStatus, type VipTierInfo };
+export { type AblyRealtimeLike, type ApiCallOptions, type AuthData, type OAuthOptions, OmenXGameSDK, type OmenXGameSDKConfig, OmenXServerSDK, REALTIME_EVENTS, type RealtimeWalletPayload, type SubscribeWalletRealtimeWithOmenXAuthOptions, type UserInfo, type VipStatus, type VipTierInfo, WALLET_CHANNEL_PREFIX, getWalletChannelName, subscribeWalletRealtime, subscribeWalletRealtimeWithOmenXAuth };

package/dist/index.d.ts

@@ -276,13 +276,15 @@ declare class OmenXServerSDK {
      * NFT Template Operations
      */
     /**
-     * Get all NFT templates for a game
+     * Get all NFT templates for the authenticated game (game is derived from API key).
+     * gameId is optional and ignored by the API; included for backward compatibility.
      */
-    getNftTemplates(gameId: string): Promise<any>;
+    getNftTemplates(_gameId?: string): Promise<any>;
     /**
-     * Get NFT contract address for a game
+     * Get NFT contract address for the authenticated game (game is derived from API key).
+     * gameId is optional and ignored by the API; included for backward compatibility.
      */
-    getNftContract(gameId: string): Promise<any>;
+    getNftContract(_gameId?: string): Promise<any>;
     /**
      * Mint NFTs (single or batch)
      */
@@ -344,6 +346,151 @@ declare class OmenXServerSDK {
             phaseIndex?: number;
         };
     }>;
+    /**
+     * Quests API (game quests only).
+     * Requires scope: quests:read for getQuestsForPlayer; quests:write for assign, progress, complete, claim.
+     */
+    /** Get assigned quests for a player. Optional questType filter. */
+    getQuestsForPlayer(wallet: string, options?: {
+        questType?: 'daily' | 'weekly' | 'monthly' | 'oneTime';
+    }): Promise<{
+        success: boolean;
+        data: {
+            quests: any[];
+        };
+    }>;
+    /** Assign quests of a type to a player. Use idempotencyKey for safe retries. */
+    assignQuests(wallet: string, questType: 'daily' | 'weekly' | 'monthly' | 'oneTime', count: number, options?: {
+        idempotencyKey?: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            assigned: number;
+            assignmentIds?: string[];
+        };
+    }>;
+    /** Report progress for a quest step. Quest auto-completes when all steps meet targets. */
+    reportQuestProgress(wallet: string, questKey: string, value: number, options?: {
+        stepKey?: string;
+    }): Promise<{
+        success: boolean;
+        data?: object;
+    }>;
+    /** Mark a quest complete (all steps set to targets). */
+    completeQuest(wallet: string, questKey: string): Promise<{
+        success: boolean;
+        data?: object;
+    }>;
+    /** Claim VIP reward for a completed quest (from game pool). Use idempotencyKey for safe retries. */
+    claimQuestReward(wallet: string, questKey: string, options?: {
+        idempotencyKey?: string;
+    }): Promise<{
+        success: boolean;
+        data?: {
+            pointsGranted?: number;
+        };
+    }>;
+    /**
+     * Reset or wipe a player's quest state for this game. Requires quests:write.
+     * - wipe: delete all quest assignments for this game for the player.
+     * - reset: delete assignments for the specified questKey only (questKey required).
+     */
+    resetPlayerQuests(wallet: string, action: 'wipe' | 'reset', questKey?: string): Promise<{
+        success: boolean;
+        data: {
+            action: string;
+            deleted: number;
+            questKey?: string;
+        };
+    }>;
+}
+
+/**
+ * Real-time wallet updates (balance & inventory) for game clients.
+ * Subscribe to the per-wallet Ably channel so the game stays in sync when the user
+ * spends or receives OmenX / NFTs on the website or in another client.
+ *
+ * Two options:
+ * 1. subscribeWalletRealtimeWithOmenXAuth – no API key needed; SDK gets a scoped token from the OmenX platform using your access token.
+ * 2. subscribeWalletRealtime – pass your own Ably Realtime instance (e.g. from an API key or your own token).
+ */
+/** Payload for balance and inventory events. Use eventId for idempotency (ignore if already processed). */
+interface RealtimeWalletPayload {
+    eventId: string;
+    timestamp: number;
+    reason?: string;
+}
+/** Ably channel name prefix. Full channel = "wallet:" + normalized wallet address. */
+declare const WALLET_CHANNEL_PREFIX = "wallet:";
+/** Event names published by the OmenX backend on the wallet channel. */
+declare const REALTIME_EVENTS: {
+    /** Currency balance changed. Refetch via GetPlayerBalances or your balance API. */
+    readonly balance: "balance";
+    /** NFT/inventory changed. Refetch via GetPlayerNfts or your inventory API (cache is source of truth). */
+    readonly inventory: "inventory";
+};
+/**
+ * Get the Ably channel name for a wallet. Use this when subscribing with your Ably client.
+ */
+declare function getWalletChannelName(walletAddress: string): string;
+/**
+ * Minimal Ably Realtime interface so the SDK works with any Ably.Realtime instance.
+ * The app provides the real Ably client from AblyProvider or new Ably.Realtime({ key }).
+ */
+interface AblyRealtimeLike {
+    channels: {
+        get(name: string): {
+            subscribe(eventOrCallback: string | ((message: {
+                name: string;
+                data: unknown;
+            }) => void), callback?: (message: {
+                name: string;
+                data: unknown;
+            }) => void): void;
+            unsubscribe(eventOrCallback?: string | ((message: {
+                name: string;
+                data: unknown;
+            }) => void), callback?: (message: {
+                name: string;
+                data: unknown;
+            }) => void): void;
+        };
+    };
+}
+/**
+ * Subscribe to real-time balance and inventory events for a wallet.
+ * Call when the user logs in; call the returned unsubscribe when they log out or wallet changes.
+ *
+ * Uses eventId to dedupe (ignores already-seen events). Refetch in your app on each callback.
+ *
+ * @param ably - Ably Realtime instance (e.g. from useAbly() or new Ably.Realtime({ key }))
+ * @param walletAddress - Current player wallet (0x...)
+ * @param callbacks - onBalance and/or onInventory; each receives the payload (eventId, timestamp, reason?)
+ * @returns Unsubscribe function
+ */
+declare function subscribeWalletRealtime(ably: AblyRealtimeLike, walletAddress: string, callbacks: {
+    onBalance?: (payload: RealtimeWalletPayload) => void;
+    onInventory?: (payload: RealtimeWalletPayload) => void;
+}): () => void;
+/** Options for subscribing via OmenX platform token (no Ably API key required). */
+interface SubscribeWalletRealtimeWithOmenXAuthOptions {
+    /** Base URL of the OmenX API (e.g. https://api.omen.foundation). No trailing slash. */
+    apiBaseUrl: string;
+    /** Returns the current OmenX access token (from your OAuth flow). Called when Ably needs to authenticate. */
+    getAccessToken: () => Promise<string | null>;
+    /** Wallet address (0x...) to subscribe to. Must match the wallet in the access token. */
+    walletAddress: string;
+    onBalance?: (payload: RealtimeWalletPayload) => void;
+    onInventory?: (payload: RealtimeWalletPayload) => void;
 }
+/**
+ * Subscribe to real-time balance and inventory for a wallet using OmenX platform auth.
+ * The SDK fetches a short-lived, subscribe-only Ably token from the OmenX API using your
+ * access token. No Ably API key or .env is required – ideal for third-party developers.
+ *
+ * Requires the app to have `ably` installed (peer dependency). Call when the user is
+ * logged in; call the returned function on logout or wallet change.
+ */
+declare function subscribeWalletRealtimeWithOmenXAuth(options: SubscribeWalletRealtimeWithOmenXAuthOptions): () => void;
 
-export { type ApiCallOptions, type AuthData, type OAuthOptions, OmenXGameSDK, type OmenXGameSDKConfig, OmenXServerSDK, type UserInfo, type VipStatus, type VipTierInfo };
+export { type AblyRealtimeLike, type ApiCallOptions, type AuthData, type OAuthOptions, OmenXGameSDK, type OmenXGameSDKConfig, OmenXServerSDK, REALTIME_EVENTS, type RealtimeWalletPayload, type SubscribeWalletRealtimeWithOmenXAuthOptions, type UserInfo, type VipStatus, type VipTierInfo, WALLET_CHANNEL_PREFIX, getWalletChannelName, subscribeWalletRealtime, subscribeWalletRealtimeWithOmenXAuth };

package/dist/index.js

@@ -1,5 +1,11 @@
 'use strict';
 
+var Ably = require('ably');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Ably__default = /*#__PURE__*/_interopDefault(Ably);
+
 // src/oauth.ts
 var OAuthFlow = class {
   constructor(config) {
@@ -630,17 +636,19 @@ var OmenXServerSDK = class {
    * NFT Template Operations
    */
   /**
-   * Get all NFT templates for a game
+   * Get all NFT templates for the authenticated game (game is derived from API key).
+   * gameId is optional and ignored by the API; included for backward compatibility.
    */
-  async getNftTemplates(gameId) {
-    const response = await this.apiCall(`/v1/nfts/templates?gameId=${gameId}`);
+  async getNftTemplates(_gameId) {
+    const response = await this.apiCall("/v1/nfts/templates");
     return response.json();
   }
   /**
-   * Get NFT contract address for a game
+   * Get NFT contract address for the authenticated game (game is derived from API key).
+   * gameId is optional and ignored by the API; included for backward compatibility.
    */
-  async getNftContract(gameId) {
-    const response = await this.apiCall(`/v1/nfts/contract?gameId=${gameId}`);
+  async getNftContract(_gameId) {
+    const response = await this.apiCall("/v1/nfts/contract");
     return response.json();
   }
   /**
@@ -715,9 +723,162 @@ var OmenXServerSDK = class {
     });
     return response.json();
   }
+  /**
+   * Quests API (game quests only).
+   * Requires scope: quests:read for getQuestsForPlayer; quests:write for assign, progress, complete, claim.
+   */
+  /** Get assigned quests for a player. Optional questType filter. */
+  async getQuestsForPlayer(wallet, options) {
+    const q = options?.questType ? `?questType=${options.questType}` : "";
+    const response = await this.apiCall(`/v1/quests/players/${encodeURIComponent(wallet)}${q}`);
+    return response.json();
+  }
+  /** Assign quests of a type to a player. Use idempotencyKey for safe retries. */
+  async assignQuests(wallet, questType, count, options) {
+    const response = await this.apiCall(`/v1/quests/players/${encodeURIComponent(wallet)}/assign`, {
+      method: "POST",
+      body: { questType, count },
+      headers: options?.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : void 0
+    });
+    return response.json();
+  }
+  /** Report progress for a quest step. Quest auto-completes when all steps meet targets. */
+  async reportQuestProgress(wallet, questKey, value, options) {
+    const response = await this.apiCall("/v1/quests/progress", {
+      method: "POST",
+      body: { wallet, questKey, value, stepKey: options?.stepKey }
+    });
+    return response.json();
+  }
+  /** Mark a quest complete (all steps set to targets). */
+  async completeQuest(wallet, questKey) {
+    const response = await this.apiCall("/v1/quests/complete", {
+      method: "POST",
+      body: { wallet, questKey }
+    });
+    return response.json();
+  }
+  /** Claim VIP reward for a completed quest (from game pool). Use idempotencyKey for safe retries. */
+  async claimQuestReward(wallet, questKey, options) {
+    const response = await this.apiCall("/v1/quests/claim", {
+      method: "POST",
+      body: { wallet, questKey },
+      headers: options?.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : void 0
+    });
+    return response.json();
+  }
+  /**
+   * Reset or wipe a player's quest state for this game. Requires quests:write.
+   * - wipe: delete all quest assignments for this game for the player.
+   * - reset: delete assignments for the specified questKey only (questKey required).
+   */
+  async resetPlayerQuests(wallet, action, questKey) {
+    const body = { action };
+    if (action === "reset" && questKey) body.questKey = questKey;
+    const response = await this.apiCall("/v1/quests/players/" + encodeURIComponent(wallet) + "/reset", {
+      method: "POST",
+      body
+    });
+    return response.json();
+  }
+};
+var WALLET_CHANNEL_PREFIX = "wallet:";
+var REALTIME_EVENTS = {
+  /** Currency balance changed. Refetch via GetPlayerBalances or your balance API. */
+  balance: "balance",
+  /** NFT/inventory changed. Refetch via GetPlayerNfts or your inventory API (cache is source of truth). */
+  inventory: "inventory"
 };
+var MAX_SEEN_IDS = 200;
+function normalizeWallet(wallet) {
+  return (wallet || "").trim().toLowerCase();
+}
+function getWalletChannelName(walletAddress) {
+  return WALLET_CHANNEL_PREFIX + normalizeWallet(walletAddress);
+}
+function subscribeWalletRealtime(ably, walletAddress, callbacks) {
+  const normalized = normalizeWallet(walletAddress);
+  if (!normalized || !/^0x[a-fa-f0-9]{40}$/.test(normalized)) {
+    return () => {
+    };
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  const handleMessage = (message) => {
+    const data = message.data;
+    if (!data || typeof data !== "object" || typeof data.eventId !== "string") return;
+    if (seenIds.has(data.eventId)) return;
+    if (seenIds.size >= MAX_SEEN_IDS) {
+      const first = seenIds.values().next().value;
+      if (first != null) seenIds.delete(first);
+    }
+    seenIds.add(data.eventId);
+    if (message.name === REALTIME_EVENTS.balance && callbacks.onBalance) {
+      callbacks.onBalance(data);
+    } else if (message.name === REALTIME_EVENTS.inventory && callbacks.onInventory) {
+      callbacks.onInventory(data);
+    }
+  };
+  const channel = ably.channels.get(getWalletChannelName(normalized));
+  channel.subscribe(handleMessage);
+  return () => {
+    channel.unsubscribe(handleMessage);
+  };
+}
+function subscribeWalletRealtimeWithOmenXAuth(options) {
+  const { apiBaseUrl, getAccessToken, walletAddress, onBalance, onInventory } = options;
+  const normalized = (walletAddress || "").trim().toLowerCase();
+  if (!normalized || !/^0x[a-fa-f0-9]{40}$/.test(normalized)) {
+    return () => {
+    };
+  }
+  const base = apiBaseUrl.replace(/\/$/, "");
+  const authCallback = (_tokenParams, callback) => {
+    getAccessToken().then((token) => {
+      if (!token) {
+        callback("Not authenticated", null);
+        return;
+      }
+      return fetch(`${base}/api/sdk/ably-token`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      });
+    }).then((res) => {
+      if (!res) return;
+      if (!res.ok) {
+        return res.json().then((body) => {
+          callback(body && body.message || res.statusText || "Request failed", null);
+        });
+      }
+      return res.json().then((tokenRequest) => {
+        callback(null, tokenRequest);
+      });
+    }).catch((err) => {
+      callback(err instanceof Error ? err.message : String(err), null);
+    });
+  };
+  const ably = new Ably__default.default.Realtime({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    authCallback
+  });
+  const unsubscribe = subscribeWalletRealtime(ably, walletAddress, {
+    onBalance,
+    onInventory
+  });
+  return () => {
+    unsubscribe();
+    ably.close();
+  };
+}
 
 exports.OmenXGameSDK = OmenXGameSDK;
 exports.OmenXServerSDK = OmenXServerSDK;
+exports.REALTIME_EVENTS = REALTIME_EVENTS;
+exports.WALLET_CHANNEL_PREFIX = WALLET_CHANNEL_PREFIX;
+exports.getWalletChannelName = getWalletChannelName;
+exports.subscribeWalletRealtime = subscribeWalletRealtime;
+exports.subscribeWalletRealtimeWithOmenXAuth = subscribeWalletRealtimeWithOmenXAuth;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map