@stackedapp/utils 0.26.1

package/dist/conditions.js

@@ -0,0 +1,1295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meetsCompletionConditionsBeforeExpiry = exports.meetsCompletionConditions = exports.offerMeetsCompletionConditions = exports.meetsLinkedEntityOffersCondition = exports.hasCompletionConditions = exports.meetsBaseConditions = exports.DEFAULT_ENTITY_KIND = void 0;
+exports.getMaxClaimsForDynamicCondition = getMaxClaimsForDynamicCondition;
+exports.getMaxClaimsForDynamicGroup = getMaxClaimsForDynamicGroup;
+exports.meetsDynamicConditions = meetsDynamicConditions;
+exports.meetsClaimableConditions = meetsClaimableConditions;
+exports.aggregateTokenBalances = aggregateTokenBalances;
+const template_1 = require("./template");
+const dynamic_1 = require("./dynamic");
+const blockchain_utils_1 = require("./blockchain_utils");
+exports.DEFAULT_ENTITY_KIND = '_default';
+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, 
+/** Additional data like fetched token balances that isn't part of playerSnap */
+additionalData, }) => {
+    const conditionData = [];
+    let isValid = true;
+    if (conditions?.minDaysInGame) {
+        const isDisqualify = (playerSnap.daysInGame || 0) < conditions.minDaysInGame;
+        if (addDetails) {
+            conditionData.push({
+                isMet: !isDisqualify,
+                kind: 'minDaysInGame',
+                trackerAmount: playerSnap.daysInGame || 0,
+                trackerGoal: conditions.minDaysInGame,
+                text: `More than ${conditions.minDaysInGame} Days in Game`,
+            });
+            if (isDisqualify)
+                isValid = false;
+        }
+        else {
+            if (isDisqualify)
+                return { isValid: false };
+        }
+    }
+    if (conditions?.minTrustScore) {
+        const isDisqualify = (playerSnap.trustScore || 0) < conditions.minTrustScore;
+        if (addDetails) {
+            conditionData.push({
+                isMet: !isDisqualify,
+                kind: 'minTrustScore',
+                trackerAmount: playerSnap.trustScore || 0,
+                trackerGoal: conditions.minTrustScore,
+                text: `More than ${conditions.minTrustScore} Rep`,
+            });
+            if (isDisqualify)
+                isValid = false;
+        }
+        else {
+            if (isDisqualify)
+                return { isValid: false };
+        }
+    }
+    if (conditions?.maxTrustScore) {
+        const isDisqualify = (playerSnap.trustScore || 0) > conditions.maxTrustScore;
+        if (addDetails) {
+            conditionData.push({
+                isMet: !isDisqualify,
+                kind: 'maxTrustScore',
+                trackerAmount: playerSnap.trustScore || 0,
+                text: `Less than ${conditions.maxTrustScore} Rep`,
+            });
+            if (isDisqualify)
+                isValid = false;
+        }
+        else {
+            if (isDisqualify)
+                return { isValid: false };
+        }
+    }
+    for (const key in conditions?.achievements) {
+        const a = conditions.achievements[key];
+        const playerAchData = playerSnap.achievements?.[key];
+        if (!playerAchData) {
+            const isDisqualify = true;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'achievements',
+                    trackerAmount: 0,
+                    trackerGoal: 1,
+                    text: `Have the achievement ${a.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (a.minCount) {
+            const isDisqualify = (playerAchData?.count || 0) < a.minCount;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'achievements',
+                    trackerAmount: playerAchData?.count || 0,
+                    trackerGoal: a.minCount,
+                    text: `Have the achievement ${a.name} more than ${a.minCount} times`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    for (const key in conditions?.currencies) {
+        const c = conditions.currencies[key];
+        const playerCurrencyData = playerSnap.currencies?.[key];
+        if (c.min) {
+            const isDisqualify = (playerCurrencyData?.balance || 0) < c.min;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'currencies',
+                    trackerAmount: playerCurrencyData?.balance || 0,
+                    trackerGoal: c.min,
+                    text: `Have more than ${c.min} ${c.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (c.max) {
+            const isDisqualify = (playerCurrencyData?.balance || 0) > c.max;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'currencies',
+                    trackerAmount: playerCurrencyData?.balance || 0,
+                    text: `Have less than ${c.max} ${c.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (c.in) {
+            const isDisqualify = (playerCurrencyData?.in || 0) < c.in;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'currencies',
+                    trackerAmount: playerCurrencyData?.in || 0,
+                    trackerGoal: c.in,
+                    text: `Deposit at least ${c.in} ${c.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (c.out) {
+            const isDisqualify = (playerCurrencyData?.out || 0) < c.out;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'currencies',
+                    trackerAmount: playerCurrencyData?.out || 0,
+                    trackerGoal: c.out,
+                    text: `Withdraw at least ${c.out} ${c.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    for (const key in conditions?.levels) {
+        const l = conditions.levels[key];
+        const playerLevelData = playerSnap.levels?.[key];
+        if (l.min) {
+            const isDisqualify = (playerLevelData?.level || 0) < l.min;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'levels',
+                    trackerAmount: playerLevelData?.level || 0,
+                    trackerGoal: l.min,
+                    text: `Be above level ${l.min} ${l.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (l.max) {
+            const isDisqualify = (playerLevelData?.level || 0) > l.max;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'levels',
+                    trackerAmount: playerLevelData?.level || 0,
+                    text: `Be under level ${l.max} ${l.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    if (conditions?.quests) {
+        for (const questId in conditions.quests) {
+            const quest = conditions.quests[questId];
+            const playerQuestData = playerSnap.quests?.[questId];
+            const isDisqualify = playerQuestData ? (playerQuestData?.completions || 0) < (quest.completions || 0) : true; // if player has no data for this quest, they haven't completed it
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'quests',
+                    trackerAmount: playerQuestData?.completions || 0,
+                    trackerGoal: quest.completions || 1,
+                    text: quest.completions === 1
+                        ? `Complete the quest ${quest.name}`
+                        : (quest.completions || 0) < 1
+                            ? `Start the quest ${quest.name}`
+                            : `Complete the quest ${quest.name} ${quest.completions} times`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    for (const key in conditions?.memberships) {
+        const m = conditions.memberships[key];
+        const playerMembershipsData = playerSnap.memberships?.[key];
+        if (m.minCount) {
+            const isDisqualify = (playerMembershipsData?.count || 0) < m.minCount;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'memberships',
+                    trackerAmount: playerMembershipsData?.count || 0,
+                    trackerGoal: m.minCount,
+                    text: m.minCount > 1 ? `Have at least ${m.minCount} ${m.name} memberships` : `Have a ${m.name} membership`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (m.maxCount) {
+            const isDisqualify = (playerMembershipsData?.count || 0) > m.maxCount;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'memberships',
+                    trackerAmount: playerMembershipsData?.count || 0,
+                    text: `Have less than ${m.maxCount} ${m.name} memberships`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        const timeOwned = (playerMembershipsData?.expiresAt || 0) - Date.now();
+        if (m.minMs) {
+            const isDisqualify = timeOwned < m.minMs;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'memberships',
+                    trackerAmount: Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1)),
+                    trackerGoal: Number((m.minMs / (1000 * 60 * 60 * 24)).toFixed(1)),
+                    text: `Own ${m.name} membership for at least ${(m.minMs / (1000 * 60 * 60 * 24)).toFixed(1)} days`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+        if (m.maxMs) {
+            const isDisqualify = timeOwned > m.maxMs;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'memberships',
+                    trackerAmount: Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1)),
+                    text: `Own ${m.name} membership for less than ${(m.maxMs / (1000 * 60 * 60 * 24)).toFixed(1)} days`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    for (const key in conditions?.stakedTokens) {
+        const s = conditions.stakedTokens[key];
+        const playerStakedData = playerSnap.stakedTokens?.[key];
+        if (s.min) {
+            const isDisqualify = (playerStakedData?.balance || 0) < s.min;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'stakedTokens',
+                    trackerAmount: playerStakedData?.balance || 0,
+                    trackerGoal: s.min,
+                    text: `Have at least ${s.min} ${s.name} staked`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false };
+            }
+        }
+    }
+    // Validate link count conditions
+    if (conditions?.links && 'entityLinks' in playerSnap) {
+        for (const [linkType, constraint] of Object.entries(conditions.links)) {
+            // linkType should always exist. and be default is none was specified
+            const linkCount = playerSnap.entityLinks?.filter((link) => (link.kind || exports.DEFAULT_ENTITY_KIND) === linkType).length || 0;
+            if (constraint.min !== undefined) {
+                const isDisqualify = linkCount < constraint.min;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'links',
+                        trackerAmount: linkCount,
+                        trackerGoal: constraint.min,
+                        text: constraint.template
+                            ? (0, template_1.renderTemplate)(constraint.template, {
+                                current: linkCount,
+                                min: constraint.min ?? 0,
+                                max: constraint.max ?? 0,
+                                type: linkType,
+                            })
+                            : `At least ${constraint.min} ${linkType} link(s)`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+            if (constraint.max !== undefined) {
+                const isDisqualify = linkCount > constraint.max;
+                if (addDetails) {
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'links',
+                        trackerAmount: linkCount,
+                        text: constraint.template
+                            ? (0, template_1.renderTemplate)(constraint.template, {
+                                current: linkCount,
+                                min: constraint.min ?? 0,
+                                max: constraint.max ?? 0,
+                                type: linkType,
+                            })
+                            : `At most ${constraint.max} ${linkType} link(s)`,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false };
+                }
+            }
+        }
+    }
+    // Evaluate dynamic conditions
+    if (conditions?.dynamic?.conditions?.length) {
+        const resolvedConditions = (0, template_1.replaceDynamicConditionKeys)(conditions.dynamic.conditions, playerOffer?.trackers || {});
+        const dynamicResult = meetsDynamicConditions(playerSnap.dynamic, {
+            ...conditions.dynamic,
+            conditions: resolvedConditions,
+        });
+        if (addDetails) {
+            conditionData.push({
+                isMet: dynamicResult,
+                kind: 'dynamic',
+                text: (0, template_1.renderTemplate)(conditions.dynamic.template, playerSnap.dynamic) || 'Dynamic conditions',
+            });
+            if (!dynamicResult)
+                isValid = false;
+        }
+        else {
+            if (!dynamicResult)
+                return { isValid: false };
+        }
+    }
+    if (conditions?.identifiers?.platforms?.length && 'identifiers' in playerSnap) {
+        const playerPlatforms = new Set(playerSnap.identifiers?.map((i) => i.platform.toLowerCase()) || []);
+        const isAndBehaviour = conditions.identifiers.behaviour === 'AND';
+        const platformsToCheck = conditions.identifiers.platforms;
+        let isMet;
+        let displayText;
+        if (isAndBehaviour) {
+            isMet = platformsToCheck.every((platform) => playerPlatforms.has(platform.toLowerCase()));
+            displayText = `Link all: ${platformsToCheck.join(', ')}`;
+        }
+        else {
+            isMet = platformsToCheck.some((platform) => playerPlatforms.has(platform.toLowerCase()));
+            displayText = `Link any: ${platformsToCheck.join(', ')}`;
+        }
+        if (addDetails) {
+            conditionData.push({
+                isMet,
+                kind: 'identifiers',
+                trackerAmount: isMet ? 1 : 0,
+                trackerGoal: 1,
+                text: displayText,
+            });
+            if (!isMet)
+                isValid = false;
+        }
+        else {
+            if (!isMet)
+                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 = (0, blockchain_utils_1.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,
+                    trackerGoal: tokenCond.min,
+                    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 };
+};
+exports.meetsBaseConditions = meetsBaseConditions;
+const hasCompletionConditions = (conditions) => {
+    if (!conditions)
+        return false;
+    if (Object.keys(conditions.currencies || {}).length > 0)
+        return true;
+    if (Object.keys(conditions.levels || {}).length > 0)
+        return true;
+    if (Object.keys(conditions.stakedTokens || {}).length > 0)
+        return true;
+    if (Object.keys(conditions.memberships || {}).length > 0)
+        return true;
+    if (Object.keys(conditions.quests || {}).length > 0)
+        return true;
+    if (conditions.minTrustScore)
+        return true;
+    if (conditions.maxTrustScore)
+        return true;
+    if (conditions.achievements)
+        return true;
+    if (conditions.minDaysInGame)
+        return true;
+    if (conditions.dynamic?.conditions?.length)
+        return true;
+    if (conditions.identifiers?.platforms?.length)
+        return true;
+    const compCond = conditions;
+    if (compCond.context)
+        return true;
+    if (compCond.buyItem)
+        return true;
+    if (compCond.spendCurrency)
+        return true;
+    if (compCond.depositCurrency)
+        return true;
+    if (compCond.social)
+        return true;
+    if (compCond.login)
+        return true;
+    if (compCond.loginStreak)
+        return true;
+    if (compCond.linkedCompletions)
+        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;
+};
+exports.hasCompletionConditions = hasCompletionConditions;
+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.instanceId.toString());
+        }
+    }
+    if (linkedPlayerOffer_ids.length > 0) {
+        return { isValid: true, linkedPlayerOffer_ids };
+    }
+    return { isValid: false };
+};
+exports.meetsLinkedEntityOffersCondition = meetsLinkedEntityOffersCondition;
+const offerMeetsCompletionConditions = (offer, snapshot, additionalData) => {
+    return (0, exports.meetsCompletionConditions)({
+        completionConditions: offer.completionConditions || {},
+        completionTrackers: offer.completionTrackers,
+        playerSnap: snapshot,
+        playerOffer: offer,
+        addDetails: true,
+        maxClaimCount: offer.maxClaimCount,
+        additionalData,
+    });
+};
+exports.offerMeetsCompletionConditions = offerMeetsCompletionConditions;
+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.trackers?.claimedCount || 0) + 1 : 1;
+        const conditionData = [];
+        let isValid = true;
+        let maxTotalClaimsFromScaling = Infinity;
+        const updateMax = (limit) => (maxTotalClaimsFromScaling = Math.min(maxTotalClaimsFromScaling, limit));
+        if (completionConditions?.context?.id) {
+            const hasTrackedContext = completionTrackers?.context && completionConditions.context.id === completionTrackers.context;
+            const isDisqualify = !hasTrackedContext;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'context',
+                    trackerAmount: hasTrackedContext ? 1 : 0,
+                    trackerGoal: 1,
+                    text: completionConditions.context.name,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false, availableClaimsNow: 0 };
+            }
+        }
+        if (conditions?.buyItem) {
+            const baseAmount = conditions.buyItem.amount || 1;
+            const scaledAmount = baseAmount * claimMultiplier;
+            const trackerValue = completionTrackers?.buyItem || 0;
+            const isDisqualify = trackerValue < scaledAmount;
+            if (shouldScale && baseAmount > 0) {
+                updateMax(Math.floor(trackerValue / baseAmount));
+            }
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'buyItem',
+                    trackerAmount: trackerValue,
+                    trackerGoal: scaledAmount,
+                    text: `Buy ${scaledAmount} ${conditions.buyItem.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false, availableClaimsNow: 0 };
+            }
+        }
+        if (conditions?.spendCurrency) {
+            const baseAmount = conditions.spendCurrency.amount || 1;
+            const scaledAmount = baseAmount * claimMultiplier;
+            const trackerValue = completionTrackers?.spendCurrency || 0;
+            const isDisqualify = trackerValue < scaledAmount;
+            if (shouldScale && baseAmount > 0) {
+                updateMax(Math.floor(trackerValue / baseAmount));
+            }
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'spendCurrency',
+                    trackerAmount: trackerValue,
+                    trackerGoal: scaledAmount,
+                    text: `Spend ${scaledAmount} ${conditions.spendCurrency.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false, availableClaimsNow: 0 };
+            }
+        }
+        if (conditions?.depositCurrency) {
+            const baseAmount = conditions.depositCurrency.amount || 1;
+            const scaledAmount = baseAmount * claimMultiplier;
+            const trackerValue = completionTrackers?.depositCurrency || 0;
+            const isDisqualify = trackerValue < scaledAmount;
+            if (shouldScale && baseAmount > 0) {
+                updateMax(Math.floor(trackerValue / baseAmount));
+            }
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'depositCurrency',
+                    trackerAmount: trackerValue,
+                    trackerGoal: scaledAmount,
+                    text: `Deposit ${scaledAmount} ${conditions.depositCurrency.name}`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false, availableClaimsNow: 0 };
+            }
+        }
+        if (conditions?.login) {
+            const isMet = new Date(playerSnap.snapshotLastUpdated || 0).getTime() > new Date(playerOffer.createdAt || 0).getTime();
+            if (addDetails) {
+                conditionData.push({
+                    isMet,
+                    kind: 'login',
+                    trackerAmount: isMet ? 1 : 0,
+                    trackerGoal: 1,
+                    text: `Login to the game`,
+                });
+                if (!isMet)
+                    isValid = false;
+            }
+            else {
+                if (!isMet)
+                    return { isValid: false, availableClaimsNow: 0 };
+            }
+        }
+        if (conditions?.loginStreak) {
+            // player's login streak snapshot right now - their login streak when offer was surfaced = their login streak since the offer was surfaced
+            // if their login streak since the offer was surfaced is less than the required login streak, then they are not yet eligible for the offer
+            const streakSinceOffer = (playerSnap.loginStreak || 0) - (completionTrackers?.currentLoginStreak || 0);
+            const isDisqualify = streakSinceOffer + 1 < conditions.loginStreak;
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'loginStreak',
+                    trackerAmount: streakSinceOffer + 1,
+                    trackerGoal: conditions.loginStreak,
+                    text: `Login streak of ${conditions.loginStreak || 0} days`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false, availableClaimsNow: 0 };
+            }
+        }
+        if (conditions?.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' ? 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;
+            const minViews = (cSocial?.minViews || 0) * socialMultiplier;
+            const minComments = (cSocial?.minComments || 0) * socialMultiplier;
+            const likes = tSocial?.likes || 0;
+            const views = tSocial?.views || 0;
+            const comments = tSocial?.comments || 0;
+            let isDisqualify = !hasContent;
+            if (likes < minLikes || views < minViews || comments < minComments) {
+                isDisqualify = true;
+            }
+            if (shouldScale && mode === 'accumulate' && hasContent) {
+                const baseLikes = cSocial?.minLikes || 0;
+                const baseViews = cSocial?.minViews || 0;
+                const baseComments = cSocial?.minComments || 0;
+                if (baseLikes > 0)
+                    updateMax(Math.floor(likes / baseLikes));
+                if (baseViews > 0)
+                    updateMax(Math.floor(views / baseViews));
+                if (baseComments > 0)
+                    updateMax(Math.floor(comments / baseComments));
+            }
+            if (addDetails) {
+                const platformMap = {
+                    tiktok: 'TikTok',
+                    instagram: 'Instagram',
+                    youtube: 'YouTube',
+                };
+                const platformText = conditions.social.platforms.map((platform) => platformMap[platform]).join(' | ');
+                const requiredWords = cSocial?.requiredWords ?? [];
+                if (mode === 'accumulate') {
+                    const matchCount = tSocialAccumulate?.matchCount || 0;
+                    conditionData.push({
+                        isMet: hasContent,
+                        kind: 'social',
+                        trackerAmount: matchCount,
+                        trackerGoal: 1,
+                        text: hasContent
+                            ? `Found ${matchCount} matching ${platformText} post${matchCount !== 1 ? 's' : ''}`
+                            : requiredWords.length > 0
+                                ? `Post ${platformText} content with ${requiredWords.map((w) => `"${w}"`).join(', ')}`
+                                : `Post ${platformText} content`,
+                    });
+                }
+                else {
+                    const title = tSocialAttach?.title;
+                    conditionData.push({
+                        isMet: hasContent,
+                        kind: 'social',
+                        trackerAmount: hasContent ? 1 : 0,
+                        trackerGoal: 1,
+                        text: !hasContent
+                            ? requiredWords.length > 0
+                                ? `Attach a ${platformText} post with ${requiredWords.map((w) => `"${w}"`).join(', ')} in the title`
+                                : `Attach a ${platformText} post`
+                            : `Attached: ${title}`,
+                    });
+                }
+                if (minLikes > 0) {
+                    conditionData.push({
+                        isMet: hasContent && likes >= minLikes,
+                        kind: 'social',
+                        trackerAmount: likes,
+                        trackerGoal: minLikes,
+                        text: mode === 'accumulate' ? `Combined ${minLikes} Likes` : `Reach ${minLikes} Likes`,
+                    });
+                }
+                if (minViews > 0) {
+                    conditionData.push({
+                        isMet: hasContent && views >= minViews,
+                        kind: 'social',
+                        trackerAmount: views,
+                        trackerGoal: minViews,
+                        text: mode === 'accumulate' ? `Combined ${minViews} Views` : `Reach ${minViews} Views`,
+                    });
+                }
+                if (minComments > 0) {
+                    conditionData.push({
+                        isMet: hasContent && comments >= minComments,
+                        kind: 'social',
+                        trackerAmount: comments,
+                        trackerGoal: minComments,
+                        text: mode === 'accumulate' ? `Combined ${minComments} Comments` : `Reach ${minComments} Comments`,
+                    });
+                }
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false, availableClaimsNow: 0 };
+            }
+        }
+        // Linked completions - wait for N linked entities to complete
+        if (conditions?.linkedCompletions?.min) {
+            const baseMin = conditions.linkedCompletions.min;
+            const currentCount = completionTrackers?.linkedCompletions || 0;
+            const scaledMin = baseMin * claimMultiplier;
+            const isDisqualify = currentCount < scaledMin;
+            if (shouldScale && baseMin > 0) {
+                updateMax(Math.floor(currentCount / baseMin));
+            }
+            if (addDetails) {
+                conditionData.push({
+                    isMet: !isDisqualify,
+                    kind: 'linkedCompletions',
+                    trackerAmount: currentCount,
+                    trackerGoal: scaledMin,
+                    text: conditions.linkedCompletions.template
+                        ? (0, template_1.renderTemplate)(conditions.linkedCompletions.template, {
+                            current: currentCount,
+                            required: scaledMin,
+                        })
+                        : `Wait for ${scaledMin} linked ${scaledMin === 1 ? 'entity' : 'entities'} to complete`,
+                });
+                if (isDisqualify)
+                    isValid = false;
+            }
+            else {
+                if (isDisqualify)
+                    return { isValid: false, availableClaimsNow: 0 };
+            }
+        }
+        if (conditions?.dynamicTracker?.conditions?.length) {
+            const resolvedConditions = (0, template_1.replaceDynamicConditionKeys)(conditions.dynamicTracker.conditions, playerOffer?.trackers || {});
+            // now we have the game-defined conditions with {{}} keys populated. feed these conditions into evaluator
+            const dynamicResult = meetsDynamicConditions((0, dynamic_1.dynamicTrackerToPrimitive)(completionTrackers?.dynamicTracker || {}), {
+                ...conditions.dynamicTracker,
+                conditions: resolvedConditions,
+            }, claimMultiplier);
+            if (shouldScale) {
+                const dynamicMax = getMaxClaimsForDynamicGroup((0, dynamic_1.dynamicTrackerToPrimitive)(completionTrackers?.dynamicTracker || {}), {
+                    ...conditions.dynamicTracker,
+                    conditions: resolvedConditions,
+                }, playerOffer?.trackers?.claimedCount || 0);
+                updateMax(dynamicMax);
+            }
+            if (addDetails) {
+                conditionData.push({
+                    isMet: dynamicResult,
+                    kind: 'dynamicTracker',
+                    text: (0, template_1.renderTemplate)(conditions.dynamicTracker.template, (0, dynamic_1.dynamicTrackerToPrimitive)(completionTrackers?.dynamicTracker || {})) || 'Dynamic conditions',
+                });
+                if (!dynamicResult)
+                    isValid = false;
+            }
+            else {
+                if (!dynamicResult)
+                    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) {
+                    const displayText = (0, template_1.renderTemplate)(condition.template, {
+                        current: trackerValue,
+                        amount: scaledAmount,
+                    });
+                    conditionData.push({
+                        isMet: !isDisqualify,
+                        kind: 'contractInteractions',
+                        trackerAmount: trackerValue,
+                        trackerGoal: scaledAmount,
+                        text: displayText,
+                    });
+                    if (isDisqualify)
+                        isValid = false;
+                }
+                else {
+                    if (isDisqualify)
+                        return { isValid: false, availableClaimsNow: 0 };
+                }
+            }
+        }
+        const r = (0, exports.meetsBaseConditions)({
+            conditions,
+            playerSnap,
+            addDetails: true,
+            playerOffer,
+            additionalData,
+        });
+        isValid = isValid && r.isValid;
+        conditionData.push(...(r.conditionData || []));
+        if (maxClaimCount && maxClaimCount > 0) {
+            updateMax(maxClaimCount);
+        }
+        const claimedCount = playerOffer?.trackers?.claimedCount || 0;
+        const availableClaimsNow = !isValid
+            ? 0
+            : maxTotalClaimsFromScaling === Infinity
+                ? -1
+                : Math.max(0, maxTotalClaimsFromScaling - claimedCount);
+        return { isValid, conditionData, availableClaimsNow };
+    }
+    return { isValid: true, conditionData: [], availableClaimsNow: -1 };
+};
+exports.meetsCompletionConditions = meetsCompletionConditions;
+/**
+ * Checks if completion conditions were met before a specific expiry time.
+ * Returns true if all relevant condition fields were updated before expiryTime.
+ *
+ * @param completionConditions - The completion conditions to check
+ * @param completionTrackers - The completion trackers (for buyItem, spendCurrency, etc.)
+ * @param playerSnap - The player snapshot with field timestamps
+ * @returns true if all conditions were met before expiry, false otherwise
+ */
+const meetsCompletionConditionsBeforeExpiry = ({ completionConditions, completionTrackers, playerSnap, playerOffer, maxClaimCount, }) => {
+    if (!completionConditions)
+        return false;
+    // Check if there are actually any conditions to evaluate
+    if (!(0, exports.hasCompletionConditions)(completionConditions))
+        return false;
+    // First check if conditions are actually met
+    const conditionsMet = (0, exports.meetsCompletionConditions)({
+        completionConditions,
+        completionTrackers,
+        playerOffer,
+        playerSnap,
+        maxClaimCount,
+    });
+    if (!conditionsMet.isValid)
+        return false;
+    if (!playerOffer.expiresAt)
+        return true;
+    const expiryTime = new Date(playerOffer.expiresAt).getTime();
+    const lastSnapshotUpdate = new Date(playerSnap.snapshotLastUpdated ?? new Date()).getTime();
+    /**
+     * Checks if a field was updated after the expiry time.
+     * Returns true if updated AFTER or AT expiry (violates grace period).
+     * Returns false if updated BEFORE expiry (allows grace period).
+     */
+    function wasUpdatedAfterExpiry(data) {
+        let lastUpdated;
+        if (typeof data === 'object' && data !== null && !(data instanceof Date)) {
+            // Object with optional lastUpdated field
+            lastUpdated = data.lastUpdated ? new Date(data.lastUpdated).getTime() : lastSnapshotUpdate;
+        }
+        else if (data instanceof Date) {
+            lastUpdated = data.getTime();
+        }
+        else if (typeof data === 'string' || typeof data === 'number') {
+            lastUpdated = new Date(data).getTime();
+        }
+        else {
+            // No data provided, use snapshot timestamp
+            lastUpdated = lastSnapshotUpdate;
+        }
+        return lastUpdated >= expiryTime;
+    }
+    if (completionConditions.currencies) {
+        for (const currencyId in completionConditions.currencies) {
+            const currency = playerSnap.currencies?.[currencyId];
+            if (!currency)
+                continue;
+            if (wasUpdatedAfterExpiry(currency))
+                return false;
+        }
+    }
+    if (completionConditions.levels) {
+        for (const skillId in completionConditions.levels) {
+            const level = playerSnap.levels?.[skillId];
+            if (!level)
+                continue;
+            if (wasUpdatedAfterExpiry(level))
+                return false;
+        }
+    }
+    if (completionConditions.quests) {
+        for (const questId in completionConditions.quests) {
+            const quest = playerSnap.quests?.[questId];
+            if (!quest)
+                continue;
+            if (wasUpdatedAfterExpiry(quest))
+                return false;
+        }
+    }
+    if (completionConditions.memberships) {
+        for (const membershipId in completionConditions.memberships) {
+            const membership = playerSnap.memberships?.[membershipId];
+            if (!membership)
+                continue;
+            if (wasUpdatedAfterExpiry(membership))
+                return false;
+        }
+    }
+    if (completionConditions.achievements) {
+        for (const achievementId in completionConditions.achievements) {
+            const achievement = playerSnap.achievements?.[achievementId];
+            if (!achievement)
+                continue;
+            if (wasUpdatedAfterExpiry(achievement))
+                return false;
+        }
+    }
+    if (completionConditions.stakedTokens) {
+        for (const tokenId in completionConditions.stakedTokens) {
+            const stakedToken = playerSnap.stakedTokens?.[tokenId];
+            if (!stakedToken)
+                continue;
+            const lastStakeTime = new Date(stakedToken.lastStake ?? 0).getTime();
+            const lastUnstakeTime = new Date(stakedToken.lastUnstake ?? 0).getTime();
+            const lastUpdated = Math.max(lastStakeTime, lastUnstakeTime);
+            if (lastUpdated >= expiryTime)
+                return false;
+        }
+    }
+    if (completionConditions.minTrustScore !== undefined || completionConditions.maxTrustScore !== undefined) {
+        if (wasUpdatedAfterExpiry(playerSnap.trustLastUpdated))
+            return false;
+    }
+    if (completionConditions.minDaysInGame !== undefined) {
+        if (wasUpdatedAfterExpiry(playerSnap.daysInGameLastUpdated))
+            return false;
+    }
+    if (completionConditions.login || completionConditions.loginStreak) {
+        if (wasUpdatedAfterExpiry())
+            return false;
+    }
+    if (completionConditions.social) {
+        // Check if social content was attached/validated after expiry
+        if (completionTrackers?.social?.lastChecked) {
+            if (wasUpdatedAfterExpiry(completionTrackers.social.lastChecked))
+                return false;
+        }
+    }
+    // All conditions were met before expiry
+    return true;
+};
+exports.meetsCompletionConditionsBeforeExpiry = meetsCompletionConditionsBeforeExpiry;
+/**
+ * Checks if a dynamic object meets a set of dynamic field conditions.
+ * @param dynamicObj - The object with any key and string or number value.
+ * @param conditions - Array of conditions to check.
+ * @param claimMultiplier - Multiplier to scale conditions (used for numeric comparisons).
+ * @returns true if all conditions are met, false otherwise.
+ */
+/**
+ * Evaluates a single dynamic condition against the dynamic object.
+ */
+function evaluateDynamicCondition(dynamicObj, cond, claimMultiplier = 1) {
+    if (!dynamicObj)
+        return false;
+    const val = dynamicObj[cond.key];
+    if (val == undefined)
+        return false;
+    const isNumber = typeof val === 'number';
+    const isBoolean = typeof val === 'boolean';
+    if (isBoolean) {
+        switch (cond.operator) {
+            case '==':
+                return val === Boolean(cond.compareTo);
+            case '!=':
+                return val !== Boolean(cond.compareTo);
+            default:
+                return false;
+        }
+    }
+    const compareTo = isNumber ? Number(cond.compareTo) : String(cond.compareTo);
+    if (isNumber && typeof compareTo === 'number') {
+        const skipMultiplier = cond.operator === '==' || cond.operator === '!=';
+        const scaledCompareTo = skipMultiplier ? compareTo : compareTo * claimMultiplier;
+        switch (cond.operator) {
+            case '==':
+                return val === scaledCompareTo;
+            case '!=':
+                return val !== scaledCompareTo;
+            case '>':
+                return val > scaledCompareTo;
+            case '>=':
+                return val >= scaledCompareTo;
+            case '<':
+                return val < scaledCompareTo;
+            case '<=':
+                return val <= scaledCompareTo;
+        }
+    }
+    else if (!isNumber && typeof compareTo === 'string') {
+        switch (cond.operator) {
+            case '==':
+                return val === compareTo;
+            case '!=':
+                return val !== compareTo;
+            case 'has':
+                return val.includes(compareTo);
+            case 'not_has':
+                return !val.includes(compareTo);
+        }
+    }
+    return false;
+}
+/**
+ * Calculates the maximum number of claims supported by a single dynamic condition.
+ */
+function getMaxClaimsForDynamicCondition(dynamicObj, cond) {
+    if (!dynamicObj)
+        return 0;
+    const val = dynamicObj[cond.key];
+    if (val === undefined)
+        return 0;
+    if (typeof val === 'number') {
+        const base = Number(cond.compareTo);
+        if (isNaN(base)) {
+            return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+        }
+        switch (cond.operator) {
+            case '>=':
+                if (base === 0)
+                    return val >= 0 ? Infinity : 0;
+                if (base < 0)
+                    return val >= base ? Infinity : 0;
+                return Math.max(0, Math.floor(val / base));
+            case '>':
+                if (base === 0)
+                    return val > 0 ? Infinity : 0;
+                if (base < 0)
+                    return val > base ? Infinity : 0;
+                if (val <= 0)
+                    return 0;
+                return Math.max(0, Math.ceil(val / base) - 1);
+            case '==':
+                return val === base ? Infinity : 0;
+            case '!=':
+                return val !== base ? Infinity : 0;
+            case '<=':
+                if (base === 0)
+                    return val <= 0 ? Infinity : 0;
+                if (base > 0)
+                    return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+                if (val >= 0)
+                    return 0;
+                return Math.max(0, Math.floor(val / base));
+            case '<':
+                if (base === 0)
+                    return val < 0 ? Infinity : 0;
+                if (base > 0)
+                    return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+                if (val >= 0)
+                    return 0;
+                return Math.max(0, Math.ceil(val / base) - 1);
+        }
+    }
+    // we don't scale the rest, they are always true or always false
+    return evaluateDynamicCondition(dynamicObj, cond, 1) ? Infinity : 0;
+}
+/**
+ * Calculates the maximum number of claims supported by a group of dynamic conditions.
+ */
+function getMaxClaimsForDynamicGroup(dynamicObj, dynamicGroup, currentClaimCount = 0) {
+    const { conditions, links } = dynamicGroup;
+    if (!conditions || conditions.length === 0)
+        return Infinity;
+    // AND only
+    if (!links || links.length === 0 || links.every((l) => l === 'AND')) {
+        let minClaims = Infinity;
+        for (const cond of conditions) {
+            const max = getMaxClaimsForDynamicCondition(dynamicObj, cond);
+            if (max === 0)
+                return 0;
+            minClaims = Math.min(minClaims, max);
+        }
+        return minClaims;
+    }
+    // OR only
+    if (links.every((l) => l === 'OR')) {
+        let maxClaims = 0;
+        for (const cond of conditions) {
+            const max = getMaxClaimsForDynamicCondition(dynamicObj, cond);
+            if (max === Infinity)
+                return Infinity;
+            maxClaims = Math.max(maxClaims, max);
+        }
+        return maxClaims;
+    }
+    // mixed:
+    const maxIterations = 100;
+    for (let n = currentClaimCount + 1; n <= currentClaimCount + maxIterations; n++) {
+        if (!meetsDynamicConditions(dynamicObj, dynamicGroup, n)) {
+            return n - 1;
+        }
+    }
+    return currentClaimCount + maxIterations;
+}
+/**
+ * Evaluates a group of dynamic conditions with logical links (AND, OR, AND NOT).
+ * @param dynamicObj - The player's dynamic object with any key and string or number value.
+ * @param dynamicGroup - The group of conditions and links to check.
+ * @param claimMultiplier - Multiplier to scale conditions (used for numeric comparisons).
+ * @returns true if the group evaluates to true, false otherwise.
+ */
+function meetsDynamicConditions(dynamicObj, dynamicGroup, claimMultiplier = 1) {
+    const { conditions, links } = dynamicGroup;
+    if (!conditions || conditions.length === 0)
+        return true;
+    if (!dynamicObj)
+        return false;
+    // If no links, treat as AND between all conditions
+    if (!links || links.length === 0) {
+        return conditions.every((cond) => evaluateDynamicCondition(dynamicObj, cond, claimMultiplier));
+    }
+    // Evaluate the first condition
+    let result = evaluateDynamicCondition(dynamicObj, conditions[0], claimMultiplier);
+    for (let i = 0; i < links.length; i++) {
+        const nextCond = evaluateDynamicCondition(dynamicObj, conditions[i + 1], claimMultiplier);
+        const link = links[i];
+        if (link === 'AND') {
+            result = result && nextCond;
+        }
+        else if (link === 'OR') {
+            result = result || nextCond;
+        }
+        else if (link === 'AND NOT') {
+            result = result && !nextCond;
+        }
+    }
+    return result;
+}
+/**
+ * Checks if a PlayerOffer meets its claimable conditions (completed -> claimable transition).
+ * @param claimableConditions - The offer's claimableConditions (from IOffer)
+ * @param claimableTrackers - The player offer's claimableTrackers
+ */
+function meetsClaimableConditions({ claimableConditions, playerOfferTrackers, claimableTrackers, }) {
+    if (!claimableConditions) {
+        return { isValid: true };
+    }
+    if (claimableConditions.siblingCompletions) {
+        const siblingCount = playerOfferTrackers?.siblingPlayerOffer_ids?.length ?? 0;
+        let completedCount = claimableTrackers?.siblingCompletions ?? 0;
+        if (completedCount == -1)
+            completedCount = siblingCount; // treat -1 as all completed
+        // if siblings exist but not all are completed, return false
+        if (siblingCount > 0 && completedCount < siblingCount) {
+            return { isValid: false };
+        }
+    }
+    return { isValid: true };
+}
+// returns contractAddress:network -> balance
+function aggregateTokenBalances(data) {
+    const aggregatedBalances = {};
+    for (const { balances } of data?.cryptoWallets || []) {
+        if (!balances)
+            continue;
+        for (const [key, balance] of Object.entries(balances)) {
+            if (!aggregatedBalances[key]) {
+                aggregatedBalances[key] = 0;
+            }
+            aggregatedBalances[key] += balance;
+        }
+    }
+    return aggregatedBalances;
+}
+//# sourceMappingURL=conditions.js.map