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

package/dist/core/OfferwallClient.d.ts

@@ -5,6 +5,7 @@ import { OfferwallConfig } from '../types/index';
 import { IClientOffer } from '../types/offer';
 import { ConnectionState } from '../types/connection';
 import { IClientPlayer } from '../types/player';
+import { StackedLinkResult } from '../types/linking';
 export declare const mapEnvToOfferClientUrl: (env: "test" | "live" | (string & {})) => "https://offers.pixels.xyz" | "https://offers.sandbox.pixels.xyz" | "https://offers.staging.pixels.xyz" | "https://offers.preview.pixels.xyz" | "https://offers.dev.pixels.xyz";
 export declare class OfferwallClient {
     private config;
@@ -17,7 +18,9 @@ export declare class OfferwallClient {
     private hooks;
     private logger;
     private isInitializing;
+    private pendingStackedToken;
     constructor(config: OfferwallConfig);
+    private setupStackedLinkDetection;
     /**
      * Get the offer store instance
      */
@@ -67,5 +70,30 @@ export declare class OfferwallClient {
     getAuthLinkToken(): Promise<string>;
     getGameId(): string | null;
     getDashboardRedirectUrl(): Promise<string | null>;
+    /**
+     * Detect if there's a Stacked link token in the current URL
+     * @returns The token string if found, null otherwise
+     */
+    detectStackedLinkToken(): string | null;
+    /**
+     * Clear the stackedToken from the URL without page reload
+     */
+    private clearStackedTokenFromUrl;
+    /**
+     * 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
+     */
+    consumeStackedLinkToken(token: string): Promise<StackedLinkResult>;
+    /**
+     * Detects the token from URL, consumes it if player is authenticated.
+     * @returns Promise resolving to the link result, or null if no token found
+     */
+    processStackedLinkToken(): Promise<StackedLinkResult | null>;
     private handleError;
 }

package/dist/index.d.ts

@@ -10,3 +10,4 @@ export * from './types/reward';
 export * from './types/events';
 export * from './types/hooks';
 export * from './types/player';
+export * from './types/linking';

package/dist/index.esm.js

@@ -890,6 +890,7 @@ const mapEnvToOfferClientUrl = (env) => {
 class OfferwallClient {
     constructor(config) {
         this.isInitializing = false;
+        this.pendingStackedToken = null;
         this.config = {
             autoConnect: config.autoConnect ?? false,
             reconnect: config.reconnect ?? true,
@@ -907,12 +908,24 @@ class OfferwallClient {
         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
      */
@@ -943,9 +956,19 @@ class OfferwallClient {
             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;
         }
@@ -1161,6 +1184,91 @@ class OfferwallClient {
             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) {
@@ -1170,19 +1278,47 @@ class OfferwallClient {
 }
 
 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) {
@@ -1508,7 +1644,7 @@ const meetsBaseConditions = ({ conditions, playerSnap, addDetails, }) => {
         }
     }
     // 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) {
@@ -1549,7 +1685,11 @@ const meetsBaseConditions = ({ conditions, playerSnap, addDetails, }) => {
     }
     // 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,
@@ -1565,7 +1705,7 @@ const meetsBaseConditions = ({ conditions, playerSnap, addDetails, }) => {
                 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;
@@ -1602,7 +1742,7 @@ const meetsSurfacingConditions = ({ surfacingConditions, playerSnap, context, pl
         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 };
@@ -1658,6 +1798,31 @@ const meetsSurfacingConditions = ({ surfacingConditions, playerSnap, context, pl
             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) => {
@@ -1710,6 +1875,12 @@ const hasConditions = (conditions) => {
         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;
@@ -1727,11 +1898,25 @@ const hasConditions = (conditions) => {
         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) {
@@ -1754,13 +1939,14 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
         }
         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;
@@ -1771,13 +1957,14 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
         }
         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;
@@ -1788,15 +1975,17 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
         }
         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)
@@ -1804,12 +1993,13 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
         }
         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;
@@ -1846,9 +2036,11 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             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;
@@ -1933,14 +2125,14 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
         // 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;
@@ -1950,10 +2142,32 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
                     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 || []));
@@ -1968,10 +2182,9 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
  * @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
@@ -1981,10 +2194,15 @@ const meetsCompletionConditionsBeforeExpiry = ({ completionConditions, completio
     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.
@@ -2095,66 +2313,80 @@ const meetsCompletionConditionsBeforeExpiry = ({ completionConditions, completio
  * 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;
@@ -2168,12 +2400,34 @@ function meetsDynamicConditions(dynamicObj, dynamicGroup) {
     }
     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',
@@ -2214,5 +2468,5 @@ const rewardSchema = {
     image: String,
 };
 
-export { AssetHelper, ConnectionState, EventEmitter, OfferEvent, OfferStore, OfferwallClient, PlayerOfferStatuses, SSEConnection, hasConditions, meetsBaseConditions, meetsCompletionConditions, meetsCompletionConditionsBeforeExpiry, meetsDynamicConditions, meetsSurfacingConditions, offerListenerEvents, rewardKinds, rewardSchema };
+export { AssetHelper, ConnectionState, EventEmitter, OfferEvent, OfferStore, OfferwallClient, PlayerOfferStatuses, SSEConnection, hasConditions, meetsBaseConditions, meetsClaimableConditions, meetsCompletionConditions, meetsCompletionConditionsBeforeExpiry, meetsDynamicConditions, meetsSurfacingConditions, offerListenerEvents, offerMeetsCompletionConditions, rewardKinds, rewardSchema };
 //# sourceMappingURL=index.esm.js.map