@stackedapp/utils 1.23.2 → 1.23.4

package/dist/conditions/handlers.js

@@ -0,0 +1,763 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateDaysInGame = evaluateDaysInGame;
+exports.evaluateTrustScore = evaluateTrustScore;
+exports.evaluateLevel = evaluateLevel;
+exports.evaluateCurrency = evaluateCurrency;
+exports.evaluateStakedTokens = evaluateStakedTokens;
+exports.evaluateLoginStreak = evaluateLoginStreak;
+exports.evaluateAchievement = evaluateAchievement;
+exports.evaluateMembership = evaluateMembership;
+exports.evaluateQuest = evaluateQuest;
+exports.evaluateEntityLink = evaluateEntityLink;
+exports.evaluateDynamic = evaluateDynamic;
+exports.evaluateIdentifiers = evaluateIdentifiers;
+exports.evaluateTokenBalance = evaluateTokenBalance;
+exports.evaluateStackedAccount = evaluateStackedAccount;
+exports.evaluateUserSettings = evaluateUserSettings;
+exports.evaluateCompletionContext = evaluateCompletionContext;
+exports.evaluateBuyItem = evaluateBuyItem;
+exports.evaluateSpendCurrency = evaluateSpendCurrency;
+exports.evaluateDepositCurrency = evaluateDepositCurrency;
+exports.evaluateLogin = evaluateLogin;
+exports.evaluateSocial = evaluateSocial;
+exports.evaluateLinkedCompletions = evaluateLinkedCompletions;
+exports.evaluateDynamicTracker = evaluateDynamicTracker;
+exports.evaluateContractInteraction = evaluateContractInteraction;
+const types_1 = require("@stackedapp/types");
+const template_1 = require("../template");
+const dynamic_1 = require("../dynamic");
+const helpers_1 = require("./helpers");
+const blockchain_utils_1 = require("../blockchain_utils");
+// ─── Base Condition Handlers ─────────────────────────────────────────────────
+function evaluateDaysInGame(cond, ctx) {
+    const details = [];
+    let isMet = true;
+    if (cond.min) {
+        const trackerAmount = ctx.snap.daysInGame || 0;
+        const trackerGoal = cond.min;
+        const met = trackerAmount >= trackerGoal;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'daysInGame', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: `More than ${trackerGoal} Days in Game`,
+        });
+    }
+    if (cond.max) {
+        const trackerAmount = ctx.snap.daysInGame || 0;
+        const met = trackerAmount <= cond.max;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'daysInGame', trackerAmount, trackerGoal: cond.max,
+            percentCompleted: met ? 100 : 0,
+            text: `Less than ${cond.max} Days in Game`,
+        });
+    }
+    return { isMet, details };
+}
+function evaluateTrustScore(cond, ctx) {
+    const details = [];
+    let isMet = true;
+    if (cond.min) {
+        const trackerAmount = ctx.snap.trustScore || 0;
+        const trackerGoal = cond.min;
+        const met = trackerAmount >= trackerGoal;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'trustScore', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: `More than ${trackerGoal} Rep`,
+        });
+    }
+    if (cond.max) {
+        const trackerAmount = ctx.snap.trustScore || 0;
+        const met = trackerAmount <= cond.max;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'trustScore', trackerAmount, trackerGoal: cond.max,
+            percentCompleted: met ? 100 : 0,
+            text: `Less than ${cond.max} Rep`,
+        });
+    }
+    return { isMet, details };
+}
+function evaluateLevel(cond, ctx) {
+    const playerLevelData = ctx.snap.levels?.[cond.id];
+    const details = [];
+    let isMet = true;
+    if (cond.min) {
+        const trackerAmount = playerLevelData?.level || 0;
+        const trackerGoal = cond.min;
+        const met = trackerAmount >= trackerGoal;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'level', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: `Be above level ${trackerGoal} ${cond.name}`,
+        });
+    }
+    if (cond.max) {
+        const trackerAmount = playerLevelData?.level || 0;
+        const met = trackerAmount <= cond.max;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'level', trackerAmount, trackerGoal: cond.max,
+            percentCompleted: met ? 100 : 0,
+            text: `Be under level ${cond.max} ${cond.name}`,
+        });
+    }
+    return { isMet, details };
+}
+function evaluateCurrency(cond, ctx) {
+    const playerCurrencyData = ctx.snap.currencies?.[cond.id];
+    const details = [];
+    let isMet = true;
+    if (cond.min) {
+        const trackerAmount = playerCurrencyData?.balance || 0;
+        const trackerGoal = cond.min;
+        const met = trackerAmount >= trackerGoal;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'currency', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: `Have more than ${trackerGoal} ${cond.name}`,
+        });
+    }
+    if (cond.max) {
+        const trackerAmount = playerCurrencyData?.balance || 0;
+        const met = trackerAmount <= cond.max;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'currency', trackerAmount, trackerGoal: cond.max,
+            percentCompleted: met ? 100 : 0,
+            text: `Have less than ${cond.max} ${cond.name}`,
+        });
+    }
+    if (cond.in) {
+        const trackerAmount = playerCurrencyData?.in || 0;
+        const trackerGoal = cond.in;
+        const met = trackerAmount >= trackerGoal;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'currency', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: `Deposit at least ${trackerGoal} ${cond.name}`,
+        });
+    }
+    if (cond.out) {
+        const trackerAmount = playerCurrencyData?.out || 0;
+        const trackerGoal = cond.out;
+        const met = trackerAmount >= trackerGoal;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'currency', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: `Withdraw at least ${trackerGoal} ${cond.name}`,
+        });
+    }
+    return { isMet, details };
+}
+function evaluateStakedTokens(cond, ctx) {
+    const playerStakedData = ctx.snap.stakedTokens?.[cond.id];
+    let isMet = true;
+    const details = [];
+    if (cond.min) {
+        const trackerAmount = playerStakedData?.balance || 0;
+        const trackerGoal = cond.min;
+        const met = trackerAmount >= trackerGoal;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'stakedTokens', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: `Have at least ${trackerGoal} ${cond.name} staked`,
+        });
+    }
+    return { isMet, details };
+}
+function evaluateLoginStreak(cond, ctx) {
+    let trackerAmount;
+    if (ctx.completionTrackers?.currentLoginStreak != null) {
+        // Completion context: streak gained since offer surfaced
+        trackerAmount = (ctx.snap.loginStreak || 0) - (ctx.completionTrackers.currentLoginStreak || 0) + 1;
+    }
+    else {
+        // Surfacing context: absolute streak
+        trackerAmount = ctx.snap.loginStreak || 0;
+    }
+    const trackerGoal = cond.days;
+    const isMet = trackerAmount >= trackerGoal;
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'loginStreak', trackerAmount, trackerGoal,
+                percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, isMet),
+                text: `Login streak of ${trackerGoal || 0} days`,
+            }],
+    };
+}
+function evaluateAchievement(cond, ctx) {
+    const playerAchData = ctx.snap.achievements?.[cond.id];
+    const details = [];
+    let isMet = true;
+    if (!playerAchData) {
+        isMet = false;
+        details.push({
+            isMet: false, kind: 'achievement', trackerAmount: 0, trackerGoal: 1,
+            percentCompleted: 0,
+            text: `Have the achievement ${cond.name}`,
+        });
+    }
+    if (cond.minCount) {
+        const trackerAmount = playerAchData?.count || 0;
+        const trackerGoal = cond.minCount;
+        const met = trackerAmount >= trackerGoal;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'achievement', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: `Have the achievement ${cond.name} more than ${trackerGoal} times`,
+        });
+    }
+    return { isMet, details };
+}
+function evaluateMembership(cond, ctx) {
+    const playerData = ctx.snap.memberships?.[cond.id];
+    const details = [];
+    let isMet = true;
+    if (cond.minCount) {
+        const trackerAmount = playerData?.count || 0;
+        const trackerGoal = cond.minCount;
+        const met = trackerAmount >= trackerGoal;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'membership', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: trackerGoal > 1 ? `Have at least ${trackerGoal} ${cond.name} memberships` : `Have a ${cond.name} membership`,
+        });
+    }
+    if (cond.maxCount) {
+        const trackerAmount = playerData?.count || 0;
+        const met = trackerAmount <= cond.maxCount;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'membership', trackerAmount, trackerGoal: cond.maxCount,
+            percentCompleted: met ? 100 : 0,
+            text: `Have less than ${cond.maxCount} ${cond.name} memberships`,
+        });
+    }
+    const timeOwned = (playerData?.expiresAt || 0) - Date.now();
+    if (cond.minMs) {
+        const trackerAmount = Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1));
+        const trackerGoal = Number((cond.minMs / (1000 * 60 * 60 * 24)).toFixed(1));
+        const met = timeOwned >= cond.minMs;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'membership', trackerAmount, trackerGoal,
+            percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, met),
+            text: `Own ${cond.name} membership for at least ${trackerGoal} days`,
+        });
+    }
+    if (cond.maxMs) {
+        const trackerAmount = Number((timeOwned / (1000 * 60 * 60 * 24)).toFixed(1));
+        const met = timeOwned <= cond.maxMs;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'membership', trackerAmount,
+            trackerGoal: Number((cond.maxMs / (1000 * 60 * 60 * 24)).toFixed(1)),
+            percentCompleted: met ? 100 : 0,
+            text: `Own ${cond.name} membership for less than ${(cond.maxMs / (1000 * 60 * 60 * 24)).toFixed(1)} days`,
+        });
+    }
+    return { isMet, details };
+}
+function evaluateQuest(cond, ctx) {
+    const playerQuestData = ctx.snap.quests?.[cond.id];
+    const trackerAmount = playerQuestData?.completions || 0;
+    const trackerGoal = cond.completions || 1;
+    const isMet = playerQuestData ? trackerAmount >= (cond.completions || 0) : false;
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'quest', trackerAmount, trackerGoal,
+                percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, isMet),
+                text: cond.completions === 1
+                    ? `Complete the quest ${cond.name}`
+                    : (cond.completions || 0) < 1
+                        ? `Start the quest ${cond.name}`
+                        : `Complete the quest ${cond.name} ${cond.completions} times`,
+            }],
+    };
+}
+function evaluateEntityLink(cond, ctx) {
+    const linkCount = ctx.snap.entityLinks?.filter((link) => (link.kind || types_1.DEFAULT_ENTITY_KIND) === cond.linkKind).length || 0;
+    const details = [];
+    let isMet = true;
+    const makeText = (fallback) => cond.template
+        ? (0, template_1.renderTemplate)(cond.template, {
+            current: linkCount, min: cond.min ?? 0, max: cond.max ?? 0, type: cond.linkKind,
+        })
+        : fallback;
+    if (cond.min !== undefined) {
+        const met = linkCount >= cond.min;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'entityLink', trackerAmount: linkCount, trackerGoal: cond.min,
+            percentCompleted: (0, helpers_1.calculatePercent)(linkCount, cond.min, met),
+            text: makeText(`At least ${cond.min} ${cond.linkKind} link(s)`),
+        });
+    }
+    if (cond.max !== undefined) {
+        const met = linkCount <= cond.max;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'entityLink', trackerAmount: linkCount, trackerGoal: cond.max,
+            percentCompleted: met ? 100 : 0,
+            text: makeText(`At most ${cond.max} ${cond.linkKind} link(s)`),
+        });
+    }
+    return { isMet, details };
+}
+function evaluateDynamic(cond, ctx) {
+    const resolvedConditions = (0, template_1.replaceDynamicConditionKeys)(cond.conditions, ctx.offerTrackers || {});
+    const dynamicObj = (ctx.snap.dynamic || {});
+    const dynamicResult = (0, helpers_1.meetsDynamicConditions)(dynamicObj, { ...cond, conditions: resolvedConditions });
+    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;
+    }
+    const percentCompleted = (0, helpers_1.calculateDynamicGroupPercent)(dynamicObj, { ...cond, conditions: resolvedConditions });
+    return {
+        isMet: dynamicResult,
+        details: [{
+                isMet: dynamicResult, kind: 'dynamic', trackerAmount, trackerGoal, percentCompleted,
+                text: (0, template_1.renderTemplate)((0, template_1.replaceDynamicConditionKey)(cond.template || '', ctx.offerTrackers || {}), dynamicObj) || 'Dynamic conditions',
+            }],
+    };
+}
+function evaluateIdentifiers(cond, ctx) {
+    const playerPlatforms = new Set(ctx.snap.identifiers?.map((i) => i.platform.toLowerCase()) || []);
+    const platformsToCheck = cond.platforms;
+    const platformsMap = {
+        sms: 'SMS', email: 'Email', apple: 'Apple', google: 'Google', tiktok: 'TikTok',
+    };
+    const metPlatforms = platformsToCheck.filter((p) => playerPlatforms.has(p.toLowerCase()));
+    const platforms = platformsToCheck.map((p) => platformsMap[p.toLowerCase()] ?? p);
+    let isMet;
+    let displayText;
+    let percentCompleted;
+    if (cond.behaviour === 'AND') {
+        isMet = metPlatforms.length === platformsToCheck.length;
+        displayText = platformsToCheck.length > 1
+            ? `Link your ${(0, helpers_1.formatList)(platforms)} accounts`
+            : `Link your ${platforms[0]} account`;
+        percentCompleted = (0, helpers_1.calculatePercent)(metPlatforms.length, platformsToCheck.length, isMet);
+    }
+    else if (cond.behaviour === 'NOT') {
+        isMet = metPlatforms.length === 0;
+        displayText = `Must not have ${(0, helpers_1.formatList)(platforms)} linked`;
+        percentCompleted = isMet ? 100 : 0;
+    }
+    else {
+        isMet = platformsToCheck.some((p) => playerPlatforms.has(p.toLowerCase()));
+        displayText = `Link any of your ${(0, helpers_1.formatList)(platforms)} accounts`;
+        percentCompleted = isMet ? 100 : 0;
+    }
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'identifiers',
+                trackerAmount: isMet ? 1 : 0, trackerGoal: 1,
+                percentCompleted,
+                text: displayText,
+            }],
+    };
+}
+function evaluateTokenBalance(cond, ctx) {
+    const contracts = cond.contracts || [];
+    let totalBalance = 0;
+    const fetchedBalances = (0, helpers_1.aggregateTokenBalances)(ctx.additionalData);
+    for (const contract of contracts) {
+        const balanceKey = (0, blockchain_utils_1.addressNetworkId)(contract.contractAddress, contract.network);
+        totalBalance += fetchedBalances[balanceKey] || 0;
+    }
+    const details = [];
+    let isMet = true;
+    if (cond.min !== undefined) {
+        const met = totalBalance >= cond.min;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'tokenBalance', trackerAmount: totalBalance, trackerGoal: cond.min,
+            percentCompleted: (0, helpers_1.calculatePercent)(totalBalance, cond.min, met),
+            text: `Have at least ${cond.min} ${cond.name || 'tokens'}`,
+        });
+    }
+    if (cond.max !== undefined) {
+        const met = totalBalance <= cond.max;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'tokenBalance', trackerAmount: totalBalance, trackerGoal: cond.max,
+            percentCompleted: met ? 100 : 0,
+            text: `Have at most ${cond.max} ${cond.name || 'tokens'}`,
+        });
+    }
+    return { isMet, details };
+}
+function evaluateStackedAccount(cond, ctx) {
+    const details = [];
+    let isMet = true;
+    if (cond.hasLinkedAccount !== undefined) {
+        const playerHasAccount = ctx.additionalData?.hasStackedAccount ?? false;
+        const met = cond.hasLinkedAccount === playerHasAccount;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'stackedAccount',
+            trackerAmount: playerHasAccount ? 1 : 0, trackerGoal: 1,
+            percentCompleted: met ? 100 : 0,
+            text: cond.hasLinkedAccount ? 'Link a Stacked account' : 'Must not have Stacked account linked',
+        });
+    }
+    if (cond.cryptoWallets) {
+        const walletCount = ctx.additionalData?.cryptoWallets?.length || 0;
+        if (cond.cryptoWallets.min !== undefined) {
+            const met = walletCount >= cond.cryptoWallets.min;
+            if (!met)
+                isMet = false;
+            details.push({
+                isMet: met, kind: 'stackedAccount',
+                trackerAmount: walletCount, trackerGoal: cond.cryptoWallets.min,
+                percentCompleted: (0, helpers_1.calculatePercent)(walletCount, cond.cryptoWallets.min, met),
+                text: `Link at least ${cond.cryptoWallets.min} crypto wallet${cond.cryptoWallets.min === 1 ? '' : 's'}`,
+            });
+        }
+        if (cond.cryptoWallets.max !== undefined) {
+            const met = walletCount <= cond.cryptoWallets.max;
+            if (!met)
+                isMet = false;
+            details.push({
+                isMet: met, kind: 'stackedAccount',
+                trackerAmount: walletCount, trackerGoal: cond.cryptoWallets.max,
+                percentCompleted: met ? 100 : 0,
+                text: `Have at most ${cond.cryptoWallets.max} crypto wallet${cond.cryptoWallets.max === 1 ? '' : 's'}`,
+            });
+        }
+    }
+    return { isMet, details };
+}
+function evaluateUserSettings(cond, ctx) {
+    const details = [];
+    let isMet = true;
+    if (cond.emailNewsletter !== undefined) {
+        const playerHasNewsletter = ctx.additionalData?.emailNewsletter ?? false;
+        const met = cond.emailNewsletter === playerHasNewsletter;
+        if (!met)
+            isMet = false;
+        details.push({
+            isMet: met, kind: 'userSettings',
+            trackerAmount: playerHasNewsletter ? 1 : 0, trackerGoal: 1,
+            percentCompleted: met ? 100 : 0,
+            text: cond.emailNewsletter ? 'Subscribe to email newsletter' : 'Must not be subscribed to email newsletter',
+        });
+    }
+    return { isMet, details };
+}
+// ─── Completion-Only Condition Handlers ──────────────────────────────────────
+function evaluateCompletionContext(cond, ctx) {
+    const hasTrackedContext = ctx.completionTrackers?.context && cond.id === ctx.completionTrackers.context;
+    const isMet = !!hasTrackedContext;
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'completionContext',
+                trackerAmount: isMet ? 1 : 0, trackerGoal: 1,
+                percentCompleted: isMet ? 100 : 0,
+                text: cond.name,
+            }],
+    };
+}
+function evaluateBuyItem(cond, ctx) {
+    const baseAmount = cond.amount || 1;
+    const scaledAmount = baseAmount * ctx.claimMultiplier;
+    const trackerValue = ctx.completionTrackers?.buyItem || 0;
+    const isMet = trackerValue >= scaledAmount;
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'buyItem', trackerAmount: trackerValue, trackerGoal: scaledAmount,
+                percentCompleted: (0, helpers_1.calculatePercent)(trackerValue, scaledAmount, isMet),
+                text: `Buy ${scaledAmount} ${cond.name}`,
+            }],
+        maxClaims: ctx.shouldScale && baseAmount > 0 ? Math.floor(trackerValue / baseAmount) : undefined,
+    };
+}
+function evaluateSpendCurrency(cond, ctx) {
+    const baseAmount = cond.amount || 1;
+    const scaledAmount = baseAmount * ctx.claimMultiplier;
+    const trackerValue = ctx.completionTrackers?.spendCurrency || 0;
+    const isMet = trackerValue >= scaledAmount;
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'spendCurrency', trackerAmount: trackerValue, trackerGoal: scaledAmount,
+                percentCompleted: (0, helpers_1.calculatePercent)(trackerValue, scaledAmount, isMet),
+                text: `Spend ${scaledAmount} ${cond.name}`,
+            }],
+        maxClaims: ctx.shouldScale && baseAmount > 0 ? Math.floor(trackerValue / baseAmount) : undefined,
+    };
+}
+function evaluateDepositCurrency(cond, ctx) {
+    const baseAmount = cond.amount || 1;
+    const scaledAmount = baseAmount * ctx.claimMultiplier;
+    const trackerValue = ctx.completionTrackers?.depositCurrency || 0;
+    const isMet = trackerValue >= scaledAmount;
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'depositCurrency', trackerAmount: trackerValue, trackerGoal: scaledAmount,
+                percentCompleted: (0, helpers_1.calculatePercent)(trackerValue, scaledAmount, isMet),
+                text: `Deposit ${scaledAmount} ${cond.name}`,
+            }],
+        maxClaims: ctx.shouldScale && baseAmount > 0 ? Math.floor(trackerValue / baseAmount) : undefined,
+    };
+}
+function evaluateLogin(_cond, ctx) {
+    const isMet = new Date(ctx.snap.snapshotLastUpdated || 0).getTime() > new Date(ctx.offerCreatedAt || 0).getTime();
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'login',
+                trackerAmount: isMet ? 1 : 0, trackerGoal: 1,
+                percentCompleted: isMet ? 100 : 0,
+                text: 'Login to the game',
+            }],
+    };
+}
+function evaluateSocial(cond, ctx) {
+    const tSocialAccumulate = ctx.completionTrackers?.social;
+    const tSocialAttach = ctx.completionTrackers?.social;
+    const mode = cond.mode || 'attach';
+    const tSocial = mode === 'accumulate' ? tSocialAccumulate : tSocialAttach;
+    const hasContent = Boolean(mode === 'accumulate' ? (tSocialAccumulate?.matchCount ?? 0) > 0 : tSocialAttach?.videoId);
+    const socialMultiplier = mode === 'accumulate' ? ctx.claimMultiplier : 1;
+    const minLikes = (cond.minLikes || 0) * socialMultiplier;
+    const minViews = (cond.minViews || 0) * socialMultiplier;
+    const minComments = (cond.minComments || 0) * socialMultiplier;
+    const likes = tSocial?.likes || 0;
+    const views = tSocial?.views || 0;
+    const comments = tSocial?.comments || 0;
+    let isMet = hasContent;
+    if (likes < minLikes || views < minViews || comments < minComments)
+        isMet = false;
+    // Max claims for accumulate mode
+    let maxClaims;
+    if (ctx.shouldScale && mode === 'accumulate' && hasContent) {
+        let mc = Infinity;
+        if (cond.minLikes && cond.minLikes > 0)
+            mc = Math.min(mc, Math.floor(likes / cond.minLikes));
+        if (cond.minViews && cond.minViews > 0)
+            mc = Math.min(mc, Math.floor(views / cond.minViews));
+        if (cond.minComments && cond.minComments > 0)
+            mc = Math.min(mc, Math.floor(comments / cond.minComments));
+        if (mc !== Infinity)
+            maxClaims = mc;
+    }
+    // Calculate social percentage - average of applicable metrics
+    const socialPercentages = [];
+    if (minLikes > 0)
+        socialPercentages.push((0, helpers_1.calculatePercent)(likes, minLikes, likes >= minLikes));
+    if (minViews > 0)
+        socialPercentages.push((0, helpers_1.calculatePercent)(views, minViews, views >= minViews));
+    if (minComments > 0)
+        socialPercentages.push((0, helpers_1.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;
+    const platformMap = { tiktok: 'TikTok', instagram: 'Instagram', youtube: 'YouTube' };
+    const platformText = cond.platforms.map((p) => platformMap[p] || p).join(' | ');
+    const requiredWords = cond.requiredWords ?? [];
+    const details = [];
+    if (mode === 'accumulate') {
+        const matchCount = tSocialAccumulate?.matchCount || 0;
+        details.push({
+            isMet: hasContent && isMet, 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;
+        details.push({
+            isMet: hasContent && isMet, 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) {
+        details.push({
+            isMet: hasContent && likes >= minLikes, kind: 'social',
+            trackerAmount: likes, trackerGoal: minLikes,
+            percentCompleted: (0, helpers_1.calculatePercent)(likes, minLikes, hasContent && likes >= minLikes),
+            text: mode === 'accumulate' ? `Combined ${minLikes} Likes` : `Reach ${minLikes} Likes`,
+        });
+    }
+    if (minViews > 0) {
+        details.push({
+            isMet: hasContent && views >= minViews, kind: 'social',
+            trackerAmount: views, trackerGoal: minViews,
+            percentCompleted: (0, helpers_1.calculatePercent)(views, minViews, hasContent && views >= minViews),
+            text: mode === 'accumulate' ? `Combined ${minViews} Views` : `Reach ${minViews} Views`,
+        });
+    }
+    if (minComments > 0) {
+        details.push({
+            isMet: hasContent && comments >= minComments, kind: 'social',
+            trackerAmount: comments, trackerGoal: minComments,
+            percentCompleted: (0, helpers_1.calculatePercent)(comments, minComments, hasContent && comments >= minComments),
+            text: mode === 'accumulate' ? `Combined ${minComments} Comments` : `Reach ${minComments} Comments`,
+        });
+    }
+    return { isMet, details, maxClaims };
+}
+function evaluateLinkedCompletions(cond, ctx) {
+    const baseMin = cond.min;
+    const trackerAmount = ctx.completionTrackers?.linkedCompletions || 0;
+    const trackerGoal = baseMin * ctx.claimMultiplier;
+    const isMet = trackerAmount >= trackerGoal;
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'linkedCompletions', trackerAmount, trackerGoal,
+                percentCompleted: (0, helpers_1.calculatePercent)(trackerAmount, trackerGoal, isMet),
+                text: cond.template
+                    ? (0, template_1.renderTemplate)(cond.template, { current: trackerAmount, required: trackerGoal })
+                    : `Wait for ${trackerGoal} linked ${trackerGoal === 1 ? 'entity' : 'entities'} to complete`,
+            }],
+        maxClaims: ctx.shouldScale && baseMin > 0 ? Math.floor(trackerAmount / baseMin) : undefined,
+    };
+}
+function evaluateDynamicTracker(cond, ctx) {
+    const resolvedConditions = (0, template_1.replaceDynamicConditionKeys)(cond.conditions, ctx.offerTrackers || {});
+    const primitiveTrackers = (0, dynamic_1.dynamicTrackerToPrimitive)(ctx.completionTrackers?.dynamicTracker || {});
+    const dynamicResult = (0, helpers_1.meetsDynamicConditions)(primitiveTrackers, { ...cond, conditions: resolvedConditions }, ctx.claimMultiplier);
+    let maxClaims;
+    if (ctx.shouldScale) {
+        maxClaims = (0, helpers_1.getMaxClaimsForDynamicGroup)(primitiveTrackers, { ...cond, conditions: resolvedConditions }, ctx.offerTrackers?.claimedCount || 0);
+    }
+    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;
+    }
+    const percentCompleted = (0, helpers_1.calculateDynamicGroupPercent)(primitiveTrackers, {
+        ...cond, conditions: resolvedConditions,
+    });
+    return {
+        isMet: dynamicResult,
+        details: [{
+                isMet: dynamicResult, kind: 'dynamicTracker', trackerAmount, trackerGoal, percentCompleted,
+                text: (0, template_1.renderTemplate)((0, template_1.replaceDynamicConditionKey)(cond.template || '', ctx.offerTrackers || {}), primitiveTrackers) || 'Dynamic conditions',
+            }],
+        maxClaims,
+    };
+}
+function evaluateContractInteraction(cond, ctx) {
+    const rawTracker = ctx.completionTrackers?.contractInteractions?.[cond.id];
+    const trackerData = rawTracker || { amount: 0, count: 0 };
+    const trackerAmount = trackerData.amount || 0;
+    const trackerCount = trackerData.count || 0;
+    const minAmount = cond.minAmount ? cond.minAmount * ctx.claimMultiplier : 0;
+    const maxAmount = cond.maxAmount ? cond.maxAmount * ctx.claimMultiplier : undefined;
+    const minCount = cond.minCount ? cond.minCount * ctx.claimMultiplier : 0;
+    const maxCount = cond.maxCount ? cond.maxCount * ctx.claimMultiplier : undefined;
+    let isMet = true;
+    if (minAmount > 0 && trackerAmount < minAmount)
+        isMet = false;
+    if (maxAmount !== undefined && trackerAmount > maxAmount)
+        isMet = false;
+    if (minCount > 0 && trackerCount < minCount)
+        isMet = false;
+    if (maxCount !== undefined && trackerCount > maxCount)
+        isMet = false;
+    let maxClaims;
+    if (ctx.shouldScale && (cond.minAmount || cond.minCount)) {
+        const byAmount = cond.minAmount ? Math.floor(trackerAmount / cond.minAmount) : Number.MAX_SAFE_INTEGER;
+        const byCount = cond.minCount ? Math.floor(trackerCount / cond.minCount) : Number.MAX_SAFE_INTEGER;
+        maxClaims = Math.min(byAmount, byCount);
+    }
+    // Calculate display percentage
+    const hasMin = minAmount > 0 || minCount > 0;
+    const hasMax = (maxAmount !== undefined && maxAmount > 0) || (maxCount !== undefined && maxCount > 0);
+    let percent = 0;
+    if (!hasMin && hasMax) {
+        const pcts = [];
+        if (maxAmount !== undefined && maxAmount > 0)
+            pcts.push(trackerAmount > 0 ? 100 : 0);
+        if (maxCount !== undefined && maxCount > 0)
+            pcts.push(trackerCount > 0 ? 100 : 0);
+        percent = pcts.length > 0 ? pcts.reduce((a, b) => a + b, 0) / pcts.length : 0;
+    }
+    else if (minAmount > 0 && minCount > 0) {
+        percent = ((0, helpers_1.calculatePercent)(trackerAmount, minAmount, true) + (0, helpers_1.calculatePercent)(trackerCount, minCount, true)) / 2;
+    }
+    else if (minCount > 0) {
+        percent = (0, helpers_1.calculatePercent)(trackerCount, minCount, isMet);
+    }
+    else {
+        percent = (0, helpers_1.calculatePercent)(trackerAmount, minAmount || 0, isMet);
+    }
+    return {
+        isMet,
+        details: [{
+                isMet, kind: 'contractInteraction', trackerAmount,
+                percentCompleted: percent,
+                text: (0, template_1.renderTemplate)(cond.template, {
+                    currentAmount: trackerAmount || 0, currentCount: trackerCount || 0,
+                    minAmount: minAmount || 0, maxAmount: maxAmount || 0,
+                    minCount: minCount || 0, maxCount: maxCount || 0,
+                }),
+            }],
+        maxClaims,
+    };
+}
+//# sourceMappingURL=handlers.js.map