@pixels-online/pixels-client-js-sdk 1.0.2

package/dist/index.js

@@ -0,0 +1,1551 @@
+'use strict';
+
+class Logger {
+    constructor(config, prefix) {
+        this.config = config;
+        this.prefix = prefix;
+    }
+    log(...args) {
+        if (this.config.debug) {
+            console.log(`[${this.prefix}]`, ...args);
+        }
+    }
+    error(...args) {
+        console.error(`[${this.prefix}]`, ...args);
+    }
+    warn(...args) {
+        if (this.config.debug) {
+            console.warn(`[${this.prefix}]`, ...args);
+        }
+    }
+    info(...args) {
+        if (this.config.debug) {
+            console.info(`[${this.prefix}]`, ...args);
+        }
+    }
+    /**
+     * Create a child logger with an additional prefix
+     */
+    child(subPrefix) {
+        return new Logger(this.config, `${this.prefix}:${subPrefix}`);
+    }
+}
+/**
+ * Create a logger instance for a component
+ */
+function createLogger(config, prefix) {
+    return new Logger(config, prefix);
+}
+
+class EventEmitter {
+    constructor(config) {
+        this.events = new Map();
+        this.logger = createLogger(config, 'EventEmitter');
+    }
+    on(event, handler) {
+        if (!this.events.has(event)) {
+            this.events.set(event, new Set());
+        }
+        this.events.get(event).add(handler);
+        this.logger.log(`Handler registered for event: ${event}`);
+    }
+    off(event, handler) {
+        const handlers = this.events.get(event);
+        if (handlers) {
+            handlers.delete(handler);
+            if (handlers.size === 0) {
+                this.events.delete(event);
+            }
+        }
+        this.logger.log(`Handler removed for event: ${event}`);
+    }
+    emit(event, data) {
+        const handlers = this.events.get(event);
+        if (handlers) {
+            handlers.forEach(handler => {
+                try {
+                    handler(data);
+                }
+                catch (error) {
+                    this.logger.error(`Error in handler for event ${event}:`, error);
+                }
+            });
+        }
+        this.logger.log(`Event emitted: ${event}`, data);
+    }
+    once(event, handler) {
+        const wrappedHandler = (data) => {
+            handler(data);
+            this.off(event, wrappedHandler);
+        };
+        this.on(event, wrappedHandler);
+    }
+    removeAllListeners(event) {
+        if (event) {
+            this.events.delete(event);
+        }
+        else {
+            this.events.clear();
+        }
+        this.logger.log(`Listeners removed for: ${event || 'all events'}`);
+    }
+    listenerCount(event) {
+        const handlers = this.events.get(event);
+        return handlers ? handlers.size : 0;
+    }
+}
+
+exports.OfferEvent = void 0;
+(function (OfferEvent) {
+    OfferEvent["CONNECTED"] = "connected";
+    OfferEvent["DISCONNECTED"] = "disconnected";
+    OfferEvent["CONNECTION_ERROR"] = "connection_error";
+    OfferEvent["CONNECTION_STATE_CHANGED"] = "connection_state_changed";
+    OfferEvent["OFFER_SURFACED"] = "offer_surfaced";
+    OfferEvent["OFFER_CLAIMED"] = "offer_claimed";
+    OfferEvent["ERROR"] = "error";
+    OfferEvent["REFRESH"] = "refresh";
+    /* placeholder events for future use
+    OFFER_ADDED = 'offer_added',
+    OFFER_UPDATED = 'offer_updated',
+    SNAPSHOT_UPDATED = 'snapshot_updated',
+    */
+})(exports.OfferEvent || (exports.OfferEvent = {}));
+
+/**
+ * Connection states for SSE connection
+ */
+exports.ConnectionState = void 0;
+(function (ConnectionState) {
+    ConnectionState["DISCONNECTED"] = "disconnected";
+    ConnectionState["CONNECTING"] = "connecting";
+    ConnectionState["CONNECTED"] = "connected";
+    ConnectionState["RECONNECTING"] = "reconnecting";
+    ConnectionState["ERROR"] = "error";
+})(exports.ConnectionState || (exports.ConnectionState = {}));
+
+/**
+ * Custom EventSource implementation that supports headers
+ * This is needed because the native EventSource API doesn't support custom headers
+ */
+var ReadyState;
+(function (ReadyState) {
+    ReadyState[ReadyState["CONNECTING"] = 0] = "CONNECTING";
+    ReadyState[ReadyState["OPEN"] = 1] = "OPEN";
+    ReadyState[ReadyState["CLOSED"] = 2] = "CLOSED";
+})(ReadyState || (ReadyState = {}));
+class CustomEventSource {
+    constructor(url, init) {
+        this.readyState = ReadyState.CONNECTING;
+        this.eventListeners = new Map();
+        this.onopen = null;
+        this.onerror = null;
+        this.onmessage = null;
+        this.reader = null;
+        this.decoder = new TextDecoder();
+        this.eventBuffer = '';
+        this.abortController = null;
+        this.lastEventId = '';
+        this.reconnectTime = 3000;
+        this.onRetryUpdate = null;
+        this.url = url;
+        this.headers = {
+            'Accept': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            ...(init?.headers || {})
+        };
+        this.connect();
+    }
+    async connect() {
+        try {
+            this.readyState = ReadyState.CONNECTING;
+            this.abortController = new AbortController();
+            const response = await fetch(this.url, {
+                method: 'GET',
+                headers: this.headers,
+                credentials: 'same-origin',
+                signal: this.abortController.signal,
+            });
+            if (!response.ok) {
+                // Check for JWT errors
+                if (response.status === 400 || response.status === 401) {
+                    try {
+                        const json = await response.json();
+                        if (json.message === 'jwt-expired' || json.message === 'jwt-invalid') {
+                            const error = new Error(json.message);
+                            error.isAuthError = true;
+                            throw error;
+                        }
+                    }
+                    catch (e) {
+                        // If not JSON or no message, throw original error
+                    }
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('Response body is null');
+            }
+            this.readyState = ReadyState.OPEN;
+            // Dispatch open event
+            if (this.onopen) {
+                this.onopen(new Event('open'));
+            }
+            this.reader = response.body.getReader();
+            await this.readStream();
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    async readStream() {
+        if (!this.reader)
+            return;
+        try {
+            while (true) {
+                const { done, value } = await this.reader.read();
+                if (done) {
+                    this.handleError(new Error('Stream ended'));
+                    break;
+                }
+                const chunk = this.decoder.decode(value, { stream: true });
+                this.eventBuffer += chunk;
+                this.processBuffer();
+            }
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    processBuffer() {
+        const lines = this.eventBuffer.split('\n');
+        this.eventBuffer = lines.pop() || '';
+        let eventType = 'message';
+        let eventData = '';
+        let eventId = '';
+        for (const line of lines) {
+            if (line === '') {
+                // Empty line signals end of event
+                if (eventData) {
+                    this.dispatchEvent(eventType, eventData.trim(), eventId);
+                    eventType = 'message';
+                    eventData = '';
+                    eventId = '';
+                }
+            }
+            else if (line.startsWith(':')) {
+                // Comment, ignore
+                continue;
+            }
+            else if (line.startsWith('event:')) {
+                eventType = line.slice(6).trim();
+            }
+            else if (line.startsWith('data:')) {
+                eventData += line.slice(5).trim() + '\n';
+            }
+            else if (line.startsWith('id:')) {
+                eventId = line.slice(3).trim();
+                this.lastEventId = eventId;
+            }
+            else if (line.startsWith('retry:')) {
+                const retry = parseInt(line.slice(6).trim(), 10);
+                if (!isNaN(retry)) {
+                    this.reconnectTime = retry;
+                    // Notify SSEConnection about the server's suggested retry time
+                    if (this.onRetryUpdate) {
+                        this.onRetryUpdate(retry);
+                    }
+                }
+            }
+        }
+    }
+    dispatchEvent(type, data, id) {
+        const event = new MessageEvent(type, {
+            data: data.endsWith('\n') ? data.slice(0, -1) : data,
+            lastEventId: id || this.lastEventId,
+            origin: new URL(this.url).origin,
+        });
+        // Dispatch to specific event listeners
+        const listeners = this.eventListeners.get(type);
+        if (listeners) {
+            listeners.forEach(listener => listener(event));
+        }
+        // Dispatch to general message handler for 'message' events
+        if (type === 'message' && this.onmessage) {
+            this.onmessage(event);
+        }
+    }
+    handleError(error) {
+        this.readyState = ReadyState.CLOSED;
+        if (this.reader) {
+            this.reader.cancel();
+            this.reader = null;
+        }
+        // Dispatch error event with details
+        if (this.onerror) {
+            const errorEvent = new Event('error');
+            errorEvent.detail = error;
+            errorEvent.message = error?.message;
+            this.onerror(errorEvent);
+        }
+        // Reconnection is handled by SSEConnection, not here
+    }
+    addEventListener(type, listener) {
+        if (!this.eventListeners.has(type)) {
+            this.eventListeners.set(type, new Set());
+        }
+        this.eventListeners.get(type).add(listener);
+    }
+    removeEventListener(type, listener) {
+        const listeners = this.eventListeners.get(type);
+        if (listeners) {
+            listeners.delete(listener);
+        }
+    }
+    close() {
+        this.readyState = ReadyState.CLOSED;
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = null;
+        }
+        if (this.reader) {
+            this.reader.cancel();
+            this.reader = null;
+        }
+        this.eventListeners.clear();
+        this.onopen = null;
+        this.onerror = null;
+        this.onmessage = null;
+    }
+    get CONNECTING() {
+        return ReadyState.CONNECTING;
+    }
+    get OPEN() {
+        return ReadyState.OPEN;
+    }
+    get CLOSED() {
+        return ReadyState.CLOSED;
+    }
+    getReadyState() {
+        return this.readyState;
+    }
+    getReconnectTime() {
+        return this.reconnectTime;
+    }
+}
+
+class SSEConnection {
+    constructor(config, eventEmitter, tokenManager) {
+        this.config = config;
+        this.eventEmitter = eventEmitter;
+        this.tokenManager = tokenManager;
+        this.eventSource = null;
+        this.reconnectAttempts = 0;
+        this.reconnectTimeout = null;
+        this.isConnecting = false;
+        this.connectionState = exports.ConnectionState.DISCONNECTED;
+        this.serverSuggestedRetryTime = null;
+        this.logger = createLogger(config, 'SSEConnection');
+    }
+    /**
+     * Get current connection state
+     */
+    getConnectionState() {
+        return this.connectionState;
+    }
+    /**
+     * Set connection state and emit change event
+     */
+    setConnectionState(newState, error) {
+        const previousState = this.connectionState;
+        if (previousState === newState)
+            return;
+        this.connectionState = newState;
+        this.eventEmitter.emit(exports.OfferEvent.CONNECTION_STATE_CHANGED, {
+            state: newState,
+            previousState,
+            error,
+            attempt: this.reconnectAttempts,
+            maxAttempts: this.config.maxReconnectAttempts
+        });
+    }
+    connect() {
+        return new Promise(async (resolve, reject) => {
+            if (this.eventSource) {
+                this.logger.log('Already connected');
+                resolve();
+                return;
+            }
+            if (this.isConnecting) {
+                this.logger.log('Connection already in progress');
+                resolve();
+                return;
+            }
+            this.isConnecting = true;
+            this.setConnectionState(exports.ConnectionState.CONNECTING);
+            this.logger.log('Connecting to SSE endpoint...');
+            try {
+                // Create SSE URL
+                const url = new URL(this.config.endpoint + '/sse/connect');
+                const token = await this.tokenManager.getTokenForConnection();
+                // Use CustomEventSource with Authorization Bearer header
+                this.eventSource = new CustomEventSource(url.toString(), {
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                    }
+                });
+                // Listen for server-suggested retry time updates
+                this.eventSource.onRetryUpdate = (retryTime) => {
+                    this.serverSuggestedRetryTime = retryTime;
+                    this.logger.log(`Server suggested retry time: ${retryTime}ms`);
+                };
+                this.eventSource.onopen = () => {
+                    this.logger.log('SSE connection opened');
+                    this.isConnecting = false;
+                    this.reconnectAttempts = 0;
+                    this.setConnectionState(exports.ConnectionState.CONNECTED);
+                    this.eventEmitter.emit(exports.OfferEvent.CONNECTED, { timestamp: new Date() });
+                    resolve();
+                };
+                this.eventSource.onerror = (error) => {
+                    this.logger.log('SSE connection error', error);
+                    this.isConnecting = false;
+                    // Check if it's an auth error
+                    if (error?.detail?.isAuthError || error?.message === 'jwt-expired' || error?.message === 'jwt-invalid') {
+                        this.tokenManager.clearToken();
+                        this.setConnectionState(exports.ConnectionState.DISCONNECTED);
+                        // Try to reconnect with fresh token if reconnect is enabled
+                        if (this.config.reconnect && this.reconnectAttempts < (this.config.maxReconnectAttempts || 5)) {
+                            this.logger.log('JWT invalid/expired, attempting reconnect with fresh token');
+                            this.handleReconnect();
+                            resolve(); // Resolve instead of reject to allow reconnection
+                            return;
+                        }
+                        else {
+                            reject(new Error('JWT token invalid or expired'));
+                            return;
+                        }
+                    }
+                    const errorMsg = this.eventSource?.getReadyState() === ReadyState.CLOSED ?
+                        'Connection closed' : 'Connection error';
+                    const connectionError = new Error(errorMsg);
+                    this.setConnectionState(exports.ConnectionState.ERROR, connectionError);
+                    if (this.eventSource?.getReadyState() === ReadyState.CLOSED) {
+                        this.eventEmitter.emit(exports.OfferEvent.CONNECTION_ERROR, {
+                            error: connectionError,
+                            timestamp: new Date()
+                        });
+                        this.handleReconnect();
+                    }
+                    else {
+                        this.eventEmitter.emit(exports.OfferEvent.CONNECTION_ERROR, {
+                            error: connectionError,
+                            timestamp: new Date()
+                        });
+                        reject(connectionError);
+                    }
+                };
+                this.eventSource.addEventListener(exports.OfferEvent.OFFER_SURFACED, (event) => {
+                    this.handleMessage(exports.OfferEvent.OFFER_SURFACED, event.data);
+                });
+                /*this.eventSource.addEventListener(OfferEvent.INIT, (event) => {
+                  this.handleMessage(OfferEvent.INIT, event.data);
+                });
+        
+                this.eventSource.addEventListener(OfferEvent.OFFER_ADDED, (event) => {
+                  this.handleMessage(OfferEvent.OFFER_ADDED, event.data);
+                });
+        
+        
+                this.eventSource.addEventListener(OfferEvent.OFFER_UPDATED, (event) => {
+                  this.handleMessage(OfferEvent.OFFER_UPDATED, event.data);
+                });
+        
+                this.eventSource.addEventListener(OfferEvent.SNAPSHOT_UPDATED, (event) => {
+                  this.handleMessage(OfferEvent.SNAPSHOT_UPDATED, event.data);
+                });
+                */
+            }
+            catch (error) {
+                this.isConnecting = false;
+                this.logger.log('Failed to create EventSource', error);
+                reject(error);
+            }
+        });
+    }
+    async handleMessage(type, data) {
+        try {
+            const parsed = JSON.parse(data);
+            this.logger.log(`Handling ${type} message:`, parsed);
+            switch (type) {
+                /*
+                case OfferEvent.INIT:
+                  if (!parsed.offers || !Array.isArray(parsed.offers))
+                    throw new Error('INIT message missing offers array');
+        
+                  if (!parsed.playerSnapshot)
+                    throw new Error('INIT message missing playerSnapshot');
+        
+                  this.eventEmitter.emit(OfferEvent.INIT, {
+                    offers: parsed.offers as IClientOffer[],
+                    playerSnapshot: parsed.playerSnapshot as IClientPlayerSnapshot
+                  });
+        
+                  break;
+                case OfferEvent.OFFER_ADDED:
+                  if (!parsed.offer)
+                    throw new Error('OFFER_ADDED message missing offer');
+                  this.eventEmitter.emit(OfferEvent.OFFER_ADDED, {
+                    offer: parsed.offer as IClientOffer,
+                  });
+                  break;
+        
+                case OfferEvent.OFFER_UPDATED:
+                  if (!parsed.offer)
+                    throw new Error('OFFER_UPDATED message missing offer');
+        
+                  this.eventEmitter.emit(OfferEvent.OFFER_UPDATED, {
+                    offer: parsed.offer as IClientOffer,
+                  });
+                  break;
+                case OfferEvent.SNAPSHOT_UPDATED:
+                  if (!parsed.playerSnapshot)
+                    throw new Error('SNAPSHOT_UPDATED message missing playerSnapshot');
+                  this.eventEmitter.emit(OfferEvent.SNAPSHOT_UPDATED, {
+                    playerSnapshot: parsed.playerSnapshot as IClientPlayerSnapshot
+                  });
+                  break;
+                case OfferEvent.OFFER_CLAIMED:
+                  if (!parsed.offerId)
+                    throw new Error('OFFER_CLAIMED message missing offerId');
+                  this.eventEmitter.emit(OfferEvent.OFFER_CLAIMED, {
+                    instanceId: parsed as string,
+                  });
+                  break;
+                  */
+                case exports.OfferEvent.OFFER_SURFACED:
+                    if (!parsed.offer)
+                        throw new Error('OFFER_SURFACED message missing offer');
+                    let surface = true;
+                    if (this.config.hooks?.onOfferSurfaced) {
+                        surface = await this.config.hooks.onOfferSurfaced(parsed.offer);
+                    }
+                    if (surface) {
+                        this.logger.log('Offer surfaced hook returned true, popping notification for offer:', parsed.offer);
+                        this.eventEmitter.emit(exports.OfferEvent.OFFER_SURFACED, {
+                            offer: parsed.offer,
+                        });
+                    }
+                    break;
+                default:
+                    this.logger.log('Unknown message type:', type);
+            }
+        }
+        catch (error) {
+            this.logger.log('Error parsing SSE message:', error);
+            this.eventEmitter.emit(exports.OfferEvent.ERROR, {
+                error: error,
+                context: 'sse_message_parse'
+            });
+        }
+    }
+    handleReconnect() {
+        if (!this.config.reconnect) {
+            this.disconnect();
+            return;
+        }
+        if (this.reconnectAttempts >= (this.config.maxReconnectAttempts || 5)) {
+            this.logger.log('Max reconnection attempts reached');
+            this.setConnectionState(exports.ConnectionState.DISCONNECTED);
+            this.disconnect();
+            this.eventEmitter.emit(exports.OfferEvent.DISCONNECTED, {
+                reason: 'max_reconnect_attempts',
+                timestamp: new Date()
+            });
+            return;
+        }
+        this.reconnectAttempts++;
+        // Use server-suggested retry time if available, otherwise use config delay with exponential backoff
+        const baseDelay = this.serverSuggestedRetryTime || this.config.reconnectDelay || 1000;
+        const backoffDelay = baseDelay * Math.pow(2, this.reconnectAttempts - 1);
+        this.setConnectionState(exports.ConnectionState.RECONNECTING);
+        this.logger.log(`Reconnecting in ${backoffDelay}ms (attempt ${this.reconnectAttempts}`);
+        this.reconnectTimeout = window.setTimeout(() => {
+            this.eventSource = null;
+            this.connect().catch((error) => {
+                this.logger.log('Reconnection failed:', error);
+            });
+        }, backoffDelay);
+    }
+    disconnect() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        if (this.eventSource) {
+            this.logger.log('Closing SSE connection');
+            this.eventSource.close();
+            this.eventSource = null;
+            this.setConnectionState(exports.ConnectionState.DISCONNECTED);
+            this.eventEmitter.emit(exports.OfferEvent.DISCONNECTED, {
+                reason: 'manual',
+                timestamp: new Date()
+            });
+        }
+        this.isConnecting = false;
+        this.reconnectAttempts = 0;
+    }
+    isConnected() {
+        return this.eventSource?.getReadyState() === ReadyState.OPEN;
+    }
+}
+
+class OfferStore {
+    constructor(config) {
+        this.offers = new Map();
+        this.playerSnapshot = null;
+        this.logger = createLogger(config, 'OfferStore');
+    }
+    getSnapshot() {
+        return this.playerSnapshot;
+    }
+    setSnapshot(snapshot) {
+        this.playerSnapshot = snapshot;
+        this.logger.log('Updated player snapshot:', snapshot);
+    }
+    /**
+     * Set all offers (replaces existing)
+     */
+    setOffers(offers) {
+        this.offers.clear();
+        offers.forEach(offer => {
+            this.offers.set(offer.instanceId, offer);
+        });
+        this.logger.log(`Set ${offers.length} offers`);
+    }
+    /**
+     * Add or update a single offer
+     */
+    upsertOffer(offer) {
+        const previousOffer = this.offers.get(offer.instanceId);
+        this.offers.set(offer.instanceId, offer);
+        this.logger.log(`${previousOffer ? 'Updated' : 'Added'} offer:`, offer.instanceId);
+        return previousOffer;
+    }
+    /**
+     * Remove an offer
+     */
+    removeOffer(offerId) {
+        const removed = this.offers.delete(offerId);
+        if (removed) {
+            this.logger.log(`Removed offer:`, offerId);
+        }
+        return removed;
+    }
+    /**
+     * Get a single offer
+     */
+    getOffer(offerId) {
+        return this.offers.get(offerId);
+    }
+    /**
+     * Get all offers
+     */
+    getAllOffers() {
+        return Array.from(this.offers.values());
+    }
+    /**
+     * Get offers filtered by status
+     */
+    getOffersByStatus(status) {
+        return this.getAllOffers().filter(offer => offer.status === status);
+    }
+    /**
+     * Get active offers (not expired, not claimed)
+     */
+    getActiveOffers() {
+        return this.getAllOffers().filter(offer => {
+            if (!offer.status)
+                return false; // Must have a status
+            return offer.status === 'surfaced' || offer.status === 'viewed' || offer.status === 'claimable';
+        });
+    }
+    /**
+     * Get claimable offers
+     */
+    getClaimableOffers() {
+        return this.getOffersByStatus('claimable');
+    }
+    /**
+     * Check if an offer has expired
+     */
+    isOfferExpired(offerId) {
+        const offer = this.getOffer(offerId);
+        if (!offer)
+            return true;
+        // Check status
+        if (offer.status === 'expired')
+            return true;
+        // Check expiry date
+        if (offer.expiresAt && new Date(offer.expiresAt) < new Date()) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Clear all offers
+     */
+    clear() {
+        this.offers.clear();
+        this.logger.log('Cleared all offers');
+    }
+    /**
+     * Get offer count
+     */
+    get size() {
+        return this.offers.size;
+    }
+}
+
+/**
+ * Manages JWT tokens for the offerwall client
+ * Handles token storage, validation, and refresh logic
+ */
+class TokenManager {
+    constructor(config) {
+        this.config = config;
+        this.currentToken = null;
+        this.logger = createLogger(config, 'TokenManager');
+    }
+    /**
+     * Get the current stored token
+     */
+    getCurrentToken() {
+        return this.currentToken;
+    }
+    /**
+     * Clear the stored token
+     */
+    clearToken() {
+        this.currentToken = null;
+    }
+    /**
+     * Get current token or fetch a new one if needed
+     */
+    async getTokenForConnection() {
+        if (!this.currentToken)
+            return this.fetchToken();
+        if (!this.validateToken(this.currentToken))
+            return this.fetchToken();
+        return this.currentToken;
+    }
+    async fetchToken() {
+        const token = await this.config.tokenProvider();
+        this.currentToken = token;
+        return token;
+    }
+    validateToken(token) {
+        try {
+            const { exp } = this.parseJWT(token);
+            const now = Date.now();
+            const expiryTime = exp * 1000;
+            var isValid = expiryTime > now + 60000; // valid if more than 1 minute left
+            return isValid;
+        }
+        catch (error) {
+            this.logger.log(`Failed to validate token: ${error}`);
+            return false;
+        }
+    }
+    parseJWT(token) {
+        try {
+            const parts = token.split(".");
+            if (parts.length !== 3)
+                throw new Error("Invalid JWT format");
+            const payload = JSON.parse(atob(parts[1]));
+            // Validate required claims
+            if (!payload.sub || typeof payload.sub !== "string") {
+                throw new Error("Invalid sub claim");
+            }
+            if (!payload.iss || typeof payload.iss !== "string") {
+                throw new Error("Invalid iss claim");
+            }
+            if (!payload.exp || typeof payload.exp !== "number") {
+                throw new Error("Invalid exp claim");
+            }
+            if (!payload.iat || typeof payload.iat !== "number") {
+                throw new Error("Invalid iat claim");
+            }
+            // discard unknown claims
+            return {
+                sub: payload.sub,
+                iss: payload.iss,
+                exp: payload.exp,
+                iat: payload.iat,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to parse JWT: ${error}`);
+        }
+    }
+}
+
+class AssetHelper {
+    constructor(config) {
+        this.config = config;
+    }
+    resolveReward(reward) {
+        // Determine the ID to translate based on reward kind
+        let id;
+        switch (reward.kind) {
+            case 'item':
+                id = reward.itemId;
+                break;
+            case 'coins':
+                id = reward.currencyId;
+                break;
+            case 'exp':
+                id = reward.skillId;
+                break;
+            case 'on_chain':
+                id = reward.assetId;
+                break;
+            case 'trust_points':
+                id = 'trust_points';
+                break;
+        }
+        // Fallback to reward's built-in name, we should add 5x popberry etc
+        const formattedName = reward.amount > 1 ? `${reward.amount}x ${reward.name}` : reward.name;
+        // Try to resolve asset content if ID exists and resolver is set
+        if (id && this.config.assetResolver) {
+            const content = this.config.assetResolver(reward, id);
+            if (content) {
+                return {
+                    name: content.name || formattedName,
+                    image: content.image || this.config.fallbackRewardImage
+                };
+            }
+        }
+        return {
+            name: formattedName,
+            image: this.config.fallbackRewardImage
+        };
+    }
+    resolveOfferRewards(offer) {
+        return offer.rewards.map(reward => ({
+            ...reward,
+            ...this.resolveReward(reward),
+        }));
+    }
+}
+
+class OfferwallClient {
+    constructor(config) {
+        this.isInitializing = false;
+        this.config = {
+            endpoint: config.endpoint || 'https://api.buildon.pixels.xyz',
+            autoConnect: config.autoConnect ?? false,
+            reconnect: config.reconnect ?? true,
+            reconnectDelay: config.reconnectDelay ?? 1000,
+            maxReconnectAttempts: config.maxReconnectAttempts ?? 5,
+            debug: config.debug ?? false,
+            ...config
+        };
+        this.hooks = this.config.hooks || {};
+        this.logger = createLogger(this.config, 'OfferwallClient');
+        this.eventEmitter = new EventEmitter(this.config);
+        this.offerStore = new OfferStore(this.config);
+        this.tokenManager = new TokenManager(this.config);
+        this.assetHelper = new AssetHelper(this.config);
+        this.sseConnection = new SSEConnection(this.config, this.eventEmitter, this.tokenManager);
+        this.setupInternalListeners();
+        if (this.config.autoConnect) {
+            this.initialize().catch(err => {
+                this.logger.error('Auto-initialization failed:', err);
+            });
+        }
+    }
+    /**
+     * Get the offer store instance
+     */
+    get store() {
+        return this.offerStore;
+    }
+    /**
+     * Get the event emitter instance for event handling
+     */
+    get events() {
+        return this.eventEmitter;
+    }
+    /**
+     * Get asset helper for resolving offer/reward content
+     */
+    get assets() {
+        return this.assetHelper;
+    }
+    /**
+     * Initialize the offerwall client and connect
+     */
+    async initialize() {
+        try {
+            if (this.isInitializing) {
+                this.logger.log('Initialization already in progress');
+                return;
+            }
+            this.isInitializing = true;
+            await this.refreshOffersAndSnapshot();
+            await this.connect();
+            this.isInitializing = false;
+        }
+        catch (error) {
+            this.handleError(error, 'initialize');
+            throw error;
+        }
+    }
+    /**
+     * Connect to the offerwall SSE endpoint
+     */
+    async connect() {
+        if (this.sseConnection?.isConnected()) {
+            this.logger.log('Already connected');
+            return;
+        }
+        const token = await this.tokenManager.getTokenForConnection();
+        if (this.hooks.beforeConnect) {
+            await this.hooks.beforeConnect({ jwt: token, endpoint: this.config.endpoint });
+        }
+        try {
+            await this.sseConnection.connect();
+            if (this.hooks.afterConnect) {
+                await this.hooks.afterConnect();
+            }
+        }
+        catch (error) {
+            this.handleError(error, 'connection');
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from the offerwall
+     */
+    async disconnect() {
+        if (this.hooks.beforeDisconnect) {
+            await this.hooks.beforeDisconnect();
+        }
+        if (this.sseConnection) {
+            this.sseConnection.disconnect();
+        }
+        this.offerStore.clear();
+        this.tokenManager.clearToken();
+        if (this.hooks.afterDisconnect) {
+            await this.hooks.afterDisconnect();
+        }
+    }
+    /**
+     * Claim rewards for an offer
+     */
+    async claimReward(instanceId) {
+        const offer = this.offerStore.getOffer(instanceId);
+        if (!offer) {
+            throw new Error(`Offer ${instanceId} not found`);
+        }
+        if (offer.status !== 'claimable') {
+            throw new Error(`Offer ${instanceId} is not claimable (status: ${offer.status})`);
+        }
+        if (this.hooks.beforeOfferClaim) {
+            const canClaim = await this.hooks.beforeOfferClaim(offer);
+            if (!canClaim) {
+                this.logger.log('Claim cancelled by beforeOfferClaim hook');
+                return;
+            }
+        }
+        try {
+            const response = await this.claimOfferAPI(instanceId);
+            const updatedOffer = { ...offer, status: 'claimed', };
+            this.offerStore.upsertOffer(updatedOffer);
+            this.eventEmitter.emit(exports.OfferEvent.OFFER_CLAIMED, {
+                instanceId,
+            });
+            if (this.hooks.afterOfferClaim) {
+                await this.hooks.afterOfferClaim(updatedOffer, offer.rewards);
+            }
+            return response;
+        }
+        catch (error) {
+            this.handleError(error, 'claim');
+            throw error;
+        }
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.sseConnection?.isConnected() || false;
+    }
+    /**
+     * Get current connection state
+     */
+    getConnectionState() {
+        return this.sseConnection?.getConnectionState() || exports.ConnectionState.DISCONNECTED;
+    }
+    setupInternalListeners() {
+        /*
+        this.eventEmitter.on(OfferEvent.INIT, ({ offers, playerSnapshot }) => {
+          this.offerStore.setOffers(offers);
+          this.offerStore.setSnapshot(playerSnapshot);
+          this.logger.log(`Loaded ${offers.length} offers`);
+        });
+    
+        this.eventEmitter.on(OfferEvent.OFFER_ADDED, ({ offer }) => {
+          this.offerStore.upsertOffer(offer);
+          this.logger.log(`Added offer: ${offer.instanceId}`);
+        });
+    
+        this.eventEmitter.on(OfferEvent.OFFER_UPDATED, ({ offer }) => {
+          this.offerStore.upsertOffer(offer);
+          this.logger.log(`Updated offer: ${offer.instanceId}`);
+        });
+    
+        this.eventEmitter.on(OfferEvent.SNAPSHOT_UPDATED, ({ playerSnapshot }) => {
+          this.offerStore.setSnapshot(playerSnapshot);
+          this.logger.log(`Updated player snapshot`);
+        });
+    
+        this.eventEmitter.on(OfferEvent.ERROR, ({ error, context }) => {
+          this.handleError(error, context);
+        });
+        */
+        this.eventEmitter.on(exports.OfferEvent.OFFER_SURFACED, ({ offer }) => {
+            this.offerStore.upsertOffer(offer);
+            this.logger.log(`Surfaced offer: ${offer.instanceId}`);
+        });
+    }
+    /**
+     * Helper to POST to an endpoint with JWT and handle token expiry/retry logic
+     */
+    async postWithAuth(endpoint, body, retry = false) {
+        const token = await this.tokenManager.getTokenForConnection();
+        const response = await fetch(`${this.config.endpoint}${endpoint}`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            if (response.status === 400) {
+                const errorData = await response.json();
+                if ((errorData.message === 'jwt-expired' || errorData.message === 'jwt-invalid') &&
+                    !retry) {
+                    this.tokenManager.clearToken();
+                    return this.postWithAuth(endpoint, body, true);
+                }
+            }
+            throw new Error(`Failed to POST to ${endpoint}: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async claimOfferAPI(instanceId) {
+        return this.postWithAuth('/client/reward/claim', { instanceId, kind: 'offer' });
+    }
+    async refreshOffersAndSnapshot() {
+        try {
+            const { offers, snapshot } = await this.getOffersAndSnapshot();
+            this.offerStore.setOffers(offers);
+            this.offerStore.setSnapshot(snapshot);
+            this.eventEmitter.emit(exports.OfferEvent.REFRESH, { offers, playerSnapshot: snapshot });
+            this.logger.log('Refreshed offers and player snapshot');
+        }
+        catch (error) {
+            this.handleError(error, 'refreshOffersAndSnapshot');
+            throw error;
+        }
+    }
+    async getOffersAndSnapshot() {
+        const data = await this.postWithAuth('/client/player/campaigns', { viewingCampaigns: true });
+        if (!data.offers || !Array.isArray(data.offers)) {
+            throw new Error('No offers returned from offers endpoint');
+        }
+        if (!data.snapshot) {
+            throw new Error('No player snapshot returned from offers endpoint');
+        }
+        return data;
+    }
+    async getAuthLinkToken() {
+        const data = await this.postWithAuth('/auth/one_time_token/generate');
+        if (!data.token) {
+            throw new Error('No token returned from auth link endpoint');
+        }
+        return data.token;
+    }
+    handleError(error, context) {
+        this.logger.error(`Error in ${context}:`, error);
+        if (this.hooks.onError) {
+            this.hooks.onError(error, context);
+        }
+    }
+}
+
+const meetsBaseConditions = ({ conditions, playerSnap, addDetails, }) => {
+    const conditionData = [];
+    let isValid = true;
+    if (conditions?.minDaysInGame) {
+        const isDisqualify = (playerSnap.daysInGame || 0) < conditions.minDaysInGame;
+        if (addDetails) {
+            conditionData.push({
+                isMet: !isDisqualify,
+                kind: 'minDaysInGame',
+                trackerAmount: playerSnap.daysInGame || 0,
+                text: `More than ${conditions.minDaysInGame} Days in Game`,
+            });
+            if (isDisqualify)
+                isValid = false;
+        }
+        else {
+            if (isDisqualify)
+                return { isValid: false };
+        }
+    }
+    if (conditions?.minTrustScore) {
+        const isDisqualify = (playerSnap.trustScore || 0) < conditions.minTrustScore;
+        if (addDetails) {
+            conditionData.push({
+                isMet: !isDisqualify,
+                kind: 'minTrustScore',
+                trackerAmount: playerSnap.trustScore || 0,
+                text: `More than ${conditions.minTrustScore} Rep`,
+            });
+            if (isDisqualify)
+                isValid = false;
+        }
+        else {
+            if (isDisqualify)
+                return { isValid: false };
+        }
+    }
+    if (conditions?.maxTrustScore) {
+        const isDisqualify = (playerSnap.trustScore || 0) > conditions.maxTrustScore;
+        if (addDetails) {
+            conditionData.push({
+                isMet: !isDisqualify,
+                kind: 'maxTrustScore',
+                trackerAmount: playerSnap.trustScore || 0,
+                text: `Less than ${conditions.maxTrustScore} Rep`,
+            });
+            if (isDisqualify)
+                isValid = false;
+        }
+        else {
+            if (isDisqualify)
+                return { isValid: false };
+        }
+    }
+    for (const key in conditions?.achievements) {
+        const a = conditions.achievements[key];
+        const playerAchData = playerSnap.achievements?.[key];
+        if (!playerAchData) {
+            const isDisqualify = true;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: isDisqualify,
+                    kind: 'achievements',
+                    trackerAmount: 0,
+                    text: `Have the achievement ${a.name}`,
+                });
+                isValid = false;
+            }
+            else {
+                return { isValid: false };
+            }
+        }
+        if (a.minCount) {
+            const isDisqualify = (playerAchData?.count || 1) < a.minCount;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'achievements',
+                    trackerAmount: playerAchData?.count || 0,
+                    text: `Have the achievement ${a.name} more than ${a.minCount} times`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+                return { isValid: false };
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    for (const key in conditions?.currencies) {
+        const c = conditions.currencies[key];
+        const playerCurrencyData = playerSnap.currencies?.[key];
+        if (c.min) {
+            const isDisqualify = (playerCurrencyData?.balance || 0) < c.min;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'currencies',
+                    trackerAmount: playerCurrencyData?.balance || 0,
+                    text: `Have more than ${c.min} ${c.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (c.max) {
+            const isDisqualify = (playerCurrencyData?.balance || 0) > c.max;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'currencies',
+                    trackerAmount: playerCurrencyData?.balance || 0,
+                    text: `Have less than ${c.max} ${c.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (c.in) {
+            const isDisqualify = (playerCurrencyData?.in || 0) < c.in;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'currencies',
+                    trackerAmount: playerCurrencyData?.in || 0,
+                    text: `Deposit at least ${c.in} ${c.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (c.out) {
+            const isDisqualify = (playerCurrencyData?.out || 0) < c.out;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'currencies',
+                    trackerAmount: playerCurrencyData?.out || 0,
+                    text: `Withdraw at least ${c.out} ${c.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    for (const key in conditions?.levels) {
+        const l = conditions.levels[key];
+        const playerLevelData = playerSnap.levels?.[key];
+        if (l.min) {
+            const isDisqualify = (playerLevelData?.level || 0) < l.min;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'levels',
+                    trackerAmount: playerLevelData?.level || 0,
+                    text: `Be above level ${l.min} ${l.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (l.max) {
+            const isDisqualify = (playerLevelData?.level || 0) > l.max;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'levels',
+                    trackerAmount: playerLevelData?.level || 0,
+                    text: `Be under level ${l.max} ${l.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    if (conditions?.quests) {
+        for (const questId in conditions.quests) {
+            const quest = conditions.quests[questId];
+            const playerQuestData = playerSnap.quests?.[questId];
+            const isDisqualify = playerQuestData
+                ? (playerQuestData?.completions || 0) < (quest.completions || 0)
+                : false;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'quests',
+                    trackerAmount: playerQuestData?.completions || 0,
+                    text: quest.completions === 1
+                        ? `Complete the quest ${quest.name}`
+                        : (quest.completions || 0) < 1
+                            ? `Start the quest ${quest.name}`
+                            : `Complete the quest ${quest.name} ${quest.completions} times`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    for (const key in conditions?.memberships) {
+        const m = conditions.memberships[key];
+        const playerMembershipsData = playerSnap.memberships?.[key];
+        if (m.minCount) {
+            const isDisqualify = (playerMembershipsData?.count || 0) < m.minCount;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'memberships',
+                    trackerAmount: playerMembershipsData?.count || 0,
+                    text: m.minCount > 1
+                        ? `Have at least ${m.minCount} ${m.name} memberships`
+                        : `Have a ${m.name} membership`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (m.maxCount) {
+            const isDisqualify = (playerMembershipsData?.count || 0) > m.maxCount;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'memberships',
+                    trackerAmount: playerMembershipsData?.count || 0,
+                    text: `Have less than ${m.maxCount} ${m.name} memberships`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        const timeOwned = (playerMembershipsData?.expiresAt || 0) - Date.now();
+        if (m.minMs) {
+            const isDisqualify = timeOwned < m.minMs;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'memberships',
+                    trackerAmount: Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1)),
+                    text: `Own ${m.name} membership for at least ${(m.minMs /
+                        (1000 * 60 * 60 * 24)).toFixed(1)} days`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (m.maxMs) {
+            const isDisqualify = timeOwned > m.maxMs;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'memberships',
+                    trackerAmount: Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1)),
+                    text: `Own ${m.name} membership for less than ${(m.maxMs /
+                        (1000 * 60 * 60 * 24)).toFixed(1)} days`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    for (const key in conditions?.stakedTokens) {
+        const s = conditions.stakedTokens[key];
+        const playerStakedData = playerSnap.stakedTokens?.[key];
+        if (s.min) {
+            const isDisqualify = (playerStakedData?.balance || 0) < s.min;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'stakedTokens',
+                    trackerAmount: playerStakedData?.balance || 0,
+                    text: `Have at least ${s.min} ${s.name} staked`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    return { isValid, conditionData: addDetails ? conditionData : undefined };
+};
+const meetsCompletionConditions = ({ completionConditions, completionTrackers, playerSnap, addDetails = false, }) => {
+    if (completionConditions) {
+        const conditions = completionConditions;
+        const conditionData = [];
+        let isValid = true;
+        if (conditions.buyItem) {
+            const isDisqualify = (completionTrackers?.buyItem || 0) < (conditions.buyItem.amount || 1);
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'buyItem',
+                    trackerAmount: completionTrackers?.buyItem || 0,
+                    text: `Buy ${conditions.buyItem.amount || 1} ${conditions.buyItem.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (conditions.spendCurrency) {
+            const isDisqualify = (completionTrackers?.spendCurrency || 0) < (conditions.spendCurrency.amount || 1);
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'spendCurrency',
+                    trackerAmount: completionTrackers?.spendCurrency || 0,
+                    text: `Spend ${conditions.spendCurrency.amount || 1} ${conditions.spendCurrency.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (conditions.depositCurrency) {
+            const isDisqualify = (completionTrackers?.depositCurrency || 0) <
+                (conditions.depositCurrency.amount || 1);
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'depositCurrency',
+                    trackerAmount: completionTrackers?.depositCurrency || 0,
+                    text: `Deposit ${conditions.depositCurrency.amount || 1} ${conditions.depositCurrency.name}`,
+                });
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (conditions.login) {
+            const isMet = completionTrackers?.login || false;
+            if (addDetails) {
+                conditionData.push({
+                    isMet,
+                    kind: 'login',
+                    trackerAmount: completionTrackers?.login ? 1 : 0,
+                    text: `Login to the game`,
+                });
+                isValid = isMet;
+            }
+            else {
+                if (!isMet)
+                    return { isValid: false };
+            }
+        }
+        if (conditions.loginStreak) {
+            // player's login streak snapshot right now - their login streak when offer was surfaced = their login streak since the offer was surfaced
+            // if their login streak since the offer was surfaced is less than the required login streak, then they are not yet eligible for the offer
+            const streakSinceOffer = (playerSnap.loginStreak || 0) - (completionTrackers?.currentLoginStreak || 0);
+            const isDisqualify = streakSinceOffer + 1 < conditions.loginStreak;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'loginStreak',
+                    trackerAmount: (playerSnap.loginStreak || 0) - (completionTrackers?.currentLoginStreak || 0),
+                    text: `Login streak of ${conditions.loginStreak || 0} days`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        const r = meetsBaseConditions({
+            conditions,
+            playerSnap,
+            addDetails: true,
+        });
+        isValid = r.isValid;
+        conditionData.push(...(r.conditionData || []));
+        return { isValid, conditionData };
+    }
+    return { isValid: true, conditionData: [] };
+};
+
+// Taken from buildon_server/src/commons/types/offer.ts and merged into a single interface
+const PlayerOfferStatuses = [
+    'inQueue',
+    'surfaced',
+    'viewed',
+    'claimable',
+    'claimed',
+    'expired',
+];
+
+// Taken from buildon_server/src/commons/types/reward.ts
+// Use a const assertion for the array and infer the union type directly
+const rewardKinds = [
+    'item',
+    'coins',
+    'exp',
+    'trust_points',
+    /** on-chain rewards require the builder to send funds to a custodial wallet that we use to send to player wallets*/
+    'on_chain',
+];
+
+exports.AssetHelper = AssetHelper;
+exports.EventEmitter = EventEmitter;
+exports.OfferStore = OfferStore;
+exports.OfferwallClient = OfferwallClient;
+exports.PlayerOfferStatuses = PlayerOfferStatuses;
+exports.SSEConnection = SSEConnection;
+exports.meetsBaseConditions = meetsBaseConditions;
+exports.meetsCompletionConditions = meetsCompletionConditions;
+exports.rewardKinds = rewardKinds;
+//# sourceMappingURL=index.js.map