@pixels-online/pixels-client-js-sdk 1.19.0 → 1.20.0

package/dist/offerwall-sdk.umd.js

@@ -646,7 +646,7 @@
             return this.players.get(targetId) || null;
         }
         setPlayer(player) {
-            this.players.set(player.snapshot.playerId, player);
+            this.players.set(player.gameData.playerId, player);
             this.logger.log('Updated player:', player);
         }
         /**
@@ -658,9 +658,9 @@
                 this.logger.warn('No target player to set offers for');
                 return;
             }
-            this.offers.set(targetPlayer.snapshot.playerId, new Map());
+            this.offers.set(targetPlayer.gameData.playerId, new Map());
             offers.forEach((offer) => {
-                this.offers.get(targetPlayer.snapshot.playerId).set(offer.instanceId, offer);
+                this.offers.get(targetPlayer.gameData.playerId).set(offer.instanceId, offer);
             });
             this.logger.log(`Set ${offers.length} offers`);
         }
@@ -1178,12 +1178,13 @@
             try {
                 const { offers, player } = await this.getOffersAndPlayer(targetId);
                 if (targetId == null) {
-                    this.selfId = player.snapshot.playerId;
+                    this.selfId = player.gameData.playerId;
                 }
                 this.offerStore.setPlayer(player);
                 this.offerStore.setOffers(offers, player);
                 this.eventEmitter.emit(exports.OfferEvent.REFRESH, { offers, player: player });
                 this.logger.log('Refreshed offers and player snapshot');
+                return offers;
             }
             catch (error) {
                 this.handleError(error, 'refreshOffersAndPlayer');
@@ -1326,6 +1327,8 @@
         }
     }
 
+    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.
@@ -1363,11 +1366,25 @@
         }));
     }
 
+    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, }) => {
+    playerOffer, 
+    /** Additional data like fetched token balances that isn't part of playerSnap */
+    additionalData, }) => {
         const conditionData = [];
         let isValid = true;
         if (conditions?.minDaysInGame) {
@@ -1695,7 +1712,8 @@
         // Validate link count conditions
         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;
+                // 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) {
@@ -1782,16 +1800,60 @@
                     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,
+                        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, }) => {
+    const meetsSurfacingConditions = ({ surfacingConditions, playerSnap, context, playerOffers, 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';
+            const playerTarget = playerSnap.entityKind || DEFAULT_ENTITY_KIND;
             // check if entity type is allowed
             if (!surfacingConditions.targetEntityTypes.includes(playerTarget)) {
                 return { isValid: false };
@@ -1872,7 +1934,7 @@
                 }
             }
         }
-        return meetsBaseConditions({ conditions, playerSnap });
+        return meetsBaseConditions({ conditions, playerSnap, additionalData });
     };
     const hasConditions = (conditions) => {
         if (!conditions)
@@ -1930,6 +1992,8 @@
             return true;
         if (surCond.networkRestrictions?.length)
             return true;
+        if (surCond.linkedEntityOffers?.offer_id)
+            return true;
         const compCond = conditions;
         if (compCond.context)
             return true;
@@ -1949,23 +2013,47 @@
             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 offerMeetsCompletionConditions = (offer, snapshot) => {
+    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, }) => {
+    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.claimedCount || 0) + 1 : 1;
+            const claimMultiplier = shouldScale
+                ? (playerOffer.trackers?.claimedCount || 0) + 1
+                : 1;
             const conditionData = [];
             let isValid = true;
             let maxTotalClaimsFromScaling = Infinity;
