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

package/dist/index.js

@@ -95,7 +95,7 @@ class EventEmitter {
     }
 }
 
-exports.OfferEvent = void 0;
+var OfferEvent;
 (function (OfferEvent) {
     OfferEvent["CONNECTED"] = "connected";
     OfferEvent["DISCONNECTED"] = "disconnected";
@@ -110,19 +110,19 @@ exports.OfferEvent = void 0;
     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
@@ -362,7 +362,7 @@ class SSEConnection {
         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);
@@ -381,7 +381,7 @@ class SSEConnection {
         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,
@@ -402,7 +402,7 @@ class SSEConnection {
                 return;
             }
             this.isConnecting = true;
-            this.setConnectionState(exports.ConnectionState.CONNECTING);
+            this.setConnectionState(ConnectionState.CONNECTING);
             this.logger.log('Connecting to SSE endpoint...');
             try {
                 // Create SSE URL
@@ -423,8 +423,8 @@ class SSEConnection {
                     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) => {
@@ -435,7 +435,7 @@ class SSEConnection {
                         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)) {
@@ -453,24 +453,24 @@ class SSEConnection {
                         ? '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);
@@ -547,7 +547,7 @@ class SSEConnection {
                   });
                   break;
                   */
-                case exports.OfferEvent.OFFER_SURFACED:
+                case OfferEvent.OFFER_SURFACED:
                     if (!parsed.instanceId)
                         throw new Error('OFFER_SURFACED message missing offer');
                     let surface = true;
@@ -556,7 +556,7 @@ class SSEConnection {
                     }
                     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,
                         });
                     }
@@ -567,7 +567,7 @@ class SSEConnection {
         }
         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',
             });
@@ -580,9 +580,9 @@ class SSEConnection {
         }
         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(),
             });
@@ -592,7 +592,7 @@ class SSEConnection {
         // 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;
@@ -611,8 +611,8 @@ class SSEConnection {
                 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(),
                 });
@@ -643,7 +643,12 @@ class OfferStore {
         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);
     }
     /**
@@ -651,13 +656,14 @@ class OfferStore {
      */
     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`);
     }
@@ -695,6 +701,17 @@ class OfferStore {
             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
      */
@@ -1055,8 +1072,8 @@ class OfferwallClient {
     /**
      * 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`);
         }
@@ -1071,10 +1088,10 @@ class OfferwallClient {
             }
         }
         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) {
@@ -1097,7 +1114,7 @@ class OfferwallClient {
      * Get current connection state
      */
     getConnectionState() {
-        return this.sseConnection?.getConnectionState() || exports.ConnectionState.DISCONNECTED;
+        return this.sseConnection?.getConnectionState() || ConnectionState.DISCONNECTED;
     }
     setupInternalListeners() {
         /*
@@ -1126,7 +1143,7 @@ class OfferwallClient {
           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}`);
         });
@@ -1174,11 +1191,11 @@ class OfferwallClient {
         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;
         }
@@ -1323,1542 +1340,8 @@ class OfferwallClient {
     }
 }
 
-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=index.js.map