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

package/dist/index.esm.js

@@ -628,25 +628,33 @@ class SSEConnection {
 }
 
 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`);
     }
@@ -654,16 +662,23 @@ class OfferStore {
      * 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);
         }
@@ -672,26 +687,30 @@ class OfferStore {
     /**
      * 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' ||
@@ -702,14 +721,14 @@ class OfferStore {
     /**
      * 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
@@ -722,17 +741,29 @@ class OfferStore {
         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;
     }
 }
 
@@ -835,7 +866,9 @@ class AssetHelper {
         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) {
@@ -891,6 +924,7 @@ class OfferwallClient {
     constructor(config) {
         this.isInitializing = false;
         this.pendingStackedToken = null;
+        this.selfId = null;
         this.config = {
             autoConnect: config.autoConnect ?? false,
             reconnect: config.reconnect ?? true,
@@ -903,7 +937,7 @@ class OfferwallClient {
         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);
@@ -944,6 +978,9 @@ class OfferwallClient {
     get assets() {
         return this.assetHelper;
     }
+    getSelfId() {
+        return this.selfId;
+    }
     /**
      * Initialize the offerwall client and connect
      */
@@ -1006,8 +1043,9 @@ class OfferwallClient {
         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();
         }
@@ -1015,8 +1053,8 @@ class OfferwallClient {
     /**
      * 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`);
         }
@@ -1031,7 +1069,7 @@ class OfferwallClient {
             }
         }
         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(OfferEvent.OFFER_CLAIMED, {
@@ -1087,7 +1125,7 @@ class OfferwallClient {
         });
         */
         this.eventEmitter.on(OfferEvent.OFFER_SURFACED, ({ offer }) => {
-            this.offerStore.upsertOffer(offer);
+            this.offerStore.upsertOffer(offer); // should always be selfId
             this.logger.log(`Surfaced offer: ${offer.instanceId}`);
         });
     }
@@ -1117,34 +1155,40 @@ class OfferwallClient {
         }
         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(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');
@@ -1277,6 +1321,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.
@@ -1314,11 +1360,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) {
@@ -1646,7 +1706,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) {
@@ -1733,16 +1794,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 };
@@ -1823,7 +1928,7 @@ const meetsSurfacingConditions = ({ surfacingConditions, playerSnap, context, pl
             }
         }
     }
-    return meetsBaseConditions({ conditions, playerSnap });
+    return meetsBaseConditions({ conditions, playerSnap, additionalData });
 };
 const hasConditions = (conditions) => {
     if (!conditions)
@@ -1881,6 +1986,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;
@@ -1900,23 +2007,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;
@@ -2047,12 +2178,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;
@@ -2087,7 +2220,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',
@@ -2100,7 +2233,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',
@@ -2177,22 +2310,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;
@@ -2202,19 +2335,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
@@ -2565,6 +2743,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 = [
@@ -2612,5 +2803,5 @@ const rewardSchema = {
     image: String,
 };
 
-export { AssetHelper, ConnectionState, EventEmitter, OfferEvent, OfferStore, OfferwallClient, PlayerOfferStatuses, SSEConnection, getMaxClaimsForDynamicCondition, getMaxClaimsForDynamicGroup, hasConditions, meetsBaseConditions, meetsClaimableConditions, meetsCompletionConditions, meetsCompletionConditionsBeforeExpiry, meetsDynamicConditions, meetsSurfacingConditions, offerListenerEvents, offerMeetsCompletionConditions, rewardKinds, rewardSchema };
+export { AssetHelper, ConnectionState, DEFAULT_ENTITY_KIND, EventEmitter, OfferEvent, OfferStore, OfferwallClient, PlayerOfferStatuses, SSEConnection, aggregateTokenBalances, getMaxClaimsForDynamicCondition, getMaxClaimsForDynamicGroup, hasConditions, meetsBaseConditions, meetsClaimableConditions, meetsCompletionConditions, meetsCompletionConditionsBeforeExpiry, meetsDynamicConditions, meetsLinkedEntityOffersCondition, meetsSurfacingConditions, offerListenerEvents, offerMeetsCompletionConditions, rewardKinds, rewardSchema };
 //# sourceMappingURL=index.esm.js.map