@stackedapp/utils 1.23.2 → 1.23.4

package/dist/conditions.js

@@ -1,1746 +0,0 @@
-"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 calculatePercent = (amount, goal, isMet) => {
-    if (goal && goal > 0 && amount !== undefined) {
-        return Math.min(100, (amount / goal) * 100);
-    }
-    return isMet ? 100 : 0;
-};
-const formatList = (items) => items.length === 2 ? items.join(' and ') : `${items.slice(0, -1).join(', ')}, and ${items.at(-1)}`;
-const calculateDynamicConditionPercent = (dynamicObj, cond) => {
-    if (!dynamicObj)
-        return 0;
-    if (cond.operator === 'is_truthy')
-        return dynamicObj[cond.key] ? 100 : 0;
-    if (cond.operator === 'is_falsy')
-        return !dynamicObj[cond.key] ? 100 : 0;
-    if (cond.operator === 'is_defined')
-        return dynamicObj[cond.key] != null ? 100 : 0;
-    const val = dynamicObj[cond.key];
-    if (typeof val !== 'number')
-        return 0;
-    const compareTo = typeof cond.compareTo === 'number' ? cond.compareTo : 0;
-    switch (cond.operator) {
-        case '>=':
-        case '>':
-            return compareTo > 0 ? Math.min(100, (val / compareTo) * 100) : val >= compareTo ? 100 : 0;
-        case '==':
-            return val === compareTo ? 100 : 0;
-        case '!=':
-            return val !== compareTo ? 100 : 0;
-        case '<=':
-        case '<':
-            return val <= compareTo ? 100 : 0; // Binary for max-style
-        default:
-            return 0;
-    }
-};
-const calculateDynamicGroupPercent = (dynamicObj, group) => {
-    if (!group?.conditions?.length)
-        return 100;
-    const percentages = group.conditions.map((c) => calculateDynamicConditionPercent(dynamicObj, c));
-    if (!group.links?.length) {
-        return percentages.reduce((sum, p) => sum + p, 0) / percentages.length;
-    }
-    let result = percentages[0];
-    for (let i = 0; i < group.links.length; i++) {
-        const nextPct = percentages[i + 1];
-        switch (group.links[i]) {
-            case 'AND':
-                result = (result + nextPct) / 2;
-                break;
-            case 'OR':
-                result = Math.max(result, nextPct);
-                break;
-            case 'AND NOT':
-                result = (result + (100 - nextPct)) / 2;
-                break;
-        }
-    }
-    return result;
-};
-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 trackerAmount = playerSnap.daysInGame || 0;
-        const trackerGoal = conditions.minDaysInGame;
-        const isDisqualify = trackerAmount < trackerGoal;
-        if (addDetails) {
-            conditionData.push({
-                isMet: !isDisqualify,
-                kind: 'minDaysInGame',
-                trackerAmount,
-                trackerGoal,
-                percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                text: `More than ${trackerGoal} Days in Game`,
-            });
-            if (isDisqualify)
-                isValid = false;
-        }
-        else {
-            if (isDisqualify)
-                return { isValid: false, isComplete: false, percentCompleted: 0 };
-        }
-    }
-    if (conditions?.minTrustScore) {
-        const trackerAmount = playerSnap.trustScore || 0;
-        const trackerGoal = conditions.minTrustScore;
-        const isDisqualify = trackerAmount < trackerGoal;
-        if (addDetails) {
-            conditionData.push({
-                isMet: !isDisqualify,
-                kind: 'minTrustScore',
-                trackerAmount,
-                trackerGoal,
-                percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                text: `More than ${trackerGoal} Rep`,
-            });
-            if (isDisqualify)
-                isValid = false;
-        }
-        else {
-            if (isDisqualify)
-                return { isValid: false, isComplete: false, percentCompleted: 0 };
-        }
-    }
-    if (conditions?.maxTrustScore) {
-        const trackerAmount = playerSnap.trustScore || 0;
-        const isDisqualify = trackerAmount > conditions.maxTrustScore;
-        if (addDetails) {
-            conditionData.push({
-                isMet: !isDisqualify,
-                kind: 'maxTrustScore',
-                trackerAmount,
-                trackerGoal: conditions.maxTrustScore,
-                percentCompleted: !isDisqualify ? 100 : 0, // Binary for max conditions
-                text: `Less than ${conditions.maxTrustScore} Rep`,
-            });
-            if (isDisqualify)
-                isValid = false;
-        }
-        else {
-            if (isDisqualify)
-                return { isValid: false, isComplete: false, percentCompleted: 0 };
-        }
-    }
-    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,
-                    percentCompleted: 0,
-                    text: `Have the achievement ${a.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        if (a.minCount) {
-            const trackerAmount = playerAchData?.count || 0;
-            const trackerGoal = a.minCount;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'achievements',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: `Have the achievement ${a.name} more than ${trackerGoal} times`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-    }
-    for (const key in conditions?.currencies) {
-        const c = conditions.currencies[key];
-        const playerCurrencyData = playerSnap.currencies?.[key];
-        if (c.min) {
-            const trackerAmount = playerCurrencyData?.balance || 0;
-            const trackerGoal = c.min;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'currencies',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: `Have more than ${trackerGoal} ${c.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        if (c.max) {
-            const trackerAmount = playerCurrencyData?.balance || 0;
-            const isDisqualify = trackerAmount > c.max;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'currencies',
-                    trackerAmount,
-                    trackerGoal: c.max,
-                    percentCompleted: !isDisqualify ? 100 : 0, // Binary for max conditions
-                    text: `Have less than ${c.max} ${c.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        if (c.in) {
-            const trackerAmount = playerCurrencyData?.in || 0;
-            const trackerGoal = c.in;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'currencies',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: `Deposit at least ${trackerGoal} ${c.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        if (c.out) {
-            const trackerAmount = playerCurrencyData?.out || 0;
-            const trackerGoal = c.out;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'currencies',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: `Withdraw at least ${trackerGoal} ${c.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-    }
-    for (const key in conditions?.levels) {
-        const l = conditions.levels[key];
-        const playerLevelData = playerSnap.levels?.[key];
-        if (l.min) {
-            const trackerAmount = playerLevelData?.level || 0;
-            const trackerGoal = l.min;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'levels',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: `Be above level ${trackerGoal} ${l.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        if (l.max) {
-            const trackerAmount = playerLevelData?.level || 0;
-            const isDisqualify = trackerAmount > l.max;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'levels',
-                    trackerAmount,
-                    trackerGoal: l.max,
-                    percentCompleted: !isDisqualify ? 100 : 0, // Binary for max conditions
-                    text: `Be under level ${l.max} ${l.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-    }
-    if (conditions?.quests) {
-        for (const questId in conditions.quests) {
-            const quest = conditions.quests[questId];
-            const playerQuestData = playerSnap.quests?.[questId];
-            const trackerAmount = playerQuestData?.completions || 0;
-            const trackerGoal = quest.completions || 1;
-            const isDisqualify = playerQuestData ? trackerAmount < (quest.completions || 0) : true;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'quests',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    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, isComplete: false, percentCompleted: 0 };
-            }
-        }
-    }
-    for (const key in conditions?.memberships) {
-        const m = conditions.memberships[key];
-        const playerMembershipsData = playerSnap.memberships?.[key];
-        if (m.minCount) {
-            const trackerAmount = playerMembershipsData?.count || 0;
-            const trackerGoal = m.minCount;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'memberships',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: trackerGoal > 1 ? `Have at least ${trackerGoal} ${m.name} memberships` : `Have a ${m.name} membership`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        if (m.maxCount) {
-            const trackerAmount = playerMembershipsData?.count || 0;
-            const isDisqualify = trackerAmount > m.maxCount;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'memberships',
-                    trackerAmount,
-                    trackerGoal: m.maxCount,
-                    percentCompleted: !isDisqualify ? 100 : 0, // Binary for max conditions
-                    text: `Have less than ${m.maxCount} ${m.name} memberships`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        const timeOwned = (playerMembershipsData?.expiresAt || 0) - Date.now();
-        if (m.minMs) {
-            const trackerAmount = Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1));
-            const trackerGoal = Number((m.minMs / (1000 * 60 * 60 * 24)).toFixed(1));
-            const isDisqualify = timeOwned < m.minMs;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'memberships',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: `Own ${m.name} membership for at least ${trackerGoal} days`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        if (m.maxMs) {
-            const trackerAmount = Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1));
-            const isDisqualify = timeOwned > m.maxMs;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'memberships',
-                    trackerAmount,
-                    trackerGoal: Number((m.maxMs / (1000 * 60 * 60 * 24)).toFixed(1)),
-                    percentCompleted: !isDisqualify ? 100 : 0, // Binary for max conditions
-                    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, isComplete: false, percentCompleted: 0 };
-            }
-        }
-    }
-    for (const key in conditions?.stakedTokens) {
-        const s = conditions.stakedTokens[key];
-        const playerStakedData = playerSnap.stakedTokens?.[key];
-        if (s.min) {
-            const trackerAmount = playerStakedData?.balance || 0;
-            const trackerGoal = s.min;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'stakedTokens',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: `Have at least ${trackerGoal} ${s.name} staked`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-    }
-    // Validate link count conditions
-    if (conditions?.links) {
-        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 trackerAmount = linkCount;
-                const trackerGoal = constraint.min;
-                const isDisqualify = trackerAmount < trackerGoal;
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'links',
-                        trackerAmount,
-                        trackerGoal,
-                        percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                        text: constraint.template
-                            ? (0, template_1.renderTemplate)(constraint.template, {
-                                current: linkCount,
-                                min: constraint.min ?? 0,
-                                max: constraint.max ?? 0,
-                                type: linkType,
-                            })
-                            : `At least ${trackerGoal} ${linkType} link(s)`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, isComplete: false, percentCompleted: 0 };
-                }
-            }
-            if (constraint.max !== undefined) {
-                const trackerAmount = linkCount;
-                const isDisqualify = trackerAmount > constraint.max;
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'links',
-                        trackerAmount,
-                        trackerGoal: constraint.max,
-                        percentCompleted: !isDisqualify ? 100 : 0, // Binary for max conditions
-                        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, isComplete: false, percentCompleted: 0 };
-                }
-            }
-        }
-    }
-    // Evaluate dynamic conditions
-    if (conditions?.dynamic?.conditions?.length) {
-        const resolvedConditions = (0, template_1.replaceDynamicConditionKeys)(conditions.dynamic.conditions, playerOffer?.trackers || {});
-        const dynamicObj = playerSnap.dynamic || {};
-        const dynamicResult = meetsDynamicConditions(dynamicObj, {
-            ...conditions.dynamic,
-            conditions: resolvedConditions,
-        });
-        if (addDetails) {
-            // Extract tracker amount and goal from the first condition for display
-            let trackerAmount;
-            let trackerGoal;
-            if (resolvedConditions.length > 0) {
-                const firstCond = resolvedConditions[0];
-                if (typeof firstCond.compareTo === 'number') {
-                    trackerGoal = firstCond.compareTo;
-                }
-                const val = dynamicObj[firstCond.key];
-                trackerAmount = typeof val === 'number' ? val : 0;
-            }
-            // Calculate percentage using the dynamic group helper for AND/OR logic
-            const percentCompleted = calculateDynamicGroupPercent(dynamicObj, {
-                ...conditions.dynamic,
-                conditions: resolvedConditions,
-            });
-            conditionData.push({
-                isMet: dynamicResult,
-                kind: 'dynamic',
-                trackerAmount,
-                trackerGoal,
-                percentCompleted,
-                text: (0, template_1.renderTemplate)((0, template_1.replaceDynamicConditionKey)(conditions.dynamic.template || '', playerOffer?.trackers || {}), dynamicObj) || 'Dynamic conditions',
-            });
-            if (!dynamicResult)
-                isValid = false;
-        }
-        else {
-            if (!dynamicResult)
-                return { isValid: false, isComplete: false, percentCompleted: 0 };
-        }
-    }
-    if (conditions?.identifiers?.platforms?.length) {
-        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;
-        const platformsMap = {
-            sms: 'SMS',
-            email: 'Email',
-            apple: 'Apple',
-            google: 'Google',
-            tiktok: 'TikTok',
-        };
-        const metAndPlatforms = platformsToCheck.filter((platform) => playerPlatforms.has(platform.toLowerCase()));
-        if (isAndBehaviour) {
-            isMet = metAndPlatforms.length === platformsToCheck.length;
-            displayText =
-                platformsToCheck.length > 1
-                    ? `Link your ${formatList(platformsToCheck.map((p) => platformsMap[p.toLowerCase()] ?? p))} accounts`
-                    : `Link your ${platformsMap[platformsToCheck[0].toLowerCase()] ?? platformsToCheck[0]} account`;
-        }
-        else {
-            isMet = platformsToCheck.some((platform) => playerPlatforms.has(platform.toLowerCase()));
-            displayText = `Link any of your ${formatList(platformsToCheck.map((p) => platformsMap[p.toLowerCase()] ?? p))} accounts`;
-        }
-        if (addDetails) {
-            conditionData.push({
-                isMet,
-                kind: 'identifiers',
-                trackerAmount: isMet ? 1 : 0,
-                trackerGoal: 1,
-                percentCompleted: isAndBehaviour
-                    ? calculatePercent(metAndPlatforms.length, platformsToCheck.length, isMet)
-                    : isMet
-                        ? 100
-                        : 0,
-                text: displayText,
-            });
-            if (!isMet)
-                isValid = false;
-        }
-        else {
-            if (!isMet)
-                return { isValid: false, isComplete: false, percentCompleted: 0 };
-        }
-    }
-    // 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 trackerAmount = totalBalance;
-            const trackerGoal = tokenCond.min;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'tokenBalances',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: `Have at least ${trackerGoal} ${tokenCond.name || 'tokens'}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        if (tokenCond.max !== undefined) {
-            const trackerAmount = totalBalance;
-            const isDisqualify = trackerAmount > tokenCond.max;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'tokenBalances',
-                    trackerAmount,
-                    trackerGoal: tokenCond.max,
-                    percentCompleted: !isDisqualify ? 100 : 0, // Binary for max conditions
-                    text: `Have at most ${tokenCond.max} ${tokenCond.name || 'tokens'}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-    }
-    // Evaluate stackedAccount conditions
-    if (conditions?.stackedAccount) {
-        const { hasLinkedAccount, cryptoWallets } = conditions.stackedAccount;
-        // Check if player has linked stacked account
-        if (hasLinkedAccount !== undefined) {
-            const playerHasAccount = additionalData?.hasStackedAccount ?? false;
-            const isDisqualify = hasLinkedAccount !== playerHasAccount;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'stackedAccount.hasLinkedAccount',
-                    trackerAmount: playerHasAccount ? 1 : 0,
-                    trackerGoal: 1,
-                    percentCompleted: !isDisqualify ? 100 : 0,
-                    text: hasLinkedAccount ? 'Link a Stacked account' : 'Must not have Stacked account linked',
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-        // Check crypto wallet count
-        if (cryptoWallets) {
-            const walletCount = additionalData?.cryptoWallets?.length || 0;
-            if (cryptoWallets.min !== undefined) {
-                const trackerAmount = walletCount;
-                const trackerGoal = cryptoWallets.min;
-                const isDisqualify = trackerAmount < trackerGoal;
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'stackedAccount.cryptoWallets',
-                        trackerAmount,
-                        trackerGoal,
-                        percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                        text: `Link at least ${trackerGoal} crypto wallet${trackerGoal === 1 ? '' : 's'}`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, isComplete: false, percentCompleted: 0 };
-                }
-            }
-            if (cryptoWallets.max !== undefined) {
-                const trackerAmount = walletCount;
-                const trackerGoal = cryptoWallets.max;
-                const isDisqualify = trackerAmount > trackerGoal;
-                if (addDetails) {
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'stackedAccount.cryptoWallets',
-                        trackerAmount,
-                        trackerGoal,
-                        percentCompleted: !isDisqualify ? 100 : 0, // Binary for max conditions
-                        text: `Have at most ${trackerGoal} crypto wallet${trackerGoal === 1 ? '' : 's'}`,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, isComplete: false, percentCompleted: 0 };
-                }
-            }
-        }
-    }
-    // Evaluate userSettings conditions
-    if (conditions?.userSettings) {
-        const { emailNewsletter } = conditions.userSettings;
-        if (emailNewsletter !== undefined) {
-            const playerHasNewsletter = additionalData?.emailNewsletter ?? false;
-            const isDisqualify = emailNewsletter !== playerHasNewsletter;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'userSettings.emailNewsletter',
-                    trackerAmount: playerHasNewsletter ? 1 : 0,
-                    trackerGoal: 1,
-                    percentCompleted: !isDisqualify ? 100 : 0,
-                    text: emailNewsletter ? 'Subscribe to email newsletter' : 'Must not be subscribed to email newsletter',
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0 };
-            }
-        }
-    }
-    // Calculate top-level percentCompleted as average of all condition percentages
-    const percentCompleted = conditionData.length > 0
-        ? conditionData.reduce((sum, c) => sum + c.percentCompleted, 0) / conditionData.length
-        : isValid
-            ? 100
-            : 0;
-    return {
-        /** @deprecated Use isComplete instead */
-        isValid,
-        isComplete: isValid,
-        percentCompleted,
-        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;
-    if (conditions.stackedAccount)
-        return true;
-    if (conditions.userSettings)
-        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,
-                    percentCompleted: !isDisqualify ? 100 : 0, // Binary
-                    text: completionConditions.context.name,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0, 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,
-                    percentCompleted: calculatePercent(trackerValue, scaledAmount, !isDisqualify),
-                    text: `Buy ${scaledAmount} ${conditions.buyItem.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0, 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,
-                    percentCompleted: calculatePercent(trackerValue, scaledAmount, !isDisqualify),
-                    text: `Spend ${scaledAmount} ${conditions.spendCurrency.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0, 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,
-                    percentCompleted: calculatePercent(trackerValue, scaledAmount, !isDisqualify),
-                    text: `Deposit ${scaledAmount} ${conditions.depositCurrency.name}`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0, 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,
-                    percentCompleted: isMet ? 100 : 0, // Binary
-                    text: `Login to the game`,
-                });
-                if (!isMet)
-                    isValid = false;
-            }
-            else {
-                if (!isMet)
-                    return { isValid: false, isComplete: false, percentCompleted: 0, 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 trackerAmount = (playerSnap.loginStreak || 0) - (completionTrackers?.currentLoginStreak || 0) + 1;
-            const trackerGoal = conditions.loginStreak;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'loginStreak',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: `Login streak of ${trackerGoal || 0} days`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0, 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));
-            }
-            // Calculate social percentage - average of all applicable metrics
-            const socialPercentages = [];
-            if (minLikes > 0)
-                socialPercentages.push(calculatePercent(likes, minLikes, likes >= minLikes));
-            if (minViews > 0)
-                socialPercentages.push(calculatePercent(views, minViews, views >= minViews));
-            if (minComments > 0)
-                socialPercentages.push(calculatePercent(comments, minComments, comments >= minComments));
-            if (!hasContent)
-                socialPercentages.push(0);
-            const socialPercent = socialPercentages.length > 0
-                ? socialPercentages.reduce((a, b) => a + b, 0) / socialPercentages.length
-                : hasContent
-                    ? 100
-                    : 0;
-            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 && !isDisqualify,
-                        kind: 'social',
-                        trackerAmount: matchCount,
-                        trackerGoal: 1,
-                        percentCompleted: socialPercent,
-                        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 && !isDisqualify,
-                        kind: 'social',
-                        trackerAmount: hasContent ? 1 : 0,
-                        trackerGoal: 1,
-                        percentCompleted: socialPercent,
-                        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,
-                        percentCompleted: calculatePercent(likes, minLikes, hasContent && likes >= 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,
-                        percentCompleted: calculatePercent(views, minViews, hasContent && views >= 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,
-                        percentCompleted: calculatePercent(comments, minComments, hasContent && comments >= minComments),
-                        text: mode === 'accumulate' ? `Combined ${minComments} Comments` : `Reach ${minComments} Comments`,
-                    });
-                }
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0, availableClaimsNow: 0 };
-            }
-        }
-        // Linked completions - wait for N linked entities to complete
-        if (conditions?.linkedCompletions?.min) {
-            const baseMin = conditions.linkedCompletions.min;
-            const trackerAmount = completionTrackers?.linkedCompletions || 0;
-            const trackerGoal = baseMin * claimMultiplier;
-            const isDisqualify = trackerAmount < trackerGoal;
-            if (shouldScale && baseMin > 0) {
-                updateMax(Math.floor(trackerAmount / baseMin));
-            }
-            if (addDetails) {
-                conditionData.push({
-                    isMet: !isDisqualify,
-                    kind: 'linkedCompletions',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted: calculatePercent(trackerAmount, trackerGoal, !isDisqualify),
-                    text: conditions.linkedCompletions.template
-                        ? (0, template_1.renderTemplate)(conditions.linkedCompletions.template, {
-                            current: trackerAmount,
-                            required: trackerGoal,
-                        })
-                        : `Wait for ${trackerGoal} linked ${trackerGoal === 1 ? 'entity' : 'entities'} to complete`,
-                });
-                if (isDisqualify)
-                    isValid = false;
-            }
-            else {
-                if (isDisqualify)
-                    return { isValid: false, isComplete: false, percentCompleted: 0, availableClaimsNow: 0 };
-            }
-        }
-        if (conditions?.dynamicTracker?.conditions?.length) {
-            const resolvedConditions = (0, template_1.replaceDynamicConditionKeys)(conditions.dynamicTracker.conditions, playerOffer?.trackers || {});
-            // Convert { key: { value: X } } to { key: X } format
-            const primitiveTrackers = (0, dynamic_1.dynamicTrackerToPrimitive)(completionTrackers?.dynamicTracker || {});
-            const dynamicResult = meetsDynamicConditions(primitiveTrackers, {
-                ...conditions.dynamicTracker,
-                conditions: resolvedConditions,
-            }, claimMultiplier);
-            if (shouldScale) {
-                const dynamicMax = getMaxClaimsForDynamicGroup(primitiveTrackers, {
-                    ...conditions.dynamicTracker,
-                    conditions: resolvedConditions,
-                }, playerOffer?.trackers?.claimedCount || 0);
-                updateMax(dynamicMax);
-            }
-            if (addDetails) {
-                // Extract tracker amount and goal from the first condition for display
-                let trackerAmount;
-                let trackerGoal;
-                if (resolvedConditions.length > 0) {
-                    const firstCond = resolvedConditions[0];
-                    if (typeof firstCond.compareTo === 'number') {
-                        trackerGoal = firstCond.compareTo;
-                    }
-                    const val = primitiveTrackers[firstCond.key];
-                    trackerAmount = typeof val === 'number' ? val : 0;
-                }
-                // Calculate percentage using the dynamic group helper for AND/OR logic
-                const percentCompleted = calculateDynamicGroupPercent(primitiveTrackers, {
-                    ...conditions.dynamicTracker,
-                    conditions: resolvedConditions,
-                });
-                conditionData.push({
-                    isMet: dynamicResult,
-                    kind: 'dynamicTracker',
-                    trackerAmount,
-                    trackerGoal,
-                    percentCompleted,
-                    text: (0, template_1.renderTemplate)(
-                    // First resolve {{}} placeholders (e.g., {{surfacerPlayerId}}) using offer trackers
-                    (0, template_1.replaceDynamicConditionKey)(conditions.dynamicTracker.template || '', playerOffer?.trackers || {}), primitiveTrackers) || 'Dynamic conditions',
-                });
-                if (!dynamicResult)
-                    isValid = false;
-            }
-            else {
-                if (!dynamicResult)
-                    return { isValid: false, isComplete: false, percentCompleted: 0, availableClaimsNow: 0 };
-            }
-        }
-        // Evaluate contractInteractions completion trackers
-        if (conditions?.contractInteractions) {
-            const interactions = conditions.contractInteractions;
-            const entries = Array.isArray(interactions)
-                ? interactions.map((c) => [c.id || '', c])
-                : Object.entries(interactions);
-            for (const [conditionId, condition] of entries) {
-                // Tracker now stores { amount: number, count: number }
-                // Default to { amount: 0, count: 0 } if missing
-                const rawTracker = completionTrackers?.contractInteractions?.[conditionId];
-                const trackerData = rawTracker || { amount: 0, count: 0 };
-                const trackerAmount = trackerData.amount || 0;
-                const trackerCount = trackerData.count || 0;
-                // Goals
-                const minAmount = condition.minAmount ? condition.minAmount * claimMultiplier : 0;
-                const maxAmount = condition.maxAmount ? condition.maxAmount * claimMultiplier : undefined;
-                const minCount = condition.minCount ? condition.minCount * claimMultiplier : 0;
-                const maxCount = condition.maxCount ? condition.maxCount * claimMultiplier : undefined;
-                let isDisqualify = false;
-                // Check Amounts
-                if (shouldScale) {
-                    // If we have scaling (claimMultiplier), we handle max claims calculation differently
-                    // For now, assume standard validation
-                }
-                if (minAmount > 0 && trackerAmount < minAmount)
-                    isDisqualify = true;
-                if (maxAmount !== undefined && trackerAmount > maxAmount)
-                    isDisqualify = true;
-                // Check Counts
-                if (minCount > 0 && trackerCount < minCount)
-                    isDisqualify = true;
-                if (maxCount !== undefined && trackerCount > maxCount)
-                    isDisqualify = true;
-                if (shouldScale) {
-                    // Update max claims based on whatever allows the FEWEST claims
-                    // e.g. if I have enough Amount for 3 claims but enough Count for 1 claim, I can only make 1 claim.
-                    const possibleClaimsByAmount = condition.minAmount
-                        ? Math.floor(trackerAmount / condition.minAmount)
-                        : Number.MAX_SAFE_INTEGER;
-                    const possibleClaimsByCount = condition.minCount
-                        ? Math.floor(trackerCount / condition.minCount)
-                        : Number.MAX_SAFE_INTEGER;
-                    const possibleClaims = Math.min(possibleClaimsByAmount, possibleClaimsByCount);
-                    // Only update if we have at least ANY requirement (Amount or Count)
-                    // If both minAmount and minCount are 0/undefined, this logic might be weird, but usually one is set.
-                    if (condition.minAmount || condition.minCount) {
-                        updateMax(possibleClaims);
-                    }
-                }
-                if (addDetails) {
-                    // Determine primary metric for progress display 
-                    // If minAmount is set, use amount. Else use count.
-                    let current = trackerAmount;
-                    let goal = minAmount;
-                    let percent = 0;
-                    // If both are set, display percent based on the average of the two
-                    const hasMin = minAmount > 0 || minCount > 0;
-                    const hasMax = (maxAmount !== undefined && maxAmount > 0) || (maxCount !== undefined && maxCount > 0);
-                    if (!hasMin && hasMax) {
-                        // If only max is set: > 0 progress = 100%, else 0%
-                        const maxAmountSet = maxAmount !== undefined && maxAmount > 0;
-                        const maxCountSet = maxCount !== undefined && maxCount > 0;
-                        let pcts = [];
-                        if (maxAmountSet) {
-                            pcts.push(trackerAmount > 0 ? 100 : 0);
-                        }
-                        if (maxCountSet) {
-                            pcts.push(trackerCount > 0 ? 100 : 0);
-                        }
-                        if (pcts.length > 0) {
-                            percent = pcts.reduce((a, b) => a + b, 0) / pcts.length;
-                        }
-                        else {
-                            percent = 0;
-                        }
-                    }
-                    else if (minAmount > 0 && minCount > 0) {
-                        const pctAmount = calculatePercent(trackerAmount, minAmount, true); // clamp to 100
-                        const pctCount = calculatePercent(trackerCount, minCount, true);
-                        percent = (pctAmount + pctCount) / 2;
-                    }
-                    else if (minCount > 0) {
-                        current = trackerCount;
-                        goal = minCount;
-                        percent = calculatePercent(current, goal, !isDisqualify);
-                    }
-                    else {
-                        percent = calculatePercent(trackerAmount, minAmount || 0, !isDisqualify);
-                    }
-                    const displayText = (0, template_1.renderTemplate)(condition.template, {
-                        currentAmount: trackerAmount || 0,
-                        currentCount: trackerCount || 0,
-                        minAmount: minAmount || 0,
-                        maxAmount: maxAmount || 0,
-                        minCount: minCount || 0,
-                        maxCount: maxCount || 0,
-                    });
-                    conditionData.push({
-                        isMet: !isDisqualify,
-                        kind: 'contractInteractions',
-                        trackerAmount,
-                        percentCompleted: percent,
-                        text: displayText,
-                    });
-                    if (isDisqualify)
-                        isValid = false;
-                }
-                else {
-                    if (isDisqualify)
-                        return { isValid: false, isComplete: false, percentCompleted: 0, 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);
-        // Calculate top-level percentCompleted as average of all condition percentages
-        const percentCompleted = conditionData.length > 0
-            ? conditionData.reduce((sum, c) => sum + c.percentCompleted, 0) / conditionData.length
-            : isValid
-                ? 100
-                : 0;
-        return {
-            /** @deprecated Use isComplete instead */
-            isValid,
-            isComplete: isValid,
-            percentCompleted,
-            conditionData,
-            availableClaimsNow,
-        };
-    }
-    return { isValid: true, isComplete: true, percentCompleted: 100, 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.dynamic?.conditions?.length) {
-        if (wasUpdatedAfterExpiry())
-            return false;
-    }
-    if (completionConditions.identifiers?.platforms?.length) {
-        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;
-        }
-    }
-    // Tracker-based conditions: use completionTrackers.lastUpdated if available.
-    // Legacy offers without lastUpdated skip these checks (preserving current grace-period behavior).
-    if (completionTrackers?.lastUpdated != null) {
-        const trackerUpdatedAfterExpiry = wasUpdatedAfterExpiry(completionTrackers.lastUpdated);
-        if (trackerUpdatedAfterExpiry && (completionConditions.buyItem ||
-            completionConditions.spendCurrency ||
-            completionConditions.depositCurrency ||
-            completionConditions.context ||
-            completionConditions.linkedCompletions ||
-            completionConditions.contractInteractions))
-            return false;
-        if (completionConditions.dynamicTracker?.conditions?.length) {
-            for (const cond of completionConditions.dynamicTracker.conditions) {
-                const perKeyTs = completionTrackers.dynamicTracker?.[cond.key]?.lastUpdated;
-                if (wasUpdatedAfterExpiry(perKeyTs ?? completionTrackers.lastUpdated))
-                    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 (cond.operator === 'is_truthy')
-        return !!val;
-    if (cond.operator === 'is_falsy')
-        return !val;
-    if (cond.operator === 'is_defined')
-        return val != null;
-    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;
-    if (cond.operator === 'is_truthy')
-        return dynamicObj[cond.key] ? Infinity : 0;
-    if (cond.operator === 'is_falsy')
-        return !dynamicObj[cond.key] ? Infinity : 0;
-    if (cond.operator === 'is_defined')
-        return dynamicObj[cond.key] != null ? Infinity : 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