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

package/dist/index.js

@@ -642,7 +642,7 @@ class OfferStore {
         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);
     }
     /**
@@ -654,9 +654,9 @@ class OfferStore {
             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`);
     }
@@ -1174,12 +1174,13 @@ class OfferwallClient {
         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');
@@ -1322,6 +1323,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.
@@ -1359,11 +1362,25 @@ function replaceDynamicConditionKeys(conditions, 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, }) => {
+playerOffer, 
+/** Additional data like fetched token balances that isn't part of playerSnap */
+additionalData, }) => {
     const conditionData = [];
     let isValid = true;
     if (conditions?.minDaysInGame) {
@@ -1691,7 +1708,8 @@ playerOffer, }) => {
     // 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) {
@@ -1778,16 +1796,60 @@ playerOffer, }) => {
                 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 };
@@ -1868,7 +1930,7 @@ const meetsSurfacingConditions = ({ surfacingConditions, playerSnap, context, pl
             }
         }
     }
-    return meetsBaseConditions({ conditions, playerSnap });
+    return meetsBaseConditions({ conditions, playerSnap, additionalData });
 };
 const hasConditions = (conditions) => {
     if (!conditions)
@@ -1926,6 +1988,8 @@ const hasConditions = (conditions) => {
         return true;
     if (surCond.networkRestrictions?.length)
         return true;
+    if (surCond.linkedEntityOffers?.offer_id)
+        return true;
     const compCond = conditions;
     if (compCond.context)
         return true;
@@ -1945,23 +2009,47 @@ const hasConditions = (conditions) => {
         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;
@@ -2092,12 +2180,14 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
             }
         }
         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;
@@ -2132,7 +2222,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
                     .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',
@@ -2145,7 +2235,7 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
                     });
                 }
                 else {
-                    const title = (tSocial && tSocial.mode !== 'accumulate' && tSocial.title) || undefined;
+                    const title = tSocialAttach?.title;
                     conditionData.push({
                         isMet: hasContent,
                         kind: 'social',
@@ -2222,22 +2312,22 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
         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;
@@ -2247,19 +2337,64 @@ const meetsCompletionConditions = ({ completionConditions, completionTrackers, p
                     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
@@ -2610,6 +2745,19 @@ function meetsClaimableConditions({ claimableConditions, playerOfferTrackers, cl
     }
     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 = [
@@ -2658,11 +2806,13 @@ const rewardSchema = {
 };
 
 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;
@@ -2671,6 +2821,7 @@ exports.meetsClaimableConditions = meetsClaimableConditions;
 exports.meetsCompletionConditions = meetsCompletionConditions;
 exports.meetsCompletionConditionsBeforeExpiry = meetsCompletionConditionsBeforeExpiry;
 exports.meetsDynamicConditions = meetsDynamicConditions;
+exports.meetsLinkedEntityOffersCondition = meetsLinkedEntityOffersCondition;
 exports.meetsSurfacingConditions = meetsSurfacingConditions;
 exports.offerListenerEvents = offerListenerEvents;
 exports.offerMeetsCompletionConditions = offerMeetsCompletionConditions;