@pixels-online/pixels-client-js-sdk 1.15.0 → 1.17.0

package/dist/offerwall-sdk.umd.js

@@ -896,6 +896,7 @@
     class OfferwallClient {
         constructor(config) {
             this.isInitializing = false;
+            this.pendingStackedToken = null;
             this.config = {
                 autoConnect: config.autoConnect ?? false,
                 reconnect: config.reconnect ?? true,
@@ -913,12 +914,24 @@
             this.assetHelper = new AssetHelper(this.config);
             this.sseConnection = new SSEConnection(this.config, this.eventEmitter, this.tokenManager);
             this.setupInternalListeners();
+            this.setupStackedLinkDetection();
             if (this.config.autoConnect) {
                 this.initialize().catch((err) => {
                     this.logger.error('Auto-initialization failed:', err);
                 });
             }
         }
+        setupStackedLinkDetection() {
+            if (!this.config.stackedLink?.autoConsume) {
+                return;
+            }
+            const token = this.detectStackedLinkToken();
+            if (token) {
+                this.logger.log('Detected stackedToken in URL');
+                this.pendingStackedToken = token;
+                this.clearStackedTokenFromUrl();
+            }
+        }
         /**
          * Get the offer store instance
          */
@@ -949,9 +962,19 @@
                 this.isInitializing = true;
                 await this.refreshOffersAndPlayer();
                 await this.connect();
+                // Process pending Stacked link token if exists and autoConsume is enabled
+                if (this.pendingStackedToken && this.config.stackedLink?.autoConsume) {
+                    this.logger.log('Processing pending Stacked link token');
+                    const result = await this.consumeStackedLinkToken(this.pendingStackedToken);
+                    this.pendingStackedToken = null;
+                    if (this.config.stackedLink?.onComplete) {
+                        this.config.stackedLink.onComplete(result);
+                    }
+                }
                 this.isInitializing = false;
             }
             catch (error) {
+                this.isInitializing = false;
                 this.handleError(error, 'initialize');
                 throw error;
             }
@@ -1167,6 +1190,91 @@
                 return null;
             return `${dashboardBaseUrl}/auth/enter?token=${token}&gameId=${gameId}`;
         }