@@ -2096,12 +2184,14 @@
                 }
             }
             if (conditions?.social) {
-                const tSocial = completionTrackers?.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'
-                    ? tSocial?.mode === 'accumulate'
-                    : tSocial && tSocial.mode !== 'accumulate' && !!tSocial.videoId);
+                    ? 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;
@@ -2136,7 +2226,7 @@
                         .join(' | ');
                     const requiredWords = cSocial?.requiredWords ?? [];
                     if (mode === 'accumulate') {
-                        const matchCount = (tSocial?.mode === 'accumulate' && tSocial.matchCount) || 0;
+                        const matchCount = tSocialAccumulate?.matchCount || 0;
                         conditionData.push({
                             isMet: hasContent,
                             kind: 'social',
@@ -2149,7 +2239,7 @@
                         });
                     }
                     else {
-                        const title = (tSocial && tSocial.mode !== 'accumulate' && tSocial.title) || undefined;
+                        const title = tSocialAttach?.title;
                         conditionData.push({
                             isMet: hasContent,
                             kind: 'social',
@@ -2226,22 +2316,22 @@
             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, {
+                const dynamicResult = meetsDynamicConditions(dynamicTrackerToPrimitive(completionTrackers?.dynamicTracker || {}), {
                     ...conditions.dynamicTracker,
                     conditions: resolvedConditions,
                 }, claimMultiplier);
                 if (shouldScale) {
-                    const dynamicMax = getMaxClaimsForDynamicGroup(completionTrackers?.dynamicTracker || {}, {
+                    const dynamicMax = getMaxClaimsForDynamicGroup(dynamicTrackerToPrimitive(completionTrackers?.dynamicTracker || {}), {
                         ...conditions.dynamicTracker,
                         conditions: resolvedConditions,
-                    }, playerOffer.claimedCount || 0);
+                    }, playerOffer?.trackers?.claimedCount || 0);
                     updateMax(dynamicMax);
                 }
                 if (addDetails) {
                     conditionData.push({
                         isMet: dynamicResult,
-                        kind: 'dynamic',
-                        text: renderTemplate(conditions.dynamicTracker.template, completionTrackers?.dynamicTracker) || 'Dynamic conditions',
+                        kind: 'dynamicTracker',
+                        text: renderTemplate(conditions.dynamicTracker.template, dynamicTrackerToPrimitive(completionTrackers?.dynamicTracker || {})) || 'Dynamic conditions',
                     });
                     if (!dynamicResult)
                         isValid = false;
@@ -2251,19 +2341,64 @@
                         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) {
+                        let displayText;
+                        const eventType = condition.event;
+                        const name = condition.name || 'tokens';
+                        if (eventType === 'spend') {
+                            displayText = `Spend ${scaledAmount} ${name}`;
+                        }
+                        else if (eventType === 'earn') {
+                            displayText = `Earn ${scaledAmount} ${name}`;
+                        }
+                        else if (eventType === 'gain') {
+                            displayText = `Gain ${scaledAmount} ${name}`;
+                        }
+                        else if (eventType === 'lose') {
+                            displayText = `Lose ${scaledAmount} ${name}`;
+                        }
+                        else {
+                            displayText = `${name}: ${scaledAmount}`;
+                        }
+                        conditionData.push({
+                            isMet: !isDisqualify,
+                            kind: 'contractInteractions',
+                            trackerAmount: trackerValue,
+                            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.claimedCount || 0;
-            let availableClaimsNow = !isValid
+            const claimedCount = playerOffer?.trackers?.claimedCount || 0;
+            const availableClaimsNow = !isValid
                 ? 0
                 : maxTotalClaimsFromScaling === Infinity
                     ? -1
@@ -2614,6 +2749,19 @@
         }
         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 = [
@@ -2662,11 +2810,13 @@
     };
 
     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;
@@ -2675,6 +2825,7 @@
     exports.meetsCompletionConditions = meetsCompletionConditions;
     exports.meetsCompletionConditionsBeforeExpiry = meetsCompletionConditionsBeforeExpiry;
     exports.meetsDynamicConditions = meetsDynamicConditions;
+    exports.meetsLinkedEntityOffersCondition = meetsLinkedEntityOffersCondition;
     exports.meetsSurfacingConditions = meetsSurfacingConditions;
     exports.offerListenerEvents = offerListenerEvents;
     exports.offerMeetsCompletionConditions = offerMeetsCompletionConditions;