@mpgd/game-services 0.16.0 → 0.17.1

package/dist/server.js

@@ -1,11 +1,13 @@
-import { implement } from '@orpc/server';
-import { RPCHandler } from '@orpc/server/fetch';
+import { implement, ORPCError } from '@orpc/server';
+import { BodyLimitHandlerPlugin, RPCHandler } from '@orpc/server/fetch';
 import { createAnalyticsReporter } from '@mpgd/analytics';
 import { resolveAdPlacementPlatformId, resolveProductPlatformId, } from '@mpgd/catalog';
 import { gameServicesBackendEndpoints, } from './client.js';
 import { gameServicesContract } from './contract.js';
 import { createRejectingGameServicesEvidenceVerifier, } from './evidence-verification.js';
 import { assertClaimAdRewardRequest, assertClaimAdRewardResponse, assertEntitlementLedgerGrant, assertEntitlementLedgerResult, assertGameServicesDeploymentTarget, assertLeaderboardScoreTransaction, assertProductGrantTransaction, assertPurchaseGrantFinalization, assertRecordLeaderboardScoreRequest, assertRecordLeaderboardScoreResponse, assertVerifyPurchaseRequest, assertVerifyPurchaseResponse, } from './types.js';
+import { gameServicesRequestLimits, GameServicesRequestValidationError } from './validation.js';
+export { gameServicesRequestLimits, GameServicesRequestValidationError } from './validation.js';
 export class InMemoryGameServicesStore {
     entitlementTransactionsByKey = new Map();
     entitlementTransactionsByEvidence = new Map();
@@ -142,7 +144,7 @@ export function createGameServicesBackend(input) {
         version,
         purchases: {
             async verifyPurchase(request) {
-                const verification = await verifyPurchaseWithStore(request, {
+                return verifyPurchaseWithStore(request, {
                     catalog: input.catalog,
                     store,
                     now,
@@ -153,47 +155,49 @@ export function createGameServicesBackend(input) {
                     ...(input.purchaseGrantFinalizer === undefined
                         ? {}
                         : { purchaseGrantFinalizer: input.purchaseGrantFinalizer }),
+                }, async (verification) => {
+                    await analytics.track({
+                        name: verification.verified ? 'purchase_granted'
+                            : verification.disposition === 'pending' ? 'purchase_pending' : 'purchase_rejected',
+                        properties: {
+                            target: request.target,
+                            playerId: request.playerId,
+                            productId: request.productId,
+                            ledgerEntryId: verification.ledgerEntryId,
+                            alreadyProcessed: verification.alreadyProcessed,
+                            reason: verification.reason,
+                            finalizationStatus: verification.finalization?.status,
+                            finalizationAction: verification.finalization?.action,
+                            finalizationAlreadyCompleted: verification.finalization?.alreadyCompleted,
+                            finalizationReason: verification.finalization?.reason,
+                        },
+                    });
                 });
-                await analytics.track({
-                    name: verification.verified ? 'purchase_granted' : 'purchase_rejected',
-                    properties: {
-                        target: request.target,
-                        playerId: request.playerId,
-                        productId: request.productId,
-                        ledgerEntryId: verification.ledgerEntryId,
-                        alreadyProcessed: verification.alreadyProcessed,
-                        reason: verification.reason,
-                        finalizationStatus: verification.finalization?.status,
-                        finalizationAction: verification.finalization?.action,
-                        finalizationAlreadyCompleted: verification.finalization?.alreadyCompleted,
-                        finalizationReason: verification.finalization?.reason,
-                    },
-                });
-                return verification;
             },
         },
         adRewards: {
             async claimAdReward(request) {
-                const claim = await claimAdRewardWithStore(request, {
+                return claimAdRewardWithStore(request, {
                     placements: input.placements,
                     store,
                     now,
                     evidenceVerifier,
                     evidenceVerificationTimeoutMs,
                     deploymentTargetBindings,
+                }, async (claim) => {
+                    await analytics.track({
+                        name: claim.granted ? 'rewarded_ad_granted'
+                            : claim.disposition === 'pending' ? 'rewarded_ad_pending' : 'rewarded_ad_rejected',
+                        properties: {
+                            target: request.target,
+                            playerId: request.playerId,
+                            placementId: request.placementId,
+                            ledgerEntryId: claim.ledgerEntryId,
+                            alreadyProcessed: claim.alreadyProcessed,
+                            reason: claim.reason,
+                        },
+                    });
                 });
-                await analytics.track({
-                    name: claim.granted ? 'rewarded_ad_granted' : 'rewarded_ad_rejected',
-                    properties: {
-                        target: request.target,
-                        playerId: request.playerId,
-                        placementId: request.placementId,
-                        ledgerEntryId: claim.ledgerEntryId,
-                        alreadyProcessed: claim.alreadyProcessed,
-                        reason: claim.reason,
-                    },
-                });
-                return claim;
             },
         },
         leaderboard: {
@@ -231,11 +235,42 @@ export function createGameServicesBackendApiHandler(input) {
                 return await routeGameServicesRequest(request.endpoint, request.body, backend);
             }
             catch (error) {
-                return errorResponse(400, error instanceof Error ? error.message : 'BAD_REQUEST');
+                if (error instanceof GameServicesRequestValidationError) {
+                    return errorResponse(400, 'INVALID_REQUEST', error.message);
+                }
+                reportInternalError(input.onInternalError, error);
+                return errorResponse(500, 'INTERNAL_ERROR');
             }
         },
     };
 }
+/**
+ * Invokes the diagnostics hook in isolation: a throwing hook, or one that returns a
+ * rejecting promise (assignable to the `void`-returning handler type), must never replace
+ * the generic `INTERNAL_ERROR` response or escape as an unhandled rejection.
+ */
+function reportInternalError(handler, error) {
+    if (handler === undefined) {
+        console.error('GameServices backend internal error:', error);
+        return;
+    }
+    try {
+        const result = handler(error);
+        if (isPromiseLike(result)) {
+            result.then(undefined, (hookError) => {
+                console.error('GameServices backend onInternalError handler rejected:', hookError);
+            });
+        }
+    }
+    catch (hookError) {
+        console.error('GameServices backend onInternalError handler threw:', hookError);
+    }
+}
+function isPromiseLike(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && typeof value.then === 'function');
+}
 export function createInProcessGameServicesBackendTransport(handler) {
     return {
         async send(request) {
@@ -243,29 +278,49 @@ export function createInProcessGameServicesBackendTransport(handler) {
         },
     };
 }
-export function createGameServicesRouter(backend) {
+export function createGameServicesRouter(backend, options = {}) {
     const contract = implement(gameServicesContract).$context();
+    // oRPC already hides non-ORPCError messages behind INTERNAL_SERVER_ERROR; validation
+    // failures are surfaced as BAD_REQUEST so clients get a stable 400 instead of a 500.
+    const invoke = async (task) => {
+        try {
+            return await task();
+        }
+        catch (error) {
+            if (error instanceof GameServicesRequestValidationError) {
+                throw new ORPCError('BAD_REQUEST', { message: error.message });
+            }
+            reportInternalError(options.onInternalError, error);
+            throw error;
+        }
+    };
     return contract.router({
         health: contract.health.handler(() => createHealthResponse(backend.version)),
         commerce: contract.commerce.router({
             verifyPurchase: contract.commerce.verifyPurchase.handler(({ input }) => {
-                return backend.purchases.verifyPurchase(input);
+                return invoke(() => backend.purchases.verifyPurchase(input));
             }),
         }),
         ads: contract.ads.router({
             claimReward: contract.ads.claimReward.handler(({ input }) => {
-                return backend.adRewards.claimAdReward(input);
+                return invoke(() => backend.adRewards.claimAdReward(input));
             }),
         }),
         leaderboard: contract.leaderboard.router({
             recordScore: contract.leaderboard.recordScore.handler(({ input }) => {
-                return backend.leaderboard.recordScore(input);
+                return invoke(() => backend.leaderboard.recordScore(input));
             }),
         }),
     });
 }
 export function createGameServicesRpcFetchHandler(router, options = {}) {
-    const rpcHandler = new RPCHandler(router);
+    const rpcHandler = new RPCHandler(router, {
+        plugins: [
+            new BodyLimitHandlerPlugin({
+                maxBodySize: resolveMaxBodyBytes(options.maxBodyBytes),
+            }),
+        ],
+    });
     const prefix = options.prefix ?? '/rpc';
     const healthPath = options.healthPath ?? '/health';
     return async (request) => {
@@ -290,6 +345,7 @@ export function createGameServicesRpcFetchHandler(router, options = {}) {
 }
 export function createGameServicesHttpFetchHandler(handler, options = {}) {
     const healthPath = options.healthPath ?? '/health';
+    const maxBodyBytes = resolveMaxBodyBytes(options.maxBodyBytes);
     return async (request) => {
         const requestUrl = new URL(request.url);
         if (requestUrl.pathname === healthPath) {
@@ -304,19 +360,39 @@ export function createGameServicesHttpFetchHandler(handler, options = {}) {
         if (!isGameServicesBackendEndpoint(requestUrl.pathname)) {
             return jsonResponse({ error: 'UNKNOWN_ENDPOINT' }, 404, options.corsHeaders);
         }
+        let body;
+        try {
+            body = await readRequestJson(request, maxBodyBytes);
+        }
+        catch (error) {
+            if (error instanceof RequestPayloadTooLargeError) {
+                return jsonResponse({ error: 'PAYLOAD_TOO_LARGE' }, 413, options.corsHeaders);
+            }
+            return jsonResponse({ error: 'INVALID_JSON' }, 400, options.corsHeaders);
+        }
         try {
             const response = await handler.handle({
                 method: 'POST',
                 endpoint: requestUrl.pathname,
-                body: await readRequestJson(request),
+                body,
             });
             return jsonResponse(response.body, response.status, options.corsHeaders);
         }
         catch (error) {
-            return jsonResponse({ error: error instanceof Error ? error.message : 'BAD_REQUEST' }, 400, options.corsHeaders);
+            // The bundled API handler never throws, but a custom handler must not leak its
+            // failure details to clients either.
+            reportInternalError(undefined, error);
+            return jsonResponse({ error: 'INTERNAL_ERROR' }, 500, options.corsHeaders);
         }
     };
 }
+function resolveMaxBodyBytes(maxBodyBytes) {
+    const resolved = maxBodyBytes ?? gameServicesRequestLimits.maxBodyBytes;
+    if (!Number.isInteger(resolved) || resolved <= 0) {
+        throw new Error('maxBodyBytes must be a positive integer.');
+    }
+    return resolved;
+}
 const gameServicesDeploymentTargetPlatforms = new Set([
     'microsoft-store',
     'android',
@@ -339,13 +415,13 @@ function bindRequestDeploymentTarget(request, bindings) {
     const deploymentTarget = bindings[request.target] ?? request.target;
     if (request.deploymentTarget !== undefined
         && request.deploymentTarget !== deploymentTarget) {
-        throw new Error(`deploymentTarget must match the backend binding for ${request.target}.`);
+        throw new GameServicesRequestValidationError(`deploymentTarget must match the backend binding for ${request.target}.`);
     }
     return deploymentTarget === request.target || request.deploymentTarget === deploymentTarget
         ? request
         : { ...request, deploymentTarget };
 }
-async function verifyPurchaseWithStore(input, context) {
+async function verifyPurchaseWithStore(input, context, onDecision) {
     const request = bindRequestDeploymentTarget(assertVerifyPurchaseRequest(input), context.deploymentTargetBindings);
     const retryIdentity = {
         source: 'purchase',
@@ -357,6 +433,13 @@ async function verifyPurchaseWithStore(input, context) {
             ? {}
             : { deploymentTarget: request.deploymentTarget }),
     };
+    return withEntitlementRetryLock(retryIdentity, async () => {
+        const verification = await verifyPurchaseForRetry(request, retryIdentity, context);
+        await onDecision(verification);
+        return verification;
+    });
+}
+async function verifyPurchaseForRetry(request, retryIdentity, context) {
     const completeExistingRetry = async (transaction) => {
         if (!matchesEntitlementRetry(transaction, retryIdentity)) {
             return assertVerifyPurchaseResponse({
@@ -412,12 +495,14 @@ async function verifyPurchaseWithStore(input, context) {
         return assertVerifyPurchaseResponse({
             verified: false,
             alreadyProcessed: false,
+            disposition: verification.status === 'pending' ? 'pending' : 'rejected',
             reason: verification.status === 'pending'
                 ? (verification.reason ?? 'EVIDENCE_PENDING')
                 : verification.reason,
         });
     }
-    const verificationPayload = createPurchaseVerificationPayload(verification);
+    const verificationPayload = createVerificationPayload(verification, 'platformTransactionId');
+    const platformTransactionId = resolvePlatformEvidenceId(verification, request.platformTransactionId);
     const grant = await recordEntitlementGrantWithEvidence(context.store, {
         playerId: request.playerId,
         grantId: product.id,
@@ -435,11 +520,7 @@ async function verifyPurchaseWithStore(input, context) {
             productId: request.productId,
             productType: product.type,
             platformProductId,
-            ...(verification.platformEvidenceId === null
-                ? {}
-                : {
-                    platformTransactionId: verification.platformEvidenceId ?? request.platformTransactionId,
-                }),
+            ...(platformTransactionId === undefined ? {} : { platformTransactionId }),
             purchasedAt: request.purchasedAt,
             evidenceVerificationId: verification.verificationId,
             evidenceVerifiedAt: verification.verifiedAt,
@@ -633,7 +714,7 @@ function createStoredPurchaseRequest(request, transaction) {
             : {}),
     };
 }
-async function claimAdRewardWithStore(input, context) {
+async function claimAdRewardWithStore(input, context, onDecision) {
     const request = bindRequestDeploymentTarget(assertClaimAdRewardRequest(input), context.deploymentTargetBindings);
     const retryIdentity = {
         source: 'ad_reward',
@@ -645,9 +726,15 @@ async function claimAdRewardWithStore(input, context) {
             ? {}
             : { deploymentTarget: request.deploymentTarget }),
     };
-    const existing = await findEntitlementTransactionByIdempotency(context.store, retryIdentity);
-    if (existing !== undefined) {
-        if (!matchesEntitlementRetry(existing, retryIdentity)) {
+    return withEntitlementRetryLock(retryIdentity, async () => {
+        const claim = await claimAdRewardForRetry(request, retryIdentity, context);
+        await onDecision(claim);
+        return claim;
+    });
+}
+async function claimAdRewardForRetry(request, retryIdentity, context) {
+    const completeExistingRetry = (transaction) => {
+        if (!matchesEntitlementRetry(transaction, retryIdentity)) {
             return assertClaimAdRewardResponse({
                 granted: false,
                 alreadyProcessed: false,
@@ -656,9 +743,13 @@ async function claimAdRewardWithStore(input, context) {
         }
         return assertClaimAdRewardResponse({
             granted: true,
-            ledgerEntryId: existing.ledgerEntryId,
+            ledgerEntryId: transaction.ledgerEntryId,
             alreadyProcessed: true,
         });
+    };
+    const existing = await findEntitlementTransactionByIdempotency(context.store, retryIdentity);
+    if (existing !== undefined) {
+        return completeExistingRetry(existing);
     }
     const placement = context.placements.placements.find((entry) => entry.id === request.placementId);
     if (placement === undefined || placement.type !== 'rewarded' || placement.reward === undefined) {
@@ -679,16 +770,28 @@ async function claimAdRewardWithStore(input, context) {
         });
     }, context.evidenceVerificationTimeoutMs);
     if (verification.status !== 'verified') {
+        // Another backend process can record a matching grant while verification is in flight.
+        // Recheck before returning a stale pending or rejected state.
+        const racedExisting = await findEntitlementTransactionByIdempotency(context.store, retryIdentity);
+        if (racedExisting !== undefined) {
+            return completeExistingRetry(racedExisting);
+        }
         return assertClaimAdRewardResponse({
             granted: false,
             alreadyProcessed: false,
+            disposition: verification.status === 'pending' ? 'pending' : 'rejected',
             reason: verification.status === 'pending'
                 ? (verification.reason ?? 'EVIDENCE_PENDING')
                 : verification.reason,
         });
     }
+    // The client-reported impression id only becomes part of the globally unique platform
+    // evidence identity when the verifier vouches for it (or replaces it with its own
+    // authority id). Otherwise an attacker could pre-register another player's impression id
+    // and have that player's legitimate claim rejected as EVIDENCE_ALREADY_PROCESSED.
+    const platformImpressionId = resolvePlatformEvidenceId(verification, request.platformImpressionId);
     const payload = {
-        ...verification.payload,
+        ...createVerificationPayload(verification, 'platformImpressionId'),
         target: request.target,
         ...(request.deploymentTarget === undefined
             ? {}
@@ -703,8 +806,8 @@ async function claimAdRewardWithStore(input, context) {
     if (placement.reward.type === 'currency') {
         payload.currency = placement.reward.currency;
     }
-    if (request.platformImpressionId !== undefined) {
-        payload.platformImpressionId = request.platformImpressionId;
+    if (platformImpressionId !== undefined) {
+        payload.platformImpressionId = platformImpressionId;
     }
     const result = await recordEntitlementGrantWithEvidence(context.store, {
         playerId: request.playerId,
@@ -739,24 +842,16 @@ async function claimAdRewardWithStore(input, context) {
 async function verifyEvidence(verify, timeoutMs) {
     const controller = new AbortController();
     const timeoutDecision = {
-        status: 'rejected',
+        status: 'pending',
         reason: 'EVIDENCE_VERIFIER_TIMEOUT',
     };
-    let timedOut = false;
     let timeout;
+    let decision;
     try {
-        return await Promise.race([
-            verify(controller.signal)
-                .then(assertEvidenceVerificationDecision)
-                .catch((error) => {
-                if (timedOut) {
-                    return timeoutDecision;
-                }
-                throw error;
-            }),
+        decision = await Promise.race([
+            verify(controller.signal),
             new Promise((resolve) => {
                 timeout = setTimeout(() => {
-                    timedOut = true;
                     resolve(timeoutDecision);
                     controller.abort();
                 }, timeoutMs);
@@ -765,7 +860,7 @@ async function verifyEvidence(verify, timeoutMs) {
     }
     catch {
         return {
-            status: 'rejected',
+            status: 'pending',
             reason: 'EVIDENCE_VERIFIER_ERROR',
         };
     }
@@ -774,13 +869,30 @@ async function verifyEvidence(verify, timeoutMs) {
             clearTimeout(timeout);
         }
     }
+    try {
+        return assertEvidenceVerificationDecision(decision);
+    }
+    catch {
+        return { status: 'rejected', reason: 'EVIDENCE_VERIFIER_ERROR' };
+    }
 }
-function createPurchaseVerificationPayload(verification) {
+/**
+ * Resolves the platform evidence identity stored in the ledger: the verifier's authority id
+ * when it supplies one, the client value when the verifier validated the request without
+ * replacing it (`undefined`), and nothing at all when the verifier suppresses it (`null`).
+ */
+function resolvePlatformEvidenceId(verification, clientPlatformEvidenceId) {
+    if (verification.platformEvidenceId === null) {
+        return undefined;
+    }
+    return verification.platformEvidenceId ?? clientPlatformEvidenceId;
+}
+function createVerificationPayload(verification, platformEvidenceField) {
     if (verification.platformEvidenceId !== null || verification.payload === undefined) {
         return verification.payload;
     }
-    const { platformTransactionId: suppressedPlatformTransactionId, ...payload } = verification.payload;
-    void suppressedPlatformTransactionId;
+    const { [platformEvidenceField]: suppressedPlatformEvidenceId, ...payload } = verification.payload;
+    void suppressedPlatformEvidenceId;
     return payload;
 }
 function assertEvidenceVerificationDecision(decision) {
@@ -875,34 +987,43 @@ async function recordEntitlementGrantUnchecked(store, grant) {
         throw error;
     }
 }
-const entitlementEvidenceLocks = new WeakMap();
+const entitlementLocks = new WeakMap();
+/** Hosts such as the Worker create a store per request, so retries lock per process instead. */
+const entitlementRetryLockScope = {};
 async function withEntitlementEvidenceLocks(store, lockKeys, task) {
     const orderedLockKeys = [...new Set(lockKeys)].sort((left, right) => left.localeCompare(right));
     async function runWithLock(index) {
         const lockKey = orderedLockKeys[index];
         return lockKey === undefined
             ? task()
-            : withEntitlementEvidenceLockKey(store, lockKey, () => runWithLock(index + 1));
+            : withEntitlementLockKey(store, lockKey, () => runWithLock(index + 1));
     }
     return runWithLock(0);
 }
-async function withEntitlementEvidenceLockKey(store, lockKey, task) {
-    const storeLocks = entitlementEvidenceLocks.get(store) ?? new Map();
-    entitlementEvidenceLocks.set(store, storeLocks);
-    const previous = storeLocks.get(lockKey) ?? Promise.resolve();
+/**
+ * Serialize one retry identity in this backend process, from its ledger lookup to its grant
+ * or non-grant decision, so a verifier decision cannot race a same-key grant here.
+ */
+async function withEntitlementRetryLock(identity, task) {
+    return withEntitlementLockKey(entitlementRetryLockScope, createEntitlementIdempotencyKey(identity), task);
+}
+async function withEntitlementLockKey(scope, lockKey, task) {
+    const scopeLocks = entitlementLocks.get(scope) ?? new Map();
+    entitlementLocks.set(scope, scopeLocks);
+    const previous = scopeLocks.get(lockKey) ?? Promise.resolve();
     const gate = createPromiseGate();
     const current = previous.then(() => gate.promise);
-    storeLocks.set(lockKey, current);
+    scopeLocks.set(lockKey, current);
     await previous;
     try {
         return await task();
     }
     finally {
         gate.release();
-        if (storeLocks.get(lockKey) === current) {
-            storeLocks.delete(lockKey);
-            if (storeLocks.size === 0) {
-                entitlementEvidenceLocks.delete(store);
+        if (scopeLocks.get(lockKey) === current) {
+            scopeLocks.delete(lockKey);
+            if (scopeLocks.size === 0) {
+                entitlementLocks.delete(scope);
             }
         }
     }
@@ -1034,11 +1155,12 @@ function okResponse(body) {
         body,
     };
 }
-function errorResponse(status, error) {
+function errorResponse(status, error, message) {
     return {
         status,
         body: {
             error,
+            ...(message === undefined ? {} : { message }),
         },
     };
 }
@@ -1107,13 +1229,51 @@ function encodeIdSegment(value) {
 function isGameServicesBackendEndpoint(pathname) {
     return Object.values(gameServicesBackendEndpoints).includes(pathname);
 }
-async function readRequestJson(request) {
-    const text = await request.text();
+class RequestPayloadTooLargeError extends Error {
+    constructor() {
+        super('Request payload exceeds the configured body limit.');
+        this.name = 'RequestPayloadTooLargeError';
+    }
+}
+async function readRequestJson(request, maxBodyBytes) {
+    const text = await readRequestText(request, maxBodyBytes);
     if (text.length === 0) {
         return {};
     }
     return JSON.parse(text);
 }
+/** Reads the body incrementally so an oversized payload is rejected before it is buffered. */
+async function readRequestText(request, maxBodyBytes) {
+    const declaredLength = Number(request.headers.get('content-length') ?? '');
+    if (Number.isFinite(declaredLength) && declaredLength > maxBodyBytes) {
+        throw new RequestPayloadTooLargeError();
+    }
+    if (request.body === null) {
+        return '';
+    }
+    const reader = request.body.getReader();
+    const chunks = [];
+    let receivedBytes = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        receivedBytes += value.byteLength;
+        if (receivedBytes > maxBodyBytes) {
+            await reader.cancel();
+            throw new RequestPayloadTooLargeError();
+        }
+        chunks.push(value);
+    }
+    const bytes = new Uint8Array(receivedBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(bytes);
+}
 function jsonResponse(body, status, corsHeaders) {
     const headers = new Headers({
         'content-type': 'application/json; charset=utf-8',

package/dist/types.d.ts

@@ -75,11 +75,23 @@ export interface LeaderboardScoreTransaction extends RecordLeaderboardScoreReque
   readonly ledgerEntryId: string;
   readonly recordedAt: string;
 }
+/**
+* Validates an untrusted purchase verification request. Failures throw
+* `GameServicesRequestValidationError` so transports can answer with a stable 400.
+*/
 export declare function assertVerifyPurchaseRequest(input: VerifyPurchaseRequest): VerifyPurchaseRequest;
 export declare function assertVerifyPurchaseResponse(input: VerifyPurchaseResponse): VerifyPurchaseResponse;
 export declare function assertPurchaseGrantFinalization(input: PurchaseGrantFinalization): PurchaseGrantFinalization;
+/**
+* Validates an untrusted ad reward claim. Failures throw
+* `GameServicesRequestValidationError` so transports can answer with a stable 400.
+*/
 export declare function assertClaimAdRewardRequest(input: ClaimAdRewardRequest): ClaimAdRewardRequest;
 export declare function assertClaimAdRewardResponse(input: ClaimAdRewardResponse): ClaimAdRewardResponse;
+/**
+* Validates an untrusted leaderboard score submission. Failures throw
+* `GameServicesRequestValidationError` so transports can answer with a stable 400.
+*/
 export declare function assertRecordLeaderboardScoreRequest(input: RecordLeaderboardScoreRequest): RecordLeaderboardScoreRequest;
 export declare function assertRecordLeaderboardScoreResponse(input: RecordLeaderboardScoreResponse): RecordLeaderboardScoreResponse;
 export declare function assertEntitlementLedgerGrant(input: EntitlementLedgerGrant): EntitlementLedgerGrant;