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

package/dist/offerwall-sdk.umd.js

@@ -634,25 +634,33 @@
     }
 
     class OfferStore {
-        constructor(config) {
+        constructor(config, client) {
+            this.client = client;
             this.offers = new Map();
-            this.player = null;
+            this.players = new Map();
             this.logger = createLogger(config, 'OfferStore');
         }
-        getPlayer() {
-            return this.player || null;
+        getPlayer(targetId = this.client.getSelfId()) {
+            if (!targetId)
+                return null;
+            return this.players.get(targetId) || null;
         }
         setPlayer(player) {
-            this.player = player;
+            this.players.set(player.gameData.playerId, player);
             this.logger.log('Updated player:', player);
         }
         /**
          * Set all offers (replaces existing)
          */
-        setOffers(offers) {
-            this.offers.clear();
+        setOffers(offers, target) {
+            const targetPlayer = target || this.getPlayer();
+            if (!targetPlayer) {
+                this.logger.warn('No target player to set offers for');
+                return;
+            }
+            this.offers.set(targetPlayer.gameData.playerId, new Map());
             offers.forEach((offer) => {
-                this.offers.set(offer.instanceId, offer);
+                this.offers.get(targetPlayer.gameData.playerId).set(offer.instanceId, offer);
             });
             this.logger.log(`Set ${offers.length} offers`);
         }
@@ -660,16 +668,23 @@
          * Add or update a single offer
          */
         upsertOffer(offer) {
-            const previousOffer = this.offers.get(offer.instanceId);
-            this.offers.set(offer.instanceId, offer);
+            let playerOffers = this.offers.get(offer.playerId);
+            if (!playerOffers) {
+                playerOffers = new Map();
+                this.offers.set(offer.playerId, playerOffers);
+            }
+            const previousOffer = playerOffers.get(offer.instanceId);
+            playerOffers.set(offer.instanceId, offer);
             this.logger.log(`${previousOffer ? 'Updated' : 'Added'} offer:`, offer.instanceId);
             return previousOffer;
         }
         /**
          * Remove an offer
          */
-        removeOffer(offerId) {
-            const removed = this.offers.delete(offerId);
+        removeOffer(offerId, targetId = this.client.getSelfId()) {
+            if (!targetId)
+                return false;
+            const removed = this.offers.get(targetId)?.delete(offerId) || false;
             if (removed) {
                 this.logger.log(`Removed offer:`, offerId);
             }
@@ -678,26 +693,30 @@
         /**
          * Get a single offer
          */
-        getOffer(offerId) {
-            return this.offers.get(offerId);
+        getOffer(offerId, targetId = this.client.getSelfId()) {
+            if (!targetId)
+                return undefined;
+            return this.offers.get(targetId)?.get(offerId);
         }
         /**
          * Get all offers
          */
-        getAllOffers() {
-            return Array.from(this.offers.values());
+        getAllOffers(targetId = this.client.getSelfId()) {
+            if (!targetId)
+                return [];
+            return Array.from(this.offers.get(targetId)?.values() || []);
         }
         /**
          * Get offers filtered by status
          */
-        getOffersByStatus(status) {
-            return this.getAllOffers().filter((offer) => offer.status === status);
+        getOffersByStatus(status, targetId = this.client.getSelfId()) {
+            return this.getAllOffers(targetId).filter((offer) => offer.status === status);
         }
         /**
          * Get active offers (not expired, not claimed)
          */
-        getActiveOffers() {
-            return this.getAllOffers().filter((offer) => {
+        getActiveOffers(targetId = this.client.getSelfId()) {
+            return this.getAllOffers(targetId).filter((offer) => {
                 if (!offer.status)
                     return false; // Must have a status
                 return (offer.status === 'surfaced' ||
@@ -708,14 +727,14 @@
         /**
          * Get claimable offers
          */
-        getClaimableOffers() {
-            return this.getOffersByStatus('claimable');
+        getClaimableOffers(targetId = this.client.getSelfId()) {
+            return this.getOffersByStatus('claimable', targetId);
         }
         /**
          * Check if an offer has expired
          */
-        isOfferExpired(offerId) {
-            const offer = this.getOffer(offerId);
+        isOfferExpired(offerId, targetId = this.client.getSelfId()) {
+            const offer = this.getOffer(offerId, targetId);
             if (!offer)
                 return true;
             // Check status
@@ -728,17 +747,29 @@
             return false;
         }
         /**
-         * Clear all offers
+         * Clear all offers for a specific player
+         */
+        clear(targetId = this.client.getSelfId()) {
+            if (!targetId)
+                return;
+            this.offers.set(targetId, new Map());
+            this.logger.log('Cleared all offers for player:', targetId);
+        }
+        /**
+         * Clear all offers for all players
          */
-        clear() {
+        clearAll() {
             this.offers.clear();
-            this.logger.log('Cleared all offers');
+            this.logger.log('Cleared all offers for all players');
         }
         /**
-         * Get offer count
+         * Get offer count (for self player)
          */
         get size() {
-            return this.offers.size;
+            const selfId = this.client.getSelfId();
+            if (!selfId)
+                return 0;
+            return this.offers.get(selfId)?.size || 0;
         }
     }
 
@@ -841,7 +872,9 @@
             return null;
         }
         setCurrencyAssetContents(currencies) {
-            this.currencies = currencies;
+            Object.keys(currencies).forEach((key) => {
+                this.currencies[key] = currencies[key];
+            });
         }
         resolveReward(reward) {
             if (reward.kind === 'loyalty_currency' && reward.rewardId) {
@@ -897,6 +930,7 @@
         constructor(config) {
             this.isInitializing = false;
             this.pendingStackedToken = null;
+            this.selfId = null;
             this.config = {
                 autoConnect: config.autoConnect ?? false,
                 reconnect: config.reconnect ?? true,
@@ -909,7 +943,7 @@
             this.hooks = this.config.hooks || {};
             this.logger = createLogger(this.config, 'OfferwallClient');
             this.eventEmitter = new EventEmitter(this.config);
-            this.offerStore = new OfferStore(this.config);
+            this.offerStore = new OfferStore(this.config, this);
             this.tokenManager = new TokenManager(this.config);
             this.assetHelper = new AssetHelper(this.config);
             this.sseConnection = new SSEConnection(this.config, this.eventEmitter, this.tokenManager);
@@ -950,6 +984,9 @@
         get assets() {
             return this.assetHelper;
         }
+        getSelfId() {
+            return this.selfId;
+        }
         /**
          * Initialize the offerwall client and connect
          */
@@ -1012,8 +1049,9 @@
             if (this.sseConnection) {
                 this.sseConnection.disconnect();
             }
-            this.offerStore.clear();
+            this.offerStore.clearAll();
             this.tokenManager.clearToken();
+            this.selfId = null;
             if (this.hooks.afterDisconnect) {
                 await this.hooks.afterDisconnect();
             }
@@ -1021,8 +1059,8 @@
         /**
          * Claim rewards for an offer
          */
-        async claimReward(instanceId) {
-            const offer = this.offerStore.getOffer(instanceId);
+        async claimReward(instanceId, targetId = this.getSelfId()) {
+            const offer = this.offerStore.getOffer(instanceId, targetId);
             if (!offer) {
                 throw new Error(`Offer ${instanceId} not found`);
             }
@@ -1037,7 +1075,7 @@
                 }
             }
             try {
-                const response = await this.claimOfferAPI(instanceId);
+                const response = await this.claimOfferAPI(instanceId, targetId);
                 const updatedOffer = { ...offer, status: 'claimed' };
                 this.offerStore.upsertOffer(updatedOffer);
                 this.eventEmitter.emit(exports.OfferEvent.OFFER_CLAIMED, {
@@ -1093,7 +1131,7 @@
             });
             */
             this.eventEmitter.on(exports.OfferEvent.OFFER_SURFACED, ({ offer }) => {
-                this.offerStore.upsertOffer(offer);
+                this.offerStore.upsertOffer(offer); // should always be selfId
                 this.logger.log(`Surfaced offer: ${offer.instanceId}`);
             });
         }
@@ -1123,34 +1161,40 @@
             }
             return response.json();
         }
-        async claimOfferAPI(instanceId) {
+        async claimOfferAPI(instanceId, targetId = null) {
             return this.postWithAuth('/v1/client/reward/claim', {
                 instanceId,
                 kind: 'offer',
+                targetId: targetId || undefined,
             });
         }
-        getPlayer() {
-            return this.offerStore.getPlayer();
+        getPlayer(targetId = this.getSelfId()) {
+            return this.offerStore.getPlayer(targetId);
         }
-        getOffers() {
-            return this.offerStore.getAllOffers();
+        getOffers(targetId = this.getSelfId()) {
+            return this.offerStore.getAllOffers(targetId);
         }
-        async refreshOffersAndPlayer() {
+        async refreshOffersAndPlayer(targetId = null) {
             try {
-                const { offers, player } = await this.getOffersAndPlayer();
-                this.offerStore.setOffers(offers);
+                const { offers, player } = await this.getOffersAndPlayer(targetId);
+                if (targetId == null) {
+                    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');
                 throw error;
             }
         }
-        async getOffersAndPlayer() {
+        async getOffersAndPlayer(targetId = null) {
             const data = await this.postWithAuth('/v1/client/player/campaigns', {
                 viewingCampaigns: true,
+                targetId: targetId || undefined,
             });
             if (!data.offers || !Array.isArray(data.offers)) {
                 throw new Error('No offers returned from offers endpoint');
@@ -1283,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.
@@ -1320,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) {
@@ -1652,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) {
@@ -1739,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 };
@@ -1829,7 +1934,7 @@
                 }
             }
         }
-        return meetsBaseConditions({ conditions, playerSnap });
+        return meetsBaseConditions({ conditions, playerSnap, additionalData });
     };
     const hasConditions = (conditions) => {
         if (!conditions)
@@ -1887,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;
@@ -1906,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;
@@ -2053,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;
@@ -2093,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',
@@ -2106,7 +2239,7 @@
                         });
                     }
                     else {
-                        const title = (tSocial && tSocial.mode !== 'accumulate' && tSocial.title) || undefined;
+                        const title = tSocialAttach?.title;
                         conditionData.push({
                             isMet: hasContent,
                             kind: 'social',
@@ -2183,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;
@@ -2208,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
@@ -2571,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 = [
@@ -2619,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;
@@ -2632,6 +2825,7 @@
     exports.meetsCompletionConditions = meetsCompletionConditions;
     exports.meetsCompletionConditionsBeforeExpiry = meetsCompletionConditionsBeforeExpiry;
     exports.meetsDynamicConditions = meetsDynamicConditions;
+    exports.meetsLinkedEntityOffersCondition = meetsLinkedEntityOffersCondition;
     exports.meetsSurfacingConditions = meetsSurfacingConditions;
     exports.offerListenerEvents = offerListenerEvents;
     exports.offerMeetsCompletionConditions = offerMeetsCompletionConditions;