+        // ==================== Stacked Link Methods ====================
+        /**
+         * Detect if there's a Stacked link token in the current URL
+         * @returns The token string if found, null otherwise
+         */
+        detectStackedLinkToken() {
+            if (typeof window === 'undefined')
+                return null;
+            try {
+                const params = new URLSearchParams(window.location.search);
+                const token = params.get('stackedToken');
+                if (token && token.length > 0) {
+                    return token;
+                }
+                // for SPA routers that use hash routing
+                if (window.location.hash) {
+                    const hashQuery = window.location.hash.split('?')[1];
+                    if (hashQuery) {
+                        const hashParams = new URLSearchParams(hashQuery);
+                        const hashToken = hashParams.get('stackedToken');
+                        if (hashToken && hashToken.length > 0) {
+                            return hashToken;
+                        }
+                    }
+                }
+                return null;
+            }
+            catch (error) {
+                this.logger.error('Error detecting stacked token:', error);
+                return null;
+            }
+        }
+        /**
+         * Clear the stackedToken from the URL without page reload
+         */
+        clearStackedTokenFromUrl() {
+            if (typeof window === 'undefined')
+                return;
+            try {
+                const url = new URL(window.location.href);
+                url.searchParams.delete('stackedToken');
+                window.history.replaceState({}, '', url.toString());
+                this.logger.log('Cleared stackedToken from URL');
+            }
+            catch (error) {
+                this.logger.error('Error clearing stacked token from URL:', error);
+            }
+        }
+        /**
+         * Consume a Stacked link token to link the current game player
+         * to a Stacked unified user account.
+         *
+         * IMPORTANT: The player must be authenticated (have a valid JWT from tokenProvider)
+         * before calling this method.
+         *
+         * @param token The Stacked link token from the URL
+         * @returns Promise resolving to the link result
+         */
+        async consumeStackedLinkToken(token) {
+            try {
+                const data = await this.postWithAuth('/v1/auth/stacked_link/exchange', { stackedToken: token });
+                return {
+                    linked: data.linked,
+                    alreadyLinked: data.alreadyLinked,
+                };
+            }
+            catch (error) {
+                this.logger.error('Error consuming stacked link token:', error);
+                return {
+                    linked: false,
+                };
+            }
+        }
+        /**
+         * Detects the token from URL, consumes it if player is authenticated.
+         * @returns Promise resolving to the link result, or null if no token found
+         */
+        async processStackedLinkToken() {
+            const token = this.detectStackedLinkToken();
+            if (!token) {
+                return null;
+            }
+            this.clearStackedTokenFromUrl();
+            return this.consumeStackedLinkToken(token);
+        }
         handleError(error, context) {
             this.logger.error(`Error in ${context}:`, error);
             if (this.hooks.onError) {
@@ -1176,19 +1284,47 @@
     }
 
     const keyPattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
-    // renders template by replacing {keyName} with values from dynamic
+    /**
+     * 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) => {
+        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 meetsBaseConditions = ({ conditions, playerSnap, addDetails, }) => {
+    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, }) => {
         const conditionData = [];
         let isValid = true;
         if (conditions?.minDaysInGame) {
@@ -1514,7 +1650,7 @@
             }
         }
         // Validate link count conditions
-        if (conditions?.links) {
+        if (conditions?.links && 'entityLinks' in playerSnap) {
             for (const [linkType, constraint] of Object.entries(conditions.links)) {
                 const linkCount = playerSnap.entityLinks?.filter((link) => link.kind === linkType).length || 0;
                 if (constraint.min !== undefined) {
@@ -1555,7 +1691,11 @@
         }
         // Evaluate dynamic conditions
         if (conditions?.dynamic?.conditions?.length) {
-            const dynamicResult = meetsDynamicConditions(playerSnap.dynamic || {}, conditions.dynamic);
+            const resolvedConditions = replaceDynamicConditionKeys(conditions.dynamic.conditions, playerOffer?.trackers || {});
+            const dynamicResult = meetsDynamicConditions(playerSnap.dynamic, {
+                ...conditions.dynamic,
+                conditions: resolvedConditions,
+            });
             if (addDetails) {
                 conditionData.push({
                     isMet: dynamicResult,
@@ -1571,7 +1711,7 @@
                     return { isValid: false };
             }
         }
-        if (conditions?.identifiers?.platforms?.length) {
+        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;
@@ -1608,7 +1748,7 @@
             return { isValid: false };
         }
         if (surfacingConditions?.targetEntityTypes?.length) {
-            const playerTarget = playerSnap.target || 'default';
+            const playerTarget = playerSnap.entityKind || 'default';
             // check if entity type is allowed
             if (!surfacingConditions.targetEntityTypes.includes(playerTarget)) {
                 return { isValid: false };
@@ -1664,6 +1804,31 @@
                 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 });
     };
     const hasConditions = (conditions) => {
@@ -1716,6 +1881,12 @@
             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;
         const compCond = conditions;
         if (compCond.context)
             return true;
@@ -1733,11 +1904,25 @@
             return true;
         if (compCond.linkedCompletions)
             return true;
+        if (compCond.dynamicTracker?.conditions?.length)
+            return true;
         return false;
     };
-    const meetsCompletionConditions = ({ completionConditions, completionTrackers, playerSnap, addDetails = false, }) => {
+    const offerMeetsCompletionConditions = (offer, snapshot) => {
+        return meetsCompletionConditions({
+            completionConditions: offer.completionConditions || {},
+            completionTrackers: offer.completionTrackers,
+            playerSnap: snapshot,
+            playerOffer: offer,
+            addDetails: true,
+        });
+    };
+    const meetsCompletionConditions = ({ completionConditions, completionTrackers, playerSnap, playerOffer, addDetails = false, maxClaimCount, }) => {
         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.claimedCount || 0) + 1 : 1;
             const conditionData = [];
             let isValid = true;
             if (completionConditions?.context?.id) {
@@ -1760,13 +1945,14 @@
                 }
             }
             if (conditions?.buyItem) {
-                const isDisqualify = (completionTrackers?.buyItem || 0) < (conditions.buyItem.amount || 1);
+                const scaledAmount = (conditions.buyItem.amount || 1) * claimMultiplier;
+                const isDisqualify = (completionTrackers?.buyItem || 0) < scaledAmount;
                 if (addDetails) {
                     conditionData.push({
                         isMet: !isDisqualify,
                         kind: 'buyItem',
                         trackerAmount: completionTrackers?.buyItem || 0,
-                        text: `Buy ${conditions.buyItem.amount || 1} ${conditions.buyItem.name}`,
+                        text: `Buy ${scaledAmount} ${conditions.buyItem.name}`,
                     });
                     if (isDisqualify)
                         isValid = false;
@@ -1777,13 +1963,14 @@
                 }
             }
             if (conditions?.spendCurrency) {
-                const isDisqualify = (completionTrackers?.spendCurrency || 0) < (conditions.spendCurrency.amount || 1);
+                const scaledAmount = (conditions.spendCurrency.amount || 1) * claimMultiplier;
+                const isDisqualify = (completionTrackers?.spendCurrency || 0) < scaledAmount;
                 if (addDetails) {
                     conditionData.push({
                         isMet: !isDisqualify,
                         kind: 'spendCurrency',
                         trackerAmount: completionTrackers?.spendCurrency || 0,
-                        text: `Spend ${conditions.spendCurrency.amount || 1} ${conditions.spendCurrency.name}`,
+                        text: `Spend ${scaledAmount} ${conditions.spendCurrency.name}`,
                     });
                     if (isDisqualify)
                         isValid = false;
@@ -1794,15 +1981,17 @@
                 }
             }
             if (conditions?.depositCurrency) {
-                const isDisqualify = (completionTrackers?.depositCurrency || 0) <
-                    (conditions.depositCurrency.amount || 1);
+                const scaledAmount = (conditions.depositCurrency.amount || 1) * claimMultiplier;
+                const isDisqualify = (completionTrackers?.depositCurrency || 0) < scaledAmount;
                 if (addDetails) {
                     conditionData.push({
                         isMet: !isDisqualify,
                         kind: 'depositCurrency',
                         trackerAmount: completionTrackers?.depositCurrency || 0,
-                        text: `Deposit ${conditions.depositCurrency.amount || 1} ${conditions.depositCurrency.name}`,
+                        text: `Deposit ${scaledAmount} ${conditions.depositCurrency.name}`,
                     });
+                    if (isDisqualify)
+                        isValid = false;
                 }
                 else {
                     if (isDisqualify)
@@ -1810,12 +1999,13 @@
                 }
             }
             if (conditions?.login) {
-                const isMet = completionTrackers?.login || false;
+                const isMet = new Date(playerSnap.snapshotLastUpdated || 0).getTime() >
+                    new Date(playerOffer.createdAt || 0).getTime();
                 if (addDetails) {
                     conditionData.push({
                         isMet,
                         kind: 'login',
-                        trackerAmount: completionTrackers?.login ? 1 : 0,
+                        trackerAmount: isMet ? 1 : 0,
                         text: `Login to the game`,
                     });
                     isValid = isMet;
@@ -1852,9 +2042,11 @@
                 const hasContent = Boolean(mode === 'accumulate'
                     ? tSocial?.mode === 'accumulate'
                     : tSocial && tSocial.mode !== 'accumulate' && !!tSocial.videoId);
-                const minLikes = cSocial?.minLikes || 0;
-                const minViews = cSocial?.minViews || 0;
-                const minComments = cSocial?.minComments || 0;
+                // 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;
@@ -1939,14 +2131,14 @@
             // Linked completions - wait for N linked entities to complete
             if (conditions?.linkedCompletions?.min) {
                 const currentCount = completionTrackers?.linkedCompletions || 0;
-                const requiredCount = conditions.linkedCompletions.min;
-                const isDisqualify = currentCount < requiredCount;
+                const scaledMin = conditions.linkedCompletions.min * claimMultiplier;
+                const isDisqualify = currentCount < scaledMin;
                 if (addDetails) {
                     conditionData.push({
                         isMet: !isDisqualify,
                         kind: 'linkedCompletions',
                         trackerAmount: currentCount,
-                        text: `Wait for ${requiredCount} linked ${requiredCount === 1 ? 'entity' : 'entities'} to complete`,
+                        text: `Wait for ${scaledMin} linked ${scaledMin === 1 ? 'entity' : 'entities'} to complete`,
                     });
                     if (isDisqualify)
                         isValid = false;
@@ -1956,10 +2148,32 @@
                         return { isValid: false };
                 }
             }
+            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(completionTrackers?.dynamicTracker, {
+                    ...conditions.dynamicTracker,
+                    conditions: resolvedConditions,
+                }, claimMultiplier);
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: dynamicResult,
+                        kind: 'dynamic',
+                        text: renderTemplate(conditions.dynamicTracker.template, completionTrackers?.dynamicTracker) || 'Dynamic conditions',
+                    });
+                    if (!dynamicResult)
+                        isValid = false;
+                }
+                else {
+                    if (!dynamicResult)
+                        return { isValid: false };
+                }
+            }
             const r = meetsBaseConditions({
                 conditions,
                 playerSnap,
                 addDetails: true,
+                playerOffer,
             });
             isValid = isValid && r.isValid;
             conditionData.push(...(r.conditionData || []));
@@ -1974,10 +2188,9 @@
      * @param completionConditions - The completion conditions to check
      * @param completionTrackers - The completion trackers (for buyItem, spendCurrency, etc.)
      * @param playerSnap - The player snapshot with field timestamps
-     * @param expiryTime - The expiry timestamp in milliseconds
      * @returns true if all conditions were met before expiry, false otherwise
      */
-    const meetsCompletionConditionsBeforeExpiry = ({ completionConditions, completionTrackers, playerSnap, expiryTime, }) => {
+    const meetsCompletionConditionsBeforeExpiry = ({ completionConditions, completionTrackers, playerSnap, playerOffer, maxClaimCount, }) => {
         if (!completionConditions)
             return false;
         // Check if there are actually any conditions to evaluate
@@ -1987,10 +2200,15 @@
         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.
@@ -2101,66 +2319,80 @@
      * 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) {
+    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);
         switch (cond.operator) {
             case '==':
-                return val === cond.compareTo;
+                return val === compareTo;
             case '!=':
-                return val !== cond.compareTo;
-            case '>':
-                return (typeof val === 'number' &&
-                    typeof cond.compareTo === 'number' &&
-                    val > cond.compareTo);
-            case '>=':
-                return (typeof val === 'number' &&
-                    typeof cond.compareTo === 'number' &&
-                    val >= cond.compareTo);
-            case '<':
-                return (typeof val === 'number' &&
-                    typeof cond.compareTo === 'number' &&
-                    val < cond.compareTo);
-            case '<=':
-                return (typeof val === 'number' &&
-                    typeof cond.compareTo === 'number' &&
-                    val <= cond.compareTo);
-            case 'has':
-                return (typeof val === 'string' &&
-                    typeof cond.compareTo === 'string' &&
-                    val.includes(cond.compareTo));
-            case 'not_has':
-                return (typeof val === 'string' &&
-                    typeof cond.compareTo === 'string' &&
-                    !val.includes(cond.compareTo));
-            default:
-                return false;
+                return val !== compareTo;
+        }
+        if (isNumber && typeof compareTo === 'number') {
+            switch (cond.operator) {
+                case '>':
+                    return val > compareTo * claimMultiplier;
+                case '>=':
+                    return val >= compareTo * claimMultiplier;
+                case '<':
+                    return val < compareTo * claimMultiplier;
+                case '<=':
+                    return val <= compareTo * claimMultiplier;
+            }
         }
+        else if (!isNumber && typeof compareTo === 'string') {
+            switch (cond.operator) {
+                case 'has':
+                    return val.includes(compareTo);
+                case 'not_has':
+                    return !val.includes(compareTo);
+            }
+        }
+        return false;
     }
     /**
      * 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) {
+    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));
+            return conditions.every((cond) => evaluateDynamicCondition(dynamicObj, cond, claimMultiplier));
         }
         // Evaluate the first condition
-        let result = evaluateDynamicCondition(dynamicObj, conditions[0]);
+        let result = evaluateDynamicCondition(dynamicObj, conditions[0], claimMultiplier);
         for (let i = 0; i < links.length; i++) {
-            const nextCond = evaluateDynamicCondition(dynamicObj, conditions[i + 1]);
+            const nextCond = evaluateDynamicCondition(dynamicObj, conditions[i + 1], claimMultiplier);
             const link = links[i];
             if (link === 'AND') {
                 result = result && nextCond;
@@ -2174,12 +2406,34 @@
         }
         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 };
+    }
 
     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',
@@ -2228,11 +2482,13 @@
     exports.SSEConnection = SSEConnection;
     exports.hasConditions = hasConditions;
     exports.meetsBaseConditions = meetsBaseConditions;
+    exports.meetsClaimableConditions = meetsClaimableConditions;
     exports.meetsCompletionConditions = meetsCompletionConditions;
     exports.meetsCompletionConditionsBeforeExpiry = meetsCompletionConditionsBeforeExpiry;
     exports.meetsDynamicConditions = meetsDynamicConditions;
     exports.meetsSurfacingConditions = meetsSurfacingConditions;
     exports.offerListenerEvents = offerListenerEvents;
+    exports.offerMeetsCompletionConditions = offerMeetsCompletionConditions;
     exports.rewardKinds = rewardKinds;
     exports.rewardSchema = rewardSchema;