dgc-core 2.0.5 → 2.0.8

package/dist/giveaways/giveaway-repository.js

@@ -9,6 +9,7 @@ const node_crypto_1 = require("node:crypto");
 const mongodb_1 = require("mongodb");
 const entry_id_1 = require("./entry-id");
 const api_pagination_1 = require("./api-pagination");
+const eligibility_1 = require("./eligibility");
 const domain_1 = require("./domain");
 const schemas_1 = require("./schemas");
 const projection = { entryVersion: 0 };
@@ -129,9 +130,10 @@ function filterCategory(filter, params) {
 }
 /** Each method reads only its own records. Transactions contain related writes only. */
 class GiveawayRepository {
-    constructor(db, client) {
+    constructor(db, client, options = {}) {
         this.db = db;
         this.client = client;
+        this.options = options;
     }
     get giveaways() {
         return this.db.collection('giveaways');
@@ -151,6 +153,111 @@ class GiveawayRepository {
     get activity() {
         return this.db.collection('audit');
     }
+    async checkCreditCandidate(entry) {
+        const check = this.options.checkCreditEligibility;
+        if (!check)
+            throw new domain_1.DomainError('RevenueCat entitlement verification is not configured', 503);
+        if (typeof entry.userId !== 'string' ||
+            !entry.userId ||
+            entry.userId.length > 128 ||
+            /[.#$[\]/]/.test(entry.userId))
+            throw new domain_1.DomainError('The entrant has no valid DGC account identity', 503);
+        let evidence;
+        try {
+            evidence = await check(entry.userId);
+        }
+        catch {
+            throw new domain_1.DomainError('Unable to verify active membership. Try again.', 503);
+        }
+        if (evidence === null)
+            return null;
+        if (!evidence ||
+            evidence.userId !== entry.userId ||
+            typeof evidence.entitlementId !== 'string' ||
+            !evidence.entitlementId.trim() ||
+            evidence.entitlementId.length > 255 ||
+            !(0, eligibility_1.isGiveawayMemberEligible)(giveaway_2.GiveawayCategory.Credits, evidence.collectorType) ||
+            typeof evidence.checkedAt !== 'string' ||
+            !Number.isFinite(Date.parse(evidence.checkedAt)) ||
+            Date.parse(evidence.checkedAt) > Date.now() + 5000 ||
+            (evidence.expiresAt !== null &&
+                (typeof evidence.expiresAt !== 'number' || !Number.isFinite(evidence.expiresAt))))
+            throw new domain_1.DomainError('Unable to verify active membership. Try again.', 503);
+        this.assertFreshCreditEvidence(evidence);
+        return {
+            userId: evidence.userId,
+            checkedAt: evidence.checkedAt,
+            entitlementId: evidence.entitlementId,
+            collectorType: evidence.collectorType,
+            expiresAt: evidence.expiresAt
+        };
+    }
+    assertFreshCreditEvidence(evidence) {
+        if (Date.now() - Date.parse(evidence.checkedAt) > 60000 ||
+            (evidence.expiresAt !== null && evidence.expiresAt <= Date.now()))
+            throw new domain_1.DomainError('Entitlement verification expired. Review and try again.', 409);
+    }
+    assertVerifiedCreditCandidate(g, reviewed, entry, verified) {
+        if (g.category !== reviewed.category || g.revision !== reviewed.revision)
+            throw new domain_1.DomainError('Giveaway changed. Review the selection again.', 409);
+        if (g.category !== giveaway_2.GiveawayCategory.Credits)
+            return;
+        if (!verified || verified.entryId !== entry._id || verified.evidence.userId !== entry.userId)
+            throw new domain_1.DomainError('Active membership must be verified before awarding credits', 503);
+        this.assertFreshCreditEvidence(verified.evidence);
+    }
+    async verifiedCreditSelection(g, input) {
+        if ((0, domain_1.effectiveStatus)(g) !== giveaway_2.GiveawayStatus.Closed)
+            throw new domain_1.DomainError('Close entries before selecting a winner', 409);
+        if (g.revision !== input.revision)
+            throw new domain_1.DomainError('Giveaway changed. Refresh before selecting.', 409);
+        if (g.selection ||
+            (await this.winners.findOne({ giveawayId: g._id, replacedAt: null }, { projection: { _id: 1 } })))
+            throw new domain_1.DomainError('A winner is already selected. Explicitly reset the selection to change it.', 409);
+        const maxAttempts = this.options.creditWinnerMaxAttempts ?? 5;
+        if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 100)
+            throw new domain_1.DomainError('Credit winner attempts must be an integer between 1 and 100', 503);
+        const tiers = (0, eligibility_1.giveawayEligibleCollectorTypes)(giveaway_2.GiveawayCategory.Credits);
+        const rejected = [];
+        const deadline = Date.now() + 30000;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            if (Date.now() >= deadline)
+                throw new domain_1.DomainError('Membership verification is taking too long. Try the draw again.', 503);
+            const eligible = {
+                giveawayId: g._id,
+                _collectorType: { $in: [...tiers] },
+                ...(rejected.length > 0 && { _id: { $nin: rejected } })
+            };
+            const count = await this.entries.countDocuments(eligible, {});
+            if (!count)
+                throw new domain_1.DomainError('This giveaway has no entries with an active eligible entitlement', 409);
+            const entry = input.method === giveaway_2.GiveawaySelectionMethod.Manual
+                ? await this.entries.findOne({ ...eligible, _id: input.entryId }, {})
+                : await this.entries
+                    .find(eligible, {
+                    projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 }
+                })
+                    .sort({ _id: 1 })
+                    .skip((0, node_crypto_1.randomInt)(count))
+                    .limit(1)
+                    .next();
+            if (!entry)
+                throw new domain_1.DomainError('Select a valid entry in this giveaway', 422);
+            if (!(0, eligibility_1.isGiveawayMemberEligible)(g.category, entry._collectorType))
+                throw new domain_1.DomainError('This entry is not eligible for the giveaway prize', 403);
+            const evidence = await this.checkCreditCandidate(entry);
+            if (Date.now() >= deadline)
+                throw new domain_1.DomainError('Membership verification is taking too long. Try the draw again.', 503);
+            if (evidence)
+                return { entryId: entry._id, evidence, skipped: rejected.length };
+            if (input.method === giveaway_2.GiveawaySelectionMethod.Manual)
+                throw new domain_1.DomainError('This entrant has no active Rookie, Collector or Elite entitlement', 422);
+            rejected.push(entry._id);
+            if (count === 1)
+                throw new domain_1.DomainError('This giveaway has no entries with an active eligible entitlement', 409);
+        }
+        throw new domain_1.DomainError(`No verified winner found after checking ${maxAttempts} candidate${maxAttempts === 1 ? '' : 's'}. Try the draw again.`, 503);
+    }
     async transaction(operation) {
         const session = this.client.startSession();
         try {
@@ -579,6 +686,49 @@ class GiveawayRepository {
                 { $sort: { _id: -1 } },
                 { $skip: skip },
                 { $limit: limit },
+                {
+                    $lookup: {
+                        from: 'notification_deliveries',
+                        let: { notification: { $toString: '$_id' } },
+                        pipeline: [
+                            { $match: { $expr: { $eq: ['$notificationId', '$$notification'] } } },
+                            {
+                                $group: {
+                                    _id: null,
+                                    queued: {
+                                        $sum: {
+                                            $cond: [
+                                                { $eq: ['$status', giveaway_2.GiveawayNotificationDeliveryStatus.Queued] },
+                                                1,
+                                                0
+                                            ]
+                                        }
+                                    },
+                                    skipped: {
+                                        $sum: {
+                                            $cond: [
+                                                { $eq: ['$status', giveaway_2.GiveawayNotificationDeliveryStatus.Skipped] },
+                                                1,
+                                                0
+                                            ]
+                                        }
+                                    },
+                                    pending: {
+                                        $sum: {
+                                            $cond: [
+                                                { $eq: ['$status', giveaway_2.GiveawayNotificationDeliveryStatus.Pending] },
+                                                1,
+                                                0
+                                            ]
+                                        }
+                                    }
+                                }
+                            },
+                            { $project: { _id: 0, queued: 1, skipped: 1, pending: 1 } }
+                        ],
+                        as: 'deliveryTotals'
+                    }
+                },
                 {
                     $lookup: {
                         from: 'giveaways',
@@ -594,10 +744,13 @@ class GiveawayRepository {
                     $set: {
                         giveawayTitle: {
                             $ifNull: [{ $first: '$campaign.title' }, '$giveawayId']
+                        },
+                        deliveryCounts: {
+                            $ifNull: [{ $first: '$deliveryTotals' }, { queued: 0, skipped: 0, pending: 0 }]
                         }
                     }
                 },
-                { $unset: ['campaign', 'claimToken'] },
+                { $unset: ['campaign', 'claimToken', 'deliveryTotals'] },
                 stringId
             ])
                 .toArray(),
@@ -741,6 +894,20 @@ class GiveawayRepository {
     }
     async confirmWinners(actor, id, raw) {
         const input = schemas_1.assignmentsSchema.parse(raw);
+        const reviewed = await this.getGiveaway(id);
+        let verified;
+        if (reviewed.category === giveaway_2.GiveawayCategory.Credits) {
+            const rows = await this.entries
+                .find({ giveawayId: id, _id: { $in: input.assignments.map(a => a.entryId) } }, { projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 } })
+                .limit(1)
+                .toArray();
+            const existing = await this.winners.findOne({ giveawayId: id, replacedAt: null }, { projection: { _id: 1 } });
+            (0, domain_1.confirmWinners)(reviewed, rows, !!existing, actor, input);
+            const evidence = await this.checkCreditCandidate(rows[0]);
+            if (!evidence)
+                throw new domain_1.DomainError('This entrant has no active Rookie, Collector or Elite entitlement', 422);
+            verified = { entryId: rows[0]._id, evidence, skipped: 0 };
+        }
         return this.transaction(async (session) => {
             const g = await this.getGiveaway(id, session);
             const rows = await this.entries
@@ -749,17 +916,25 @@ class GiveawayRepository {
                 _id: { $in: input.assignments.map(a => a.entryId) }
             }, {
                 session,
-                projection: { _id: 1, userId: 1, giveawayId: 1 }
+                projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 }
             })
                 .limit(1000)
                 .toArray();
             const entries = rows;
             const existing = await this.winners.findOne({ giveawayId: id, replacedAt: null }, { session, projection: { _id: 1 } });
             const winners = (0, domain_1.confirmWinners)(g, entries, !!existing, actor, input);
+            this.assertVerifiedCreditCandidate(g, reviewed, entries[0], verified);
+            if (verified)
+                winners[0].creditEligibility = verified.evidence;
             await this.updateGiveaway({ ...g, status: giveaway_2.GiveawayStatus.AwaitingClaim, revision: g.revision + 1 }, g.revision, session);
             const result = await this.winners.insertMany(winners.map(winner => ({ ...winner })), { session });
-            await this.enqueueEvent(g, giveaway_2.GiveawayNotificationKind.Results, 'results:' + result.insertedIds[0].toHexString(), session);
-            await this.audit(actor, 'Winners confirmed', id, winners.length + ' prize assignments', session);
+            await this.enqueueEvent(g, giveaway_2.GiveawayNotificationKind.Results, 'results:' + result.insertedIds[0].toHexString(), session, winners[0].claimDeadline);
+            await this.audit(actor, 'Winners confirmed', id, verified
+                ? JSON.stringify({
+                    prizeAssignments: winners.length,
+                    creditEligibility: verified.evidence
+                })
+                : winners.length + ' prize assignments', session);
             return winners.map((winner, index) => ({
                 ...winner,
                 _id: result.insertedIds[index].toHexString()
@@ -767,22 +942,52 @@ class GiveawayRepository {
         });
     }
     async replaceWinner(actor, id, winnerId, replacementEntryId, reason) {
+        const reviewed = await this.getGiveaway(id);
+        let verified;
+        if (reviewed.category === giveaway_2.GiveawayCategory.Credits) {
+            const previous = await this.winners.findOne({
+                _id: objectId(winnerId),
+                giveawayId: id,
+                replacedAt: null
+            });
+            const entry = await this.entries.findOne({ _id: schemas_1.entryIdSchema.parse(replacementEntryId), giveawayId: id }, { projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 } });
+            if (!previous || !entry)
+                throw new domain_1.DomainError('Winner or entrant not found', 404);
+            const existing = await this.winners.findOne({ giveawayId: id, entryId: replacementEntryId, replacedAt: null }, { projection: { _id: 1 } });
+            (0, domain_1.replaceWinner)(reviewed, serialize(previous), entry, !!existing, actor, reason);
+            const evidence = await this.checkCreditCandidate(entry);
+            if (!evidence)
+                throw new domain_1.DomainError('This entrant has no active Rookie, Collector or Elite entitlement', 422);
+            verified = { entryId: entry._id, evidence, skipped: 0 };
+        }
         return this.transaction(async (session) => {
             const g = await this.getGiveaway(id, session);
             const previousWinner = await this.winners.findOne({ _id: objectId(winnerId), giveawayId: id, replacedAt: null }, { session });
-            const entrant = await this.entries.findOne({ _id: schemas_1.entryIdSchema.parse(replacementEntryId), giveawayId: id }, { session, projection: { _id: 1, giveawayId: 1 } });
+            const entrant = await this.entries.findOne({ _id: schemas_1.entryIdSchema.parse(replacementEntryId), giveawayId: id }, { session, projection: { _id: 1, userId: 1, giveawayId: 1, _collectorType: 1 } });
             if (!previousWinner || !entrant)
                 throw new domain_1.DomainError('Winner or entrant not found', 404);
             const old = serialize(previousWinner);
             const entry = entrant;
             const existing = await this.winners.findOne({ giveawayId: id, entryId: replacementEntryId, replacedAt: null }, { session, projection: { _id: 1 } });
             const { previous, replacement } = (0, domain_1.replaceWinner)(g, old, entry, !!existing, actor, reason);
+            this.assertVerifiedCreditCandidate(g, reviewed, entry, verified);
+            replacement.userId = entry.userId;
+            if (verified) {
+                replacement.creditEligibility = verified.evidence;
+                replacement.selection.creditEligibility = verified.evidence;
+            }
             await this.updateGiveaway({ ...g, status: giveaway_2.GiveawayStatus.AwaitingClaim, revision: g.revision + 1 }, g.revision, session);
             const { _id, ...previousFields } = previous;
             await this.winners.updateOne({ _id: objectId(_id), replacedAt: null }, { $set: previousFields }, { session });
             const result = await this.winners.insertOne({ ...replacement }, { session });
-            await this.enqueueEvent(g, giveaway_2.GiveawayNotificationKind.Results, 'results:' + result.insertedId.toHexString(), session);
-            await this.audit(actor, 'Winner replaced', id, old._id + ': ' + reason.trim(), session);
+            await this.enqueueEvent(g, giveaway_2.GiveawayNotificationKind.Results, 'results:' + result.insertedId.toHexString(), session, replacement.claimDeadline);
+            await this.audit(actor, 'Winner replaced', id, verified
+                ? JSON.stringify({
+                    previousWinnerId: old._id,
+                    reason: reason.trim(),
+                    creditEligibility: verified.evidence
+                })
+                : old._id + ': ' + reason.trim(), session);
             return { ...replacement, _id: result.insertedId.toHexString() };
         });
     }
@@ -818,7 +1023,7 @@ class GiveawayRepository {
             return winner;
         });
     }
-    async enqueueEvent(g, kind, eventKey, session) {
+    async enqueueEvent(g, kind, eventKey, session, expiresAt) {
         const copy = g.reminders?.[kind];
         if (!copy?.enabled)
             return;
@@ -828,6 +1033,11 @@ class GiveawayRepository {
                 eventKey,
                 kind,
                 audience: giveaway_2.GiveawayNotificationAudience.Entrants,
+                category: g.category,
+                expiresAt: kind === giveaway_2.GiveawayNotificationKind.Closing
+                    ? g.closesAt
+                    : expiresAt ||
+                        new Date(Date.now() + (g.claimWindowDays || 14) * 86400000).toISOString(),
                 title: copy.title,
                 message: copy.message,
                 status: giveaway_2.GiveawayNotificationStatus.Pending,
@@ -837,6 +1047,10 @@ class GiveawayRepository {
     }
     async selectWinner(actor, id, raw) {
         const input = schemas_1.selectionSchema.parse(raw);
+        const reviewed = await this.getGiveaway(id);
+        const verified = reviewed.category === giveaway_2.GiveawayCategory.Credits
+            ? await this.verifiedCreditSelection(reviewed, input)
+            : undefined;
         return this.transaction(async (session) => {
             const g = await this.getGiveaway(id, session);
             if ((0, domain_1.effectiveStatus)(g) !== giveaway_2.GiveawayStatus.Closed)
@@ -846,29 +1060,47 @@ class GiveawayRepository {
             if (g.selection ||
                 (await this.winners.findOne({ giveawayId: id, replacedAt: null }, { session })))
                 throw new domain_1.DomainError('A winner is already selected. Explicitly reset the selection to change it.', 409);
-            const count = await this.entries.countDocuments({ giveawayId: id }, { session });
+            const collectorTypes = (0, eligibility_1.giveawayEligibleCollectorTypes)(g.category);
+            const eligible = {
+                giveawayId: id,
+                ...(collectorTypes !== null && { _collectorType: { $in: [...collectorTypes] } })
+            };
+            const count = verified ? 1 : await this.entries.countDocuments(eligible, { session });
             if (!count)
                 throw new domain_1.DomainError('This giveaway has no eligible entries', 409);
-            const entry = input.method === giveaway_2.GiveawaySelectionMethod.Manual
-                ? await this.entries.findOne({ giveawayId: id, _id: input.entryId }, { session })
+            const candidateId = verified?.entryId ||
+                (input.method === giveaway_2.GiveawaySelectionMethod.Manual ? input.entryId : undefined);
+            const entry = candidateId
+                ? await this.entries.findOne({ ...eligible, _id: candidateId }, { session })
                 : await this.entries
-                    .find({ giveawayId: id }, { session })
+                    .find(eligible, { session })
                     .sort({ _id: 1 })
                     .skip((0, node_crypto_1.randomInt)(count))
                     .limit(1)
                     .next();
             if (!entry)
                 throw new domain_1.DomainError('Select a valid entry in this giveaway', 422);
+            if (!(0, eligibility_1.isGiveawayMemberEligible)(g.category, entry._collectorType))
+                throw new domain_1.DomainError('This entry is not eligible for the giveaway prize', 403);
+            this.assertVerifiedCreditCandidate(g, reviewed, entry, verified);
             const selection = {
                 entryId: entry._id,
                 method: input.method,
                 reason: input.method === giveaway_2.GiveawaySelectionMethod.Manual ? input.reason : '',
                 selectedBy: actor,
-                selectedAt: new Date().toISOString()
+                selectedAt: new Date().toISOString(),
+                ...(verified && { creditEligibility: verified.evidence })
             };
             const updated = { ...g, selection, revision: g.revision + 1 };
             await this.updateGiveaway(updated, g.revision, session);
-            await this.audit(actor, 'Winner selected: ' + input.method, id, entry._id + (selection.reason ? ': ' + selection.reason : ''), session);
+            await this.audit(actor, 'Winner selected: ' + input.method, id, verified
+                ? JSON.stringify({
+                    entryId: entry._id,
+                    reason: selection.reason,
+                    creditEligibility: verified.evidence,
+                    skippedIneligibleEntries: verified.skipped
+                })
+                : entry._id + (selection.reason ? ': ' + selection.reason : ''), session);
             return { giveaway: updated, entry: normalizeEntry(entry) };
         });
     }
@@ -930,7 +1162,7 @@ class GiveawayRepository {
                     category: giveaway_2.GiveawayCategory.Credits,
                     creditAmount: amount,
                     countries: [],
-                    rules: 'One ticket per DGC account. All members have equal chances. One winner. The winner must claim within the stated claim window.',
+                    rules: 'One ticket per eligible DGC account. Eligible members have equal chances. One winner. The winner must claim within the stated claim window.',
                     deliveryInformation: '',
                     revision: 1,
                     createdAt: now,
@@ -1263,7 +1495,11 @@ class GiveawayRepository {
             const now = new Date().toISOString();
             const updated = await this.notifications.updateOne(filter, successful
                 ? {
-                    $set: { status: giveaway_2.GiveawayNotificationStatus.Sent, sentAt: now },
+                    $set: {
+                        status: giveaway_2.GiveawayNotificationStatus.Sent,
+                        sentAt: now,
+                        dispatchCompletedAt: now
+                    },
                     $unset: { error: '', claimToken: '' }
                 }
                 : {

package/dist/giveaways/index.d.ts

@@ -2,6 +2,7 @@
 export * from './domain';
 export * from './api-pagination';
 export * from './entry-id';
+export * from './eligibility';
 export * from './giveaway-repository';
 export * from './schemas';
 export * from './credit-award';

package/dist/giveaways/index.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./domain"), exports);
 __exportStar(require("./api-pagination"), exports);
 __exportStar(require("./entry-id"), exports);
+__exportStar(require("./eligibility"), exports);
 __exportStar(require("./giveaway-repository"), exports);
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./credit-award"), exports);

package/dist/index.d.ts

@@ -2,8 +2,6 @@ export * from './types';
 export * from './db/mongo';
 export * from './db/mongo2';
 export * from './db/mongo3';
-export * from './tw/utils';
-export * from './tw/wallet';
 export * from './auth';
 export * from './chunk';
 export * from './env';
@@ -20,3 +18,5 @@ export * from './validator';
 export * from './id';
 export * from './http-error';
 export * from './giveaways';
+export * from './constants/revenuecat';
+export * from './revenuecat';

package/dist/index.js

@@ -18,8 +18,6 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./db/mongo"), exports);
 __exportStar(require("./db/mongo2"), exports);
 __exportStar(require("./db/mongo3"), exports);
-__exportStar(require("./tw/utils"), exports);
-__exportStar(require("./tw/wallet"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./chunk"), exports);
 __exportStar(require("./env"), exports);
@@ -36,3 +34,5 @@ __exportStar(require("./validator"), exports);
 __exportStar(require("./id"), exports);
 __exportStar(require("./http-error"), exports);
 __exportStar(require("./giveaways"), exports);
+__exportStar(require("./constants/revenuecat"), exports);
+__exportStar(require("./revenuecat"), exports);

package/dist/pub.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.publishMessage = publishMessage;
 // src/pub.ts
 const pubsub_1 = require("@google-cloud/pubsub");
+const logger_1 = require("./logger");
 let cachedPubSub = null;
 function getPubSub(projectId) {
     if (!projectId)
@@ -26,11 +27,11 @@ async function publishMessage(projectId, topicName, envelope) {
         const messageId = await topic.publishMessage({
             data
         });
-        console.info(`INFO: Pub/Sub publish topic=${topicName} msg_id=${messageId}`);
+        (0, logger_1.log)(logger_1.LogLevel.INFO, 'Pub/Sub publish', { topicName, messageId });
         return messageId;
     }
     catch (err) {
-        console.error('ERROR: publish failed:', err);
+        (0, logger_1.log)(logger_1.LogLevel.ERROR, 'publish failed', { error: err });
         throw err;
     }
 }

package/dist/revenuecat.d.ts

@@ -0,0 +1,16 @@
+import { HttpError } from './http-error';
+import type { GiveawayCreditEligibilityEvidence, RevenueCatClient, RevenueCatEntitlementIds } from './types/revenuecat';
+export type RevenueCatClientOptions = {
+    apiKey: string;
+    projectId: string;
+    timeoutMs?: number;
+    totalTimeoutMs?: number;
+    maxPages?: number;
+};
+/** Deliberately excludes the original HTTP error, which can contain the API key. */
+export declare class RevenueCatLookupError extends HttpError {
+    constructor();
+}
+export declare function createRevenueCatClient(options: RevenueCatClientOptions): RevenueCatClient;
+/** Resolve any eligible entitlement from one customer lookup; never infer Free from API failures. */
+export declare function verifyCreditGiveawayEntitlement(userId: string, client: RevenueCatClient, entitlementIds: RevenueCatEntitlementIds): Promise<GiveawayCreditEligibilityEvidence | null>;