@pixels-online/pixels-client-js-sdk 1.21.0 → 2.1.0

package/dist/offerwall-sdk.umd.js

@@ -99,7 +99,7 @@
         }
     }
 
-    exports.OfferEvent = void 0;
+    var OfferEvent;
     (function (OfferEvent) {
         OfferEvent["CONNECTED"] = "connected";
         OfferEvent["DISCONNECTED"] = "disconnected";
@@ -114,19 +114,19 @@
         OFFER_UPDATED = 'offer_updated',
         SNAPSHOT_UPDATED = 'snapshot_updated',
         */
-    })(exports.OfferEvent || (exports.OfferEvent = {}));
+    })(OfferEvent || (OfferEvent = {}));
 
     /**
      * Connection states for SSE connection
      */
-    exports.ConnectionState = void 0;
+    var ConnectionState;
     (function (ConnectionState) {
         ConnectionState["DISCONNECTED"] = "disconnected";
         ConnectionState["CONNECTING"] = "connecting";
         ConnectionState["CONNECTED"] = "connected";
         ConnectionState["RECONNECTING"] = "reconnecting";
         ConnectionState["ERROR"] = "error";
-    })(exports.ConnectionState || (exports.ConnectionState = {}));
+    })(ConnectionState || (ConnectionState = {}));
 
     /**
      * Custom EventSource implementation that supports headers
@@ -366,7 +366,7 @@
             this.reconnectAttempts = 0;
             this.reconnectTimeout = null;
             this.isConnecting = false;
-            this.connectionState = exports.ConnectionState.DISCONNECTED;
+            this.connectionState = ConnectionState.DISCONNECTED;
             this.serverSuggestedRetryTime = null;
             this.logger = createLogger(config, 'SSEConnection');
             this.endpoint = mapEnvToBuildOnApiUrl(config.env);
@@ -385,7 +385,7 @@
             if (previousState === newState)
                 return;
             this.connectionState = newState;
-            this.eventEmitter.emit(exports.OfferEvent.CONNECTION_STATE_CHANGED, {
+            this.eventEmitter.emit(OfferEvent.CONNECTION_STATE_CHANGED, {
                 state: newState,
                 previousState,
                 error,
@@ -406,7 +406,7 @@
                     return;
                 }
                 this.isConnecting = true;
-                this.setConnectionState(exports.ConnectionState.CONNECTING);
+                this.setConnectionState(ConnectionState.CONNECTING);
                 this.logger.log('Connecting to SSE endpoint...');
                 try {
                     // Create SSE URL
@@ -427,8 +427,8 @@
                         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() });
+                        this.setConnectionState(ConnectionState.CONNECTED);
+                        this.eventEmitter.emit(OfferEvent.CONNECTED, { timestamp: new Date() });
                         resolve();
                     };
                     this.eventSource.onerror = (error) => {
@@ -439,7 +439,7 @@
                             error?.message === 'jwt-expired' ||
                             error?.message === 'jwt-invalid') {
                             this.tokenManager.clearToken();
-                            this.setConnectionState(exports.ConnectionState.DISCONNECTED);
+                            this.setConnectionState(ConnectionState.DISCONNECTED);
                             // Try to reconnect with fresh token if reconnect is enabled
                             if (this.config.reconnect &&
                                 this.reconnectAttempts < (this.config.maxReconnectAttempts || 5)) {
@@ -457,24 +457,24 @@
                             ? 'Connection closed'
                             : 'Connection error';
                         const connectionError = new Error(errorMsg);
-                        this.setConnectionState(exports.ConnectionState.ERROR, connectionError);
+                        this.setConnectionState(ConnectionState.ERROR, connectionError);
                         if (this.eventSource?.getReadyState() === ReadyState.CLOSED) {
-                            this.eventEmitter.emit(exports.OfferEvent.CONNECTION_ERROR, {
+                            this.eventEmitter.emit(OfferEvent.CONNECTION_ERROR, {
                                 error: connectionError,
                                 timestamp: new Date(),
                             });
                             this.handleReconnect();
                         }
                         else {
-                            this.eventEmitter.emit(exports.OfferEvent.CONNECTION_ERROR, {
+                            this.eventEmitter.emit(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.OFFER_SURFACED, (event) => {
+                        this.handleMessage(OfferEvent.OFFER_SURFACED, event.data);
                     });
                     /*this.eventSource.addEventListener(OfferEvent.INIT, (event) => {
                       this.handleMessage(OfferEvent.INIT, event.data);
@@ -551,7 +551,7 @@
                       });
                       break;
                       */
-                    case exports.OfferEvent.OFFER_SURFACED:
+                    case OfferEvent.OFFER_SURFACED:
                         if (!parsed.instanceId)
                             throw new Error('OFFER_SURFACED message missing offer');
                         let surface = true;
@@ -560,7 +560,7 @@
                         }
                         if (surface) {
                             this.logger.log('Offer surfaced hook returned true, popping notification for offer:', parsed);
-                            this.eventEmitter.emit(exports.OfferEvent.OFFER_SURFACED, {
+                            this.eventEmitter.emit(OfferEvent.OFFER_SURFACED, {
                                 offer: parsed,
                             });
                         }
@@ -571,7 +571,7 @@
             }
             catch (error) {
                 this.logger.log('Error parsing SSE message:', error);
-                this.eventEmitter.emit(exports.OfferEvent.ERROR, {
+                this.eventEmitter.emit(OfferEvent.ERROR, {
                     error: error,
                     context: 'sse_message_parse',
                 });
@@ -584,9 +584,9 @@
             }
             if (this.reconnectAttempts >= (this.config.maxReconnectAttempts || 5)) {
                 this.logger.log('Max reconnection attempts reached');
-                this.setConnectionState(exports.ConnectionState.DISCONNECTED);
+                this.setConnectionState(ConnectionState.DISCONNECTED);
                 this.disconnect();
-                this.eventEmitter.emit(exports.OfferEvent.DISCONNECTED, {
+                this.eventEmitter.emit(OfferEvent.DISCONNECTED, {
                     reason: 'max_reconnect_attempts',
                     timestamp: new Date(),
                 });
@@ -596,7 +596,7 @@
             // 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.setConnectionState(ConnectionState.RECONNECTING);
             this.logger.log(`Reconnecting in ${backoffDelay}ms (attempt ${this.reconnectAttempts}`);
             this.reconnectTimeout = window.setTimeout(() => {
                 this.eventSource = null;
@@ -615,8 +615,8 @@
                     this.logger.log('Closing SSE connection');
                     this.eventSource.close();
                     this.eventSource = null;
-                    this.setConnectionState(exports.ConnectionState.DISCONNECTED);
-                    this.eventEmitter.emit(exports.OfferEvent.DISCONNECTED, {
+                    this.setConnectionState(ConnectionState.DISCONNECTED);
+                    this.eventEmitter.emit(OfferEvent.DISCONNECTED, {
                         reason: 'manual',
                         timestamp: new Date(),
                     });
@@ -647,7 +647,12 @@
             return this.players.get(targetId) || null;
         }
         setPlayer(player) {
-            this.players.set(player.gameData.playerId, player);
+            const playerId = player.snapshot?.playerId;
+            if (!playerId) {
+                this.logger.warn('No playerId in player snapshot');
+                return;
+            }
+            this.players.set(playerId, player);
             this.logger.log('Updated player:', player);
         }
         /**
@@ -655,13 +660,14 @@
          */
         setOffers(offers, target) {
             const targetPlayer = target || this.getPlayer();
-            if (!targetPlayer) {
+            if (!targetPlayer?.snapshot?.playerId) {
                 this.logger.warn('No target player to set offers for');
                 return;
             }
-            this.offers.set(targetPlayer.gameData.playerId, new Map());
+            const playerId = targetPlayer.snapshot.playerId;
+            this.offers.set(playerId, new Map());
             offers.forEach((offer) => {
-                this.offers.get(targetPlayer.gameData.playerId).set(offer.instanceId, offer);
+                this.offers.get(playerId).set(offer.instanceId, offer);
             });
             this.logger.log(`Set ${offers.length} offers`);
         }
@@ -699,6 +705,17 @@
                 return undefined;
             return this.offers.get(targetId)?.get(offerId);
         }
+        /**
+         * Find an offer by instanceId across all players in the store
+         */
+        findOfferById(instanceId) {
+            for (const playerOffers of this.offers.values()) {
+                const offer = playerOffers.get(instanceId);
+                if (offer)
+                    return offer;
+            }
+            return undefined;
+        }
         /**
          * Get all offers
          */
@@ -1059,8 +1076,8 @@
         /**
          * Claim rewards for an offer
          */
-        async claimReward(instanceId, targetId = this.getSelfId()) {
-            const offer = this.offerStore.getOffer(instanceId, targetId);
+        async claimReward(instanceId) {
+            const offer = this.offerStore.findOfferById(instanceId);
             if (!offer) {
                 throw new Error(`Offer ${instanceId} not found`);
             }
@@ -1075,10 +1092,10 @@
                 }
             }
             try {
-                const response = await this.claimOfferAPI(instanceId, targetId);
+                const response = await this.claimOfferAPI(instanceId, offer.playerId);
                 const updatedOffer = { ...offer, status: 'claimed' };
                 this.offerStore.upsertOffer(updatedOffer);
-                this.eventEmitter.emit(exports.OfferEvent.OFFER_CLAIMED, {
+                this.eventEmitter.emit(OfferEvent.OFFER_CLAIMED, {
                     instanceId,
                 });
                 if (this.hooks.afterOfferClaim) {
@@ -1101,7 +1118,7 @@
          * Get current connection state
          */
         getConnectionState() {
-            return this.sseConnection?.getConnectionState() || exports.ConnectionState.DISCONNECTED;
+            return this.sseConnection?.getConnectionState() || ConnectionState.DISCONNECTED;
         }
         setupInternalListeners() {
             /*
@@ -1130,7 +1147,7 @@
               this.handleError(error, context);
             });
             */
-            this.eventEmitter.on(exports.OfferEvent.OFFER_SURFACED, ({ offer }) => {
+            this.eventEmitter.on(OfferEvent.OFFER_SURFACED, ({ offer }) => {
                 this.offerStore.upsertOffer(offer); // should always be selfId
                 this.logger.log(`Surfaced offer: ${offer.instanceId}`);
             });
@@ -1178,11 +1195,11 @@
             try {
                 const { offers, player } = await this.getOffersAndPlayer(targetId);
                 if (targetId == null) {
-                    this.selfId = player.gameData.playerId;
+                    this.selfId = player.snapshot?.playerId ?? null;
                 }
                 this.offerStore.setPlayer(player);
                 this.offerStore.setOffers(offers, player);
-                this.eventEmitter.emit(exports.OfferEvent.REFRESH, { offers, player: player });
+                this.eventEmitter.emit(OfferEvent.REFRESH, { offers, player: player });
                 this.logger.log('Refreshed offers and player snapshot');
                 return offers;
             }
@@ -1327,1544 +1344,10 @@
         }
     }
 
-    const DEFAULT_ENTITY_KIND = '_default';
-
-    const keyPattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
-    /**
-     * This replaces {keyName} keys from the template with corresponding values from the dynamic object.
-     */
-    function renderTemplate(template, dynamic) {
-        if (!template)
-            return '';
-        return template.replace(keyPattern, (_match, key) => {
-            if (dynamic && typeof dynamic[key] === 'boolean') {
-                return dynamic[key] ? '✓' : '✗';
-            }
-            if (dynamic && dynamic[key] !== undefined) {
-                return String(dynamic[key]);
-            }
-            return '{?}'; // indicate missing key
-        });
-    }
-    /**
-     * This replaces {{keyName}} in dynamic condition keys with corresponding values from
-     * the PlayerOffer.trackers
-     *
-     * eg. a condition high_score_pet-{{surfacerPlayerId}} with high_score_pet-12345
-     */
-    function replaceDynamicConditionKey(key, trackers) {
-        return key?.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (match, p1) => {
-            const value = trackers[p1];
-            return value !== undefined ? String(value) : match;
-        });
-    }
-    /** this replaces all of the dynamic conditions.keys by calling replaceDynamicConditionKey */
-    function replaceDynamicConditionKeys(conditions, trackers) {
-        return conditions.map((condition) => ({
-            ...condition,
-            key: replaceDynamicConditionKey(condition.key, trackers),
-        }));
-    }
-
-    const dynamicTrackerToPrimitive = (dynaTrack) => {
-        const primitive = {};
-        for (const key in dynaTrack) {
-            primitive[key] = dynaTrack[key].value || 0;
-        }
-        return primitive;
-    };
-
-    const addressNetworkId = (contractAddress, network) => {
-        return `${contractAddress.toLowerCase()}:${network.toUpperCase()}`;
-    };
-
-    const meetsBaseConditions = ({ conditions, playerSnap, addDetails, 
-    /** this exists if calling meetsBaseConditions from meetsCompletionConditions. but surfacing
-     * check doesn't use this since we don't have a playerOffer at surfacing time
-     */
-    playerOffer, 
-    /** Additional data like fetched token balances that isn't part of playerSnap */
-    additionalData, }) => {
-        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,
-                    trackerGoal: conditions.minDaysInGame,
-                    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,
-                    trackerGoal: conditions.minTrustScore,
-                    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) {
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: false,
-                        kind: 'achievements',
-                        trackerAmount: 0,
-                        trackerGoal: 1,
-                        text: `Have the achievement ${a.name}`,
-                    });
-                    isValid = false;
-                }
-                else {
-                    return { isValid: false };
-                }
-            }
-            if (a.minCount) {
-                const isDisqualify = (playerAchData?.count || 0) < a.minCount;
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'achievements',
-                        trackerAmount: playerAchData?.count || 0,
-                        trackerGoal: a.minCount,
-                        text: `Have the achievement ${a.name} more than ${a.minCount} times`,
-                    });
-                    if (isDisqualify)
-                        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,
-                        trackerGoal: c.min,
-                        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,
-                        trackerGoal: c.in,
-                        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,
-                        trackerGoal: c.out,
-                        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,
-                        trackerGoal: l.min,
-                        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)
-                    : true; // if player has no data for this quest, they haven't completed it
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'quests',
-                        trackerAmount: playerQuestData?.completions || 0,
-                        trackerGoal: quest.completions || 1,
-                        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,
-                        trackerGoal: m.minCount,
-                        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)),
-                        trackerGoal: Number((m.minMs / (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,
-                        trackerGoal: s.min,
-                        text: `Have at least ${s.min} ${s.name} staked`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false };
-                }
-            }
-        }
-        // Validate link count conditions
-        if (conditions?.links && 'entityLinks' in playerSnap) {
-            for (const [linkType, constraint] of Object.entries(conditions.links)) {
-                // linkType should always exist. and be default is none was specified
-                const linkCount = playerSnap.entityLinks?.filter((link) => (link.kind || DEFAULT_ENTITY_KIND) === linkType).length || 0;
-                if (constraint.min !== undefined) {
-                    const isDisqualify = linkCount < constraint.min;
-                    if (addDetails) {
-                        conditionData.push({
-                            isMet: !isDisqualify,
-                            kind: 'links',
-                            trackerAmount: linkCount,
-                            trackerGoal: constraint.min,
-                            text: constraint.template
-                                ? renderTemplate(constraint.template, {
-                                    current: linkCount,
-                                    min: constraint.min ?? 0,
-                                    max: constraint.max ?? 0,
-                                    type: linkType,
-                                })
-                                : `At least ${constraint.min} ${linkType} link(s)`,
-                        });
-                        if (isDisqualify)
-                            isValid = false;
-                    }
-                    else {
-                        if (isDisqualify)
-                            return { isValid: false };
-                    }
-                }
-                if (constraint.max !== undefined) {
-                    const isDisqualify = linkCount > constraint.max;
-                    if (addDetails) {
-                        conditionData.push({
-                            isMet: !isDisqualify,
-                            kind: 'links',
-                            trackerAmount: linkCount,
-                            text: constraint.template
-                                ? renderTemplate(constraint.template, {
-                                    current: linkCount,
-                                    min: constraint.min ?? 0,
-                                    max: constraint.max ?? 0,
-                                    type: linkType,
-                                })
-                                : `At most ${constraint.max} ${linkType} link(s)`,
-                        });
-                        if (isDisqualify)
-                            isValid = false;
-                    }
-                    else {
-                        if (isDisqualify)
-                            return { isValid: false };
-                    }
-                }
-            }
-        }
-        // Evaluate dynamic conditions
-        if (conditions?.dynamic?.conditions?.length) {
-            const resolvedConditions = replaceDynamicConditionKeys(conditions.dynamic.conditions, playerOffer?.trackers || {});
-            const dynamicResult = meetsDynamicConditions(playerSnap.dynamic, {
-                ...conditions.dynamic,
-                conditions: resolvedConditions,
-            });
-            if (addDetails) {
-                conditionData.push({
-                    isMet: dynamicResult,
-                    kind: 'dynamic',
-                    text: renderTemplate(conditions.dynamic.template, playerSnap.dynamic) ||
-                        'Dynamic conditions',
-                });
-                if (!dynamicResult)
-                    isValid = false;
-            }
-            else {
-                if (!dynamicResult)
-                    return { isValid: false };
-            }
-        }
-        if (conditions?.identifiers?.platforms?.length && 'identifiers' in playerSnap) {
-            const playerPlatforms = new Set(playerSnap.identifiers?.map((i) => i.platform.toLowerCase()) || []);
-            const isAndBehaviour = conditions.identifiers.behaviour === 'AND';
-            const platformsToCheck = conditions.identifiers.platforms;
-            let isMet;
-            let displayText;
-            if (isAndBehaviour) {
-                isMet = platformsToCheck.every((platform) => playerPlatforms.has(platform.toLowerCase()));
-                displayText = `Link all: ${platformsToCheck.join(', ')}`;
-            }
-            else {
-                isMet = platformsToCheck.some((platform) => playerPlatforms.has(platform.toLowerCase()));
-                displayText = `Link any: ${platformsToCheck.join(', ')}`;
-            }
-            if (addDetails) {
-                conditionData.push({
-                    isMet,
-                    kind: 'identifiers',
-                    trackerAmount: isMet ? 1 : 0,
-                    trackerGoal: 1,
-                    text: displayText,
-                });
-                if (!isMet)
-                    isValid = false;
-            }
-            else {
-                if (!isMet)
-                    return { isValid: false };
-            }
-        }
-        // Evaluate token balance conditions
-        for (const tokenCond of conditions?.tokenBalances || []) {
-            const contracts = tokenCond.contracts || [];
-            let totalBalance = 0;
-            const fetchedBalances = aggregateTokenBalances(additionalData);
-            for (const contract of contracts) {
-                const balanceKey = addressNetworkId(contract.contractAddress, contract.network);
-                totalBalance += fetchedBalances[balanceKey] || 0;
-            }
-            if (tokenCond.min !== undefined) {
-                const isDisqualify = totalBalance < tokenCond.min;
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'tokenBalances',
-                        trackerAmount: totalBalance,
-                        trackerGoal: tokenCond.min,
-                        text: `Have at least ${tokenCond.min} ${tokenCond.name || 'tokens'}`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false };
-                }
-            }
-            if (tokenCond.max !== undefined) {
-                const isDisqualify = totalBalance > tokenCond.max;
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'tokenBalances',
-                        trackerAmount: totalBalance,
-                        text: `Have at most ${tokenCond.max} ${tokenCond.name || 'tokens'}`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false };
-                }
-            }
-        }
-        return { isValid, conditionData: addDetails ? conditionData : undefined };
-    };
-    const meetsSurfacingConditions = ({ surfacingConditions, playerSnap, context, playerOffers, ignoreRequiredCompletions, additionalData, }) => {
-        if (surfacingConditions?.contexts?.length &&
-            !surfacingConditions.contexts?.includes(context || '')) {
-            // context is not in the list of surfacing contexts, so we don't want to surface this offer
-            return { isValid: false };
-        }
-        if (surfacingConditions?.targetEntityTypes?.length) {
-            const playerTarget = playerSnap.entityKind || DEFAULT_ENTITY_KIND;
-            // check if entity type is allowed
-            if (!surfacingConditions.targetEntityTypes.includes(playerTarget)) {
-                return { isValid: false };
-            }
-        }
-        const conditions = surfacingConditions;
-        if (conditions?.andTags?.length) {
-            // check if player has all of the tags
-            const hasAllTags = conditions.andTags.every((tag) => playerSnap.tags?.includes(tag));
-            if (!hasAllTags) {
-                return { isValid: false };
-            }
-        }
-        if (conditions?.orTags?.length) {
-            // check if player has any of the tags
-            const hasAnyTags = conditions.orTags.some((tag) => playerSnap.tags?.includes(tag));
-            if (!hasAnyTags) {
-                return { isValid: false };
-            }
-        }
-        if (conditions?.notTags?.length) {
-            // check if player has any of the tags
-            const hasAnyTags = conditions.notTags.some((tag) => playerSnap.tags?.includes(tag));
-            if (hasAnyTags) {
-                return { isValid: false };
-            }
-        }
-        if (conditions?.maxDaysInGame &&
-            (playerSnap.daysInGame ?? 0) > conditions.maxDaysInGame) {
-            return { isValid: false };
-        }
-        if (conditions.loginStreak && (playerSnap.loginStreak || 0) < conditions.loginStreak) {
-            return { isValid: false };
-        }
-        // Check dateSignedUp conditions
-        if (conditions.minDateSignedUp &&
-            (!playerSnap.dateSignedUp || playerSnap.dateSignedUp < conditions.minDateSignedUp)) {
-            return { isValid: false };
-        }
-        if (conditions.maxDateSignedUp &&
-            (!playerSnap.dateSignedUp || playerSnap.dateSignedUp > conditions.maxDateSignedUp)) {
-            return { isValid: false };
-        }
-        const completedOfferIds = new Set();
-        for (const pOffer of playerOffers?.values() || []) {
-            if (pOffer.status === 'claimed' || pOffer.status === 'claimable') {
-                completedOfferIds.add(pOffer.offer_id.toString());
-            }
-        }
-        if (conditions.completedOffers?.length) {
-            const hasCompletedAllOffers = conditions.completedOffers.every((offerId) => completedOfferIds.has(offerId));
-            if (!hasCompletedAllOffers && !ignoreRequiredCompletions) {
-                return { isValid: false };
-            }
-        }
-        if (conditions.allowedCountries?.length) {
-            const playerCountry = playerSnap.ip?.countryCode;
-            if (!playerCountry || !conditions.allowedCountries.includes(playerCountry)) {
-                return { isValid: false };
-            }
-        }
-        if (conditions.restrictedCountries?.length) {
-            const playerCountry = playerSnap.ip?.countryCode;
-            if (!playerCountry) {
-                return { isValid: false };
-            }
-            if (conditions.restrictedCountries.includes(playerCountry)) {
-                return { isValid: false };
-            }
-        }
-        if (conditions.networkRestrictions?.length) {
-            if (!playerSnap.ip) {
-                return { isValid: false };
-            }
-            for (const restriction of conditions.networkRestrictions) {
-                if (playerSnap.ip[restriction]) {
-                    return { isValid: false };
-                }
-            }
-        }
-        return meetsBaseConditions({ conditions, playerSnap, additionalData });
-    };
-    const hasConditions = (conditions) => {
-        if (!conditions)
-            return false;
-        if (Object.keys(conditions.currencies || {}).length > 0)
-            return true;
-        if (Object.keys(conditions.levels || {}).length > 0)
-            return true;
-        if (Object.keys(conditions.stakedTokens || {}).length > 0)
-            return true;
-        if (Object.keys(conditions.memberships || {}).length > 0)
-            return true;
-        if (Object.keys(conditions.quests || {}).length > 0)
-            return true;
-        if (conditions.minTrustScore)
-            return true;
-        if (conditions.maxTrustScore)
-            return true;
-        if (conditions.achievements)
-            return true;
-        if (conditions.minDaysInGame)
-            return true;
-        if (conditions.dynamic?.conditions?.length)
-            return true;
-        if (conditions.identifiers?.platforms?.length)
-            return true;
-        const surCond = conditions;
-        if (surCond.contexts?.length)
-            return true;
-        if (surCond.andTags?.length)
-            return true;
-        if (surCond.orTags?.length)
-            return true;
-        if (surCond.notTags?.length)
-            return true;
-        if (surCond.maxDaysInGame)
-            return true;
-        if (surCond.loginStreak)
-            return true;
-        if (surCond.minDateSignedUp)
-            return true;
-        if (surCond.maxDateSignedUp)
-            return true;
-        if (surCond.completedOffers?.length)
-            return true;
-        if (surCond.programmatic)
-            return true;
-        if (surCond.targetEntityTypes?.length)
-            return true;
-        if (surCond.links && Object.keys(surCond.links).length > 0)
-            return true;
-        if (surCond.allowedCountries?.length)
-            return true;
-        if (surCond.restrictedCountries?.length)
-            return true;
-        if (surCond.networkRestrictions?.length)
-            return true;
-        if (surCond.linkedEntityOffers?.offer_id)
-            return true;
-        const compCond = conditions;
-        if (compCond.context)
-            return true;
-        if (compCond.buyItem)
-            return true;
-        if (compCond.spendCurrency)
-            return true;
-        if (compCond.depositCurrency)
-            return true;
-        if (compCond.social)
-            return true;
-        if (compCond.login)
-            return true;
-        if (compCond.loginStreak)
-            return true;
-        if (compCond.linkedCompletions)
-            return true;
-        if (compCond.dynamicTracker?.conditions?.length)
-            return true;
-        if (conditions.tokenBalances?.length)
-            return true;
-        if (Object.keys(compCond.contractInteractions || {}).length > 0)
-            return true;
-        return false;
-    };
-    const meetsLinkedEntityOffersCondition = ({ linkedEntityOffers, matchingLinks, linkedPOfferMap, }) => {
-        if (!linkedPOfferMap)
-            return { isValid: false };
-        const linkedPlayerOffer_ids = [];
-        for (const link of matchingLinks) {
-            const key = `${link.playerId}:${linkedEntityOffers.offer_id}`;
-            const po = linkedPOfferMap.get(key);
-            if (po) {
-                linkedPlayerOffer_ids.push(po._id.toString());
-            }
-        }
-        if (linkedPlayerOffer_ids.length > 0) {
-            return { isValid: true, linkedPlayerOffer_ids };
-        }
-        return { isValid: false };
-    };
-    const offerMeetsCompletionConditions = (offer, snapshot, additionalData) => {
-        return meetsCompletionConditions({
-            completionConditions: offer.completionConditions || {},
-            completionTrackers: offer.completionTrackers,
-            playerSnap: snapshot,
-            playerOffer: offer,
-            addDetails: true,
-            maxClaimCount: offer.maxClaimCount,
-            additionalData,
-        });
-    };
-    const meetsCompletionConditions = ({ completionConditions, completionTrackers, playerSnap, playerOffer, addDetails = false, maxClaimCount, additionalData, }) => {
-        if (completionConditions) {
-            const conditions = completionConditions;
-            // For multi-claim offers, scale cumulative requirements by (claimedCount + 1)
-            const shouldScale = maxClaimCount === -1 || (maxClaimCount && maxClaimCount > 1);
-            const claimMultiplier = shouldScale
-                ? (playerOffer.trackers?.claimedCount || 0) + 1
-                : 1;
-            const conditionData = [];
-            let isValid = true;
-            let maxTotalClaimsFromScaling = Infinity;
-            const updateMax = (limit) => (maxTotalClaimsFromScaling = Math.min(maxTotalClaimsFromScaling, limit));
-            if (completionConditions?.context?.id) {
-                const hasTrackedContext = completionTrackers?.context &&
-                    completionConditions.context.id === completionTrackers.context;
-                const isDisqualify = !hasTrackedContext;
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'context',
-                        trackerAmount: hasTrackedContext ? 1 : 0,
-                        trackerGoal: 1,
-                        text: completionConditions.context.name,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, availableClaimsNow: 0 };
-                }
-            }
-            if (conditions?.buyItem) {
-                const baseAmount = conditions.buyItem.amount || 1;
-                const scaledAmount = baseAmount * claimMultiplier;
-                const trackerValue = completionTrackers?.buyItem || 0;
-                const isDisqualify = trackerValue < scaledAmount;
-                if (shouldScale && baseAmount > 0) {
-                    updateMax(Math.floor(trackerValue / baseAmount));
-                }
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'buyItem',
-                        trackerAmount: trackerValue,
-                        trackerGoal: scaledAmount,
-                        text: `Buy ${scaledAmount} ${conditions.buyItem.name}`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, availableClaimsNow: 0 };
-                }
-            }
-            if (conditions?.spendCurrency) {
-                const baseAmount = conditions.spendCurrency.amount || 1;
-                const scaledAmount = baseAmount * claimMultiplier;
-                const trackerValue = completionTrackers?.spendCurrency || 0;
-                const isDisqualify = trackerValue < scaledAmount;
-                if (shouldScale && baseAmount > 0) {
-                    updateMax(Math.floor(trackerValue / baseAmount));
-                }
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'spendCurrency',
-                        trackerAmount: trackerValue,
-                        trackerGoal: scaledAmount,
-                        text: `Spend ${scaledAmount} ${conditions.spendCurrency.name}`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, availableClaimsNow: 0 };
-                }
-            }
-            if (conditions?.depositCurrency) {
-                const baseAmount = conditions.depositCurrency.amount || 1;
-                const scaledAmount = baseAmount * claimMultiplier;
-                const trackerValue = completionTrackers?.depositCurrency || 0;
-                const isDisqualify = trackerValue < scaledAmount;
-                if (shouldScale && baseAmount > 0) {
-                    updateMax(Math.floor(trackerValue / baseAmount));
-                }
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'depositCurrency',
-                        trackerAmount: trackerValue,
-                        trackerGoal: scaledAmount,
-                        text: `Deposit ${scaledAmount} ${conditions.depositCurrency.name}`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, availableClaimsNow: 0 };
-                }
-            }
-            if (conditions?.login) {
-                const isMet = new Date(playerSnap.snapshotLastUpdated || 0).getTime() >
-                    new Date(playerOffer.createdAt || 0).getTime();
-                if (addDetails) {
-                    conditionData.push({
-                        isMet,
-                        kind: 'login',
-                        trackerAmount: isMet ? 1 : 0,
-                        trackerGoal: 1,
-                        text: `Login to the game`,
-                    });
-                    if (!isMet)
-                        isValid = false;
-                }
-                else {
-                    if (!isMet)
-                        return { isValid: false, availableClaimsNow: 0 };
-                }
-            }
-            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: streakSinceOffer + 1,
-                        trackerGoal: conditions.loginStreak,
-                        text: `Login streak of ${conditions.loginStreak || 0} days`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, availableClaimsNow: 0 };
-                }
-            }
-            if (conditions?.social) {
-                const tSocialAccumulate = completionTrackers?.social;
-                const tSocialAttach = completionTrackers?.social;
-                const cSocial = completionConditions.social;
-                const mode = cSocial?.mode || 'attach';
-                const tSocial = mode === 'accumulate' ? tSocialAccumulate : tSocialAttach;
-                const hasContent = Boolean(mode === 'accumulate'
-                    ? tSocialAccumulate?.matchCount > 0
-                    : tSocialAttach?.videoId);
-                // Only scale social metrics in accumulate mode (attach mode is single content)
-                const socialMultiplier = mode === 'accumulate' ? claimMultiplier : 1;
-                const minLikes = (cSocial?.minLikes || 0) * socialMultiplier;
-                const minViews = (cSocial?.minViews || 0) * socialMultiplier;
-                const minComments = (cSocial?.minComments || 0) * socialMultiplier;
-                const likes = tSocial?.likes || 0;
-                const views = tSocial?.views || 0;
-                const comments = tSocial?.comments || 0;
-                let isDisqualify = !hasContent;
-                if (likes < minLikes || views < minViews || comments < minComments) {
-                    isDisqualify = true;
-                }
-                if (shouldScale && mode === 'accumulate' && hasContent) {
-                    const baseLikes = cSocial?.minLikes || 0;
-                    const baseViews = cSocial?.minViews || 0;
-                    const baseComments = cSocial?.minComments || 0;
-                    if (baseLikes > 0)
-                        updateMax(Math.floor(likes / baseLikes));
-                    if (baseViews > 0)
-                        updateMax(Math.floor(views / baseViews));
-                    if (baseComments > 0)
-                        updateMax(Math.floor(comments / baseComments));
-                }
-                if (addDetails) {
-                    const platformMap = {
-                        tiktok: 'TikTok',
-                        instagram: 'Instagram',
-                        youtube: 'YouTube',
-                    };
-                    const platformText = conditions.social.platforms
-                        .map((platform) => platformMap[platform])
-                        .join(' | ');
-                    const requiredWords = cSocial?.requiredWords ?? [];
-                    if (mode === 'accumulate') {
-                        const matchCount = tSocialAccumulate?.matchCount || 0;
-                        conditionData.push({
-                            isMet: hasContent,
-                            kind: 'social',
-                            trackerAmount: matchCount,
-                            trackerGoal: 1,
-                            text: hasContent
-                                ? `Found ${matchCount} matching ${platformText} post${matchCount !== 1 ? 's' : ''}`
-                                : requiredWords.length > 0
-                                    ? `Post ${platformText} content with ${requiredWords.map((w) => `"${w}"`).join(', ')}`
-                                    : `Post ${platformText} content`,
-                        });
-                    }
-                    else {
-                        const title = tSocialAttach?.title;
-                        conditionData.push({
-                            isMet: hasContent,
-                            kind: 'social',
-                            trackerAmount: hasContent ? 1 : 0,
-                            trackerGoal: 1,
-                            text: !hasContent
-                                ? requiredWords.length > 0
-                                    ? `Attach a ${platformText} post with ${requiredWords.map((w) => `"${w}"`).join(', ')} in the title`
-                                    : `Attach a ${platformText} post`
-                                : `Attached: ${title}`,
-                        });
-                    }
-                    if (minLikes > 0) {
-                        conditionData.push({
-                            isMet: hasContent && likes >= minLikes,
-                            kind: 'social',
-                            trackerAmount: likes,
-                            trackerGoal: minLikes,
-                            text: mode === 'accumulate'
-                                ? `Combined ${minLikes} Likes`
-                                : `Reach ${minLikes} Likes`,
-                        });
-                    }
-                    if (minViews > 0) {
-                        conditionData.push({
-                            isMet: hasContent && views >= minViews,
-                            kind: 'social',
-                            trackerAmount: views,
-                            trackerGoal: minViews,
-                            text: mode === 'accumulate'
-                                ? `Combined ${minViews} Views`
-                                : `Reach ${minViews} Views`,
-                        });
-                    }
-                    if (minComments > 0) {
-                        conditionData.push({
-                            isMet: hasContent && comments >= minComments,
-                            kind: 'social',
-                            trackerAmount: comments,
-                            trackerGoal: minComments,
-                            text: mode === 'accumulate'
-                                ? `Combined ${minComments} Comments`
-                                : `Reach ${minComments} Comments`,
-                        });
-                    }
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, availableClaimsNow: 0 };
-                }
-            }
-            // Linked completions - wait for N linked entities to complete
-            if (conditions?.linkedCompletions?.min) {
-                const baseMin = conditions.linkedCompletions.min;
-                const currentCount = completionTrackers?.linkedCompletions || 0;
-                const scaledMin = baseMin * claimMultiplier;
-                const isDisqualify = currentCount < scaledMin;
-                if (shouldScale && baseMin > 0) {
-                    updateMax(Math.floor(currentCount / baseMin));
-                }
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'linkedCompletions',
-                        trackerAmount: currentCount,
-                        trackerGoal: scaledMin,
-                        text: conditions.linkedCompletions.template
-                            ? renderTemplate(conditions.linkedCompletions.template, {
-                                current: currentCount,
-                                required: scaledMin,
-                            })
-                            : `Wait for ${scaledMin} linked ${scaledMin === 1 ? 'entity' : 'entities'} to complete`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, availableClaimsNow: 0 };
-                }
-            }
-            if (conditions?.dynamicTracker?.conditions?.length) {
-                const resolvedConditions = replaceDynamicConditionKeys(conditions.dynamicTracker.conditions, playerOffer?.trackers || {});
-                // now we have the game-defined conditions with {{}} keys populated. feed these conditions into evaluator
-                const dynamicResult = meetsDynamicConditions(dynamicTrackerToPrimitive(completionTrackers?.dynamicTracker || {}), {
-                    ...conditions.dynamicTracker,
-                    conditions: resolvedConditions,
-                }, claimMultiplier);
-                if (shouldScale) {
-                    const dynamicMax = getMaxClaimsForDynamicGroup(dynamicTrackerToPrimitive(completionTrackers?.dynamicTracker || {}), {
-                        ...conditions.dynamicTracker,
-                        conditions: resolvedConditions,
-                    }, playerOffer?.trackers?.claimedCount || 0);
-                    updateMax(dynamicMax);
-                }
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: dynamicResult,
-                        kind: 'dynamicTracker',
-                        text: renderTemplate(conditions.dynamicTracker.template, dynamicTrackerToPrimitive(completionTrackers?.dynamicTracker || {})) || 'Dynamic conditions',
-                    });
-                    if (!dynamicResult)
-                        isValid = false;
-                }
-                else {
-                    if (!dynamicResult)
-                        return { isValid: false, availableClaimsNow: 0 };
-                }
-            }
-            // Evaluate contractInteractions completion trackers
-            if (conditions?.contractInteractions) {
-                for (const [conditionId, condition] of Object.entries(conditions.contractInteractions)) {
-                    const baseAmount = condition.amount || 0;
-                    const scaledAmount = baseAmount * claimMultiplier;
-                    const trackerValue = completionTrackers?.contractInteractions?.[conditionId] || 0;
-                    const isDisqualify = trackerValue < scaledAmount;
-                    if (shouldScale && baseAmount > 0) {
-                        updateMax(Math.floor(trackerValue / baseAmount));
-                    }
-                    if (addDetails) {
-                        const displayText = renderTemplate(condition.template, {
-                            current: trackerValue,
-                            amount: scaledAmount,
-                        });
-                        conditionData.push({
-                            isMet: !isDisqualify,
-                            kind: 'contractInteractions',
-                            trackerAmount: trackerValue,
-                            trackerGoal: scaledAmount,
-                            text: displayText,
-                        });
-                        if (isDisqualify)
-                            isValid = false;
-                    }
-                    else {
-                        if (isDisqualify)
-                            return { isValid: false, availableClaimsNow: 0 };
-                    }
-                }
-            }
-            const r = meetsBaseConditions({
-                conditions,
-                playerSnap,
-                addDetails: true,
-                playerOffer,
-                additionalData,
-            });
-            isValid = isValid && r.isValid;
-            conditionData.push(...(r.conditionData || []));
-            if (maxClaimCount && maxClaimCount > 0) {
-                updateMax(maxClaimCount);
-            }
-            const claimedCount = playerOffer?.trackers?.claimedCount || 0;
-            const availableClaimsNow = !isValid
-                ? 0
-                : maxTotalClaimsFromScaling === Infinity
-                    ? -1
-                    : Math.max(0, maxTotalClaimsFromScaling - claimedCount);
-            return { isValid, conditionData, availableClaimsNow };
-        }
-        return { isValid: true, conditionData: [], availableClaimsNow: -1 };
-    };
-    /**
-     * Checks if completion conditions were met before a specific expiry time.
-     * Returns true if all relevant condition fields were updated before expiryTime.
-     *
-     * @param completionConditions - The completion conditions to check
-     * @param completionTrackers - The completion trackers (for buyItem, spendCurrency, etc.)
-     * @param playerSnap - The player snapshot with field timestamps
-     * @returns true if all conditions were met before expiry, false otherwise
-     */
-    const meetsCompletionConditionsBeforeExpiry = ({ completionConditions, completionTrackers, playerSnap, playerOffer, maxClaimCount, }) => {
-        if (!completionConditions)
-            return false;
-        // Check if there are actually any conditions to evaluate
-        if (!hasConditions(completionConditions))
-            return false;
-        // First check if conditions are actually met
-        const conditionsMet = meetsCompletionConditions({
-            completionConditions,
-            completionTrackers,
-            playerOffer,
-            playerSnap,
-            maxClaimCount,
-        });
-        if (!conditionsMet.isValid)
-            return false;
-        if (!playerOffer.expiresAt)
-            return true;
-        const expiryTime = new Date(playerOffer.expiresAt).getTime();
-        const lastSnapshotUpdate = new Date(playerSnap.snapshotLastUpdated).getTime();
-        /**
-         * Checks if a field was updated after the expiry time.
-         * Returns true if updated AFTER or AT expiry (violates grace period).
-         * Returns false if updated BEFORE expiry (allows grace period).
-         */
-        function wasUpdatedAfterExpiry(data) {
-            let lastUpdated;
-            if (typeof data === 'object' && data !== null && !(data instanceof Date)) {
-                // Object with optional lastUpdated field
-                lastUpdated = data.lastUpdated
-                    ? new Date(data.lastUpdated).getTime()
-                    : lastSnapshotUpdate;
-            }
-            else if (data instanceof Date) {
-                lastUpdated = data.getTime();
-            }
-            else if (typeof data === 'string' || typeof data === 'number') {
-                lastUpdated = new Date(data).getTime();
-            }
-            else {
-                // No data provided, use snapshot timestamp
-                lastUpdated = lastSnapshotUpdate;
-            }
-            return lastUpdated >= expiryTime;
-        }
-        if (completionConditions.currencies) {
-            for (const currencyId in completionConditions.currencies) {
-                const currency = playerSnap.currencies?.[currencyId];
-                if (!currency)
-                    continue;
-                if (wasUpdatedAfterExpiry(currency))
-                    return false;
-            }
-        }
-        if (completionConditions.levels) {
-            for (const skillId in completionConditions.levels) {
-                const level = playerSnap.levels?.[skillId];
-                if (!level)
-                    continue;
-                if (wasUpdatedAfterExpiry(level))
-                    return false;
-            }
-        }
-        if (completionConditions.quests) {
-            for (const questId in completionConditions.quests) {
-                const quest = playerSnap.quests?.[questId];
-                if (!quest)
-                    continue;
-                if (wasUpdatedAfterExpiry(quest))
-                    return false;
-            }
-        }
-        if (completionConditions.memberships) {
-            for (const membershipId in completionConditions.memberships) {
-                const membership = playerSnap.memberships?.[membershipId];
-                if (!membership)
-                    continue;
-                if (wasUpdatedAfterExpiry(membership))
-                    return false;
-            }
-        }
-        if (completionConditions.achievements) {
-            for (const achievementId in completionConditions.achievements) {
-                const achievement = playerSnap.achievements?.[achievementId];
-                if (!achievement)
-                    continue;
-                if (wasUpdatedAfterExpiry(achievement))
-                    return false;
-            }
-        }
-        if (completionConditions.stakedTokens) {
-            for (const tokenId in completionConditions.stakedTokens) {
-                const stakedToken = playerSnap.stakedTokens?.[tokenId];
-                if (!stakedToken)
-                    continue;
-                const lastStakeTime = new Date(stakedToken.lastStake ?? 0).getTime();
-                const lastUnstakeTime = new Date(stakedToken.lastUnstake ?? 0).getTime();
-                const lastUpdated = Math.max(lastStakeTime, lastUnstakeTime);
-                if (lastUpdated >= expiryTime)
-                    return false;
-            }
-        }
-        if (completionConditions.minTrustScore !== undefined ||
-            completionConditions.maxTrustScore !== undefined) {
-            if (wasUpdatedAfterExpiry(playerSnap.trustLastUpdated))
-                return false;
-        }
-        if (completionConditions.minDaysInGame !== undefined) {
-            if (wasUpdatedAfterExpiry(playerSnap.daysInGameLastUpdated))
-                return false;
-        }
-        if (completionConditions.login || completionConditions.loginStreak) {
-            if (wasUpdatedAfterExpiry())
-                return false;
-        }
-        if (completionConditions.social) {
-            // Check if social content was attached/validated after expiry
-            if (completionTrackers?.social?.lastChecked) {
-                if (wasUpdatedAfterExpiry(completionTrackers.social.lastChecked))
-                    return false;
-            }
-        }
-        // All conditions were met before expiry
-        return true;
-    };
-    /**
-     * Checks if a dynamic object meets a set of dynamic field conditions.
-     * @param dynamicObj - The object with any key and string or number value.
-     * @param conditions - Array of conditions to check.
-     * @param claimMultiplier - Multiplier to scale conditions (used for numeric comparisons).
-     * @returns true if all conditions are met, false otherwise.
-     */
-    /**
-     * Evaluates a single dynamic condition against the dynamic object.
-     */
-    function evaluateDynamicCondition(dynamicObj, cond, claimMultiplier = 1) {
-        if (!dynamicObj)
-            return false;
-        const val = dynamicObj[cond.key];
-        if (val == undefined)
-            return false;
-        const isNumber = typeof val === 'number';
-        const isBoolean = typeof val === 'boolean';
-        if (isBoolean) {
-            switch (cond.operator) {
-                case '==':
-                    return val === Boolean(cond.compareTo);
-                case '!=':
-                    return val !== Boolean(cond.compareTo);
-                default:
-                    return false;
-            }
-        }
-        const compareTo = isNumber ? Number(cond.compareTo) : String(cond.compareTo);
-        if (isNumber && typeof compareTo === 'number') {
-            const skipMultiplier = cond.operator === '==' || cond.operator === '!=';
-            const scaledCompareTo = skipMultiplier ? compareTo : compareTo * claimMultiplier;
-            switch (cond.operator) {
-                case '==':
-                    return val === scaledCompareTo;
-                case '!=':
-                    return val !== scaledCompareTo;
-                case '>':
-                    return val > scaledCompareTo;
-                case '>=':
-                    return val >= scaledCompareTo;
-                case '<':
-                    return val < scaledCompareTo;
-                case '<=':
-                    return val <= scaledCompareTo;
-            }
-        }
-        else if (!isNumber && typeof compareTo === 'string') {
-            switch (cond.operator) {
-                case '==':
-                    return val === compareTo;
-                case '!=':
-                    return val !== compareTo;
-                case 'has':
-                    return val.includes(compareTo);
-                case 'not_has':
-                    return !val.includes(compareTo);
-            }
-        }
-        return false;
-    }
-    /**
-     * Calculates the maximum number of claims supported by a single dynamic condition.
-     */
-    function getMaxClaimsForDynamicCondition(dynamicObj, cond) {
-        if (!dynamicObj)
-            return 0;
-        const val = dynamicObj[cond.key];
-        if (val === undefined)
-            return 0;
-        if (typeof val === 'number') {
-            const base = Number(cond.compareTo);
-            if (isNaN(base)) {
-                return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
-            }
-            switch (cond.operator) {
-                case '>=':
-                    if (base === 0)
-                        return val >= 0 ? Infinity : 0;
-                    if (base < 0)
-                        return val >= base ? Infinity : 0;
-                    return Math.max(0, Math.floor(val / base));
-                case '>':
-                    if (base === 0)
-                        return val > 0 ? Infinity : 0;
-                    if (base < 0)
-                        return val > base ? Infinity : 0;
-                    if (val <= 0)
-                        return 0;
-                    return Math.max(0, Math.ceil(val / base) - 1);
-                case '==':
-                    return val === base ? Infinity : 0;
-                case '!=':
-                    return val !== base ? Infinity : 0;
-                case '<=':
-                    if (base === 0)
-                        return val <= 0 ? Infinity : 0;
-                    if (base > 0)
-                        return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
-                    if (val >= 0)
-                        return 0;
-                    return Math.max(0, Math.floor(val / base));
-                case '<':
-                    if (base === 0)
-                        return val < 0 ? Infinity : 0;
-                    if (base > 0)
-                        return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
-                    if (val >= 0)
-                        return 0;
-                    return Math.max(0, Math.ceil(val / base) - 1);
-            }
-        }
-        // we don't scale the rest, they are always true or always false
-        return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
-    }
-    /**
-     * Calculates the maximum number of claims supported by a group of dynamic conditions.
-     */
-    function getMaxClaimsForDynamicGroup(dynamicObj, dynamicGroup, currentClaimCount = 0) {
-        const { conditions, links } = dynamicGroup;
-        if (!conditions || conditions.length === 0)
-            return Infinity;
-        // AND only
-        if (!links || links.length === 0 || links.every((l) => l === 'AND')) {
-            let minClaims = Infinity;
-            for (const cond of conditions) {
-                const max = getMaxClaimsForDynamicCondition(dynamicObj, cond);
-                if (max === 0)
-                    return 0;
-                minClaims = Math.min(minClaims, max);
-            }
-            return minClaims;
-        }
-        // OR only
-        if (links.every((l) => l === 'OR')) {
-            let maxClaims = 0;
-            for (const cond of conditions) {
-                const max = getMaxClaimsForDynamicCondition(dynamicObj, cond);
-                if (max === Infinity)
-                    return Infinity;
-                maxClaims = Math.max(maxClaims, max);
-            }
-            return maxClaims;
-        }
-        // mixed:
-        const maxIterations = 100;
-        for (let n = currentClaimCount + 1; n <= currentClaimCount + maxIterations; n++) {
-            if (!meetsDynamicConditions(dynamicObj, dynamicGroup, n)) {
-                return n - 1;
-            }
-        }
-        return currentClaimCount + maxIterations;
-    }
-    /**
-     * Evaluates a group of dynamic conditions with logical links (AND, OR, AND NOT).
-     * @param dynamicObj - The player's dynamic object with any key and string or number value.
-     * @param dynamicGroup - The group of conditions and links to check.
-     * @param claimMultiplier - Multiplier to scale conditions (used for numeric comparisons).
-     * @returns true if the group evaluates to true, false otherwise.
-     */
-    function meetsDynamicConditions(dynamicObj, dynamicGroup, claimMultiplier = 1) {
-        const { conditions, links } = dynamicGroup;
-        if (!conditions || conditions.length === 0)
-            return true;
-        if (!dynamicObj)
-            return false;
-        // If no links, treat as AND between all conditions
-        if (!links || links.length === 0) {
-            return conditions.every((cond) => evaluateDynamicCondition(dynamicObj, cond, claimMultiplier));
-        }
-        // Evaluate the first condition
-        let result = evaluateDynamicCondition(dynamicObj, conditions[0], claimMultiplier);
-        for (let i = 0; i < links.length; i++) {
-            const nextCond = evaluateDynamicCondition(dynamicObj, conditions[i + 1], claimMultiplier);
-            const link = links[i];
-            if (link === 'AND') {
-                result = result && nextCond;
-            }
-            else if (link === 'OR') {
-                result = result || nextCond;
-            }
-            else if (link === 'AND NOT') {
-                result = result && !nextCond;
-            }
-        }
-        return result;
-    }
-    /**
-     * Checks if a PlayerOffer meets its claimable conditions (completed -> claimable transition).
-     * @param claimableConditions - The offer's claimableConditions (from IOffer)
-     * @param claimableTrackers - The player offer's claimableTrackers
-     */
-    function meetsClaimableConditions({ claimableConditions, playerOfferTrackers, claimableTrackers, }) {
-        if (!claimableConditions) {
-            return { isValid: true };
-        }
-        if (claimableConditions.siblingCompletions) {
-            const siblingCount = playerOfferTrackers?.siblingPlayerOffer_ids?.length ?? 0;
-            let completedCount = claimableTrackers?.siblingCompletions ?? 0;
-            if (completedCount == -1)
-                completedCount = siblingCount; // treat -1 as all completed
-            // if siblings exist but not all are completed, return false
-            if (siblingCount > 0 && completedCount < siblingCount) {
-                return { isValid: false };
-            }
-        }
-        return { isValid: true };
-    }
-    // returns contractAddress:network -> balance
-    function aggregateTokenBalances(data) {
-        const aggregatedBalances = {};
-        for (const { balances } of data?.cryptoWallets || []) {
-            for (const [key, balance] of Object.entries(balances)) {
-                if (!aggregatedBalances[key]) {
-                    aggregatedBalances[key] = 0;
-                }
-                aggregatedBalances[key] += balance;
-            }
-        }
-        return aggregatedBalances;
-    }
-
-    const offerListenerEvents = ['claim_offer'];
-    const PlayerOfferStatuses = [
-        // 'inQueue', // fuck this shit. just don't surface offers if their offer plate is full.
-        'surfaced',
-        'viewed',
-        'completed', // Individual completionConditions met, waiting for claimableConditions (e.g., siblings)
-        'claimable',
-        'claimed',
-        'expired',
-    ];
-
-    // Use a const assertion for the array and infer the union type directly
-    const rewardKinds = [
-        'item',
-        'coins',
-        'exp',
-        'trust_points',
-        'loyalty_currency', // loyalty currency that the player can exchange for rewards like on-chain via withdraw, etc.
-        'discount', // handled by the external dev, using the rewardId to identify what it is for in their system
-        /** on-chain rewards require the builder to send funds to a custodial wallet that we use to send to player wallets*/
-    ];
-    const rewardSchema = {
-        _id: false,
-        kind: { type: String, enum: rewardKinds },
-        rewardId: {
-            type: String,
-            validate: {
-                validator: function (value) {
-                    // Require rewardId for item, coins, loyalty_currency, exp, and discount kinds
-                    const requiresRewardId = ['item', 'coins', 'loyalty_currency', 'exp', 'discount'].includes(this.kind);
-                    if (requiresRewardId) {
-                        return !!value;
-                    }
-                    return true;
-                },
-                message: 'rewardId is required for reward kinds: item, coins, loyalty_currency, exp, and discount',
-            },
-        },
-        skillId: String,
-        currencyId: String, // could be a loyalty currency
-        itemId: String,
-        amount: Number,
-        name: String,
-        image: String,
-    };
-
-    exports.AssetHelper = AssetHelper;
-    exports.DEFAULT_ENTITY_KIND = DEFAULT_ENTITY_KIND;
     exports.EventEmitter = EventEmitter;
     exports.OfferStore = OfferStore;
     exports.OfferwallClient = OfferwallClient;
-    exports.PlayerOfferStatuses = PlayerOfferStatuses;
     exports.SSEConnection = SSEConnection;
-    exports.aggregateTokenBalances = aggregateTokenBalances;
-    exports.getMaxClaimsForDynamicCondition = getMaxClaimsForDynamicCondition;
-    exports.getMaxClaimsForDynamicGroup = getMaxClaimsForDynamicGroup;
-    exports.hasConditions = hasConditions;
-    exports.meetsBaseConditions = meetsBaseConditions;
-    exports.meetsClaimableConditions = meetsClaimableConditions;
-    exports.meetsCompletionConditions = meetsCompletionConditions;
-    exports.meetsCompletionConditionsBeforeExpiry = meetsCompletionConditionsBeforeExpiry;
-    exports.meetsDynamicConditions = meetsDynamicConditions;
-    exports.meetsLinkedEntityOffersCondition = meetsLinkedEntityOffersCondition;
-    exports.meetsSurfacingConditions = meetsSurfacingConditions;
-    exports.offerListenerEvents = offerListenerEvents;
-    exports.offerMeetsCompletionConditions = offerMeetsCompletionConditions;
-    exports.rewardKinds = rewardKinds;
-    exports.rewardSchema = rewardSchema;
 
 }));
 //# sourceMappingURL=offerwall-sdk.umd.js.map