@mpgd/game-services 0.16.0 → 0.17.1

package/dist/admob-client-reward.d.ts

@@ -0,0 +1,27 @@
+import type { RewardedAdResult } from '@mpgd/platform';
+/** This schema records SDK callback evidence, never an authoritative grant. */
+export declare const admobClientRewardEvidenceSchema = "mpgd.admob.client-reward.v1";
+export declare function isAdMobClientRewardEvidence(value: unknown): boolean;
+/**
+* Verse8 Ads SDK callback evidence. Mirrors `verse8AdsRewardEvidenceSchema`
+* from `@mpgd/adapter-verse8`; the adapter owns the schema and the backend
+* verifier consumes it, so the value must stay byte-identical on both sides.
+*/
+export declare const verse8ClientRewardEvidenceSchema = "verse8.ads.reward.v1";
+/**
+* Evidence schemas that a client adapter may return with
+* `status: 'completed' | 'pending'`, `rewardGranted: false`, and no
+* `ledgerEntryId`. They are claim candidates only: the backend ledger decides
+* whether a reward is granted.
+*/
+export declare const clientRewardEvidenceSchemas: readonly ["mpgd.admob.client-reward.v1", "verse8.ads.reward.v1"];
+export type ClientRewardEvidenceSchema = (typeof clientRewardEvidenceSchemas)[number];
+/** True when a rewarded-ad result carries ungranted evidence from an allow-listed schema. */
+export declare function isClientRewardEvidence(value: unknown): boolean;
+export declare function isVerse8ClientRewardEvidence(value: unknown): boolean;
+/**
+* Resolve the platform impression identifier to forward with a backend claim.
+* Authoritative adapters return `ledgerEntryId`; client-evidence adapters
+* expose the impression identifier inside the evidence payload instead.
+*/
+export declare function resolveRewardPlatformImpressionId(reward: RewardedAdResult): string | undefined;

package/dist/admob-client-reward.js

@@ -0,0 +1,84 @@
+/** This schema records SDK callback evidence, never an authoritative grant. */
+export const admobClientRewardEvidenceSchema = 'mpgd.admob.client-reward.v1';
+export function isAdMobClientRewardEvidence(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const reward = value;
+    const evidence = reward.evidence;
+    if ((reward.status !== 'completed' && reward.status !== 'pending')
+        || reward.rewardGranted !== false
+        || reward.ledgerEntryId !== undefined
+        || typeof evidence !== 'object' || evidence === null || Array.isArray(evidence)) {
+        return false;
+    }
+    const envelope = evidence;
+    const payload = envelope.payload;
+    return envelope.schema === admobClientRewardEvidenceSchema
+        && typeof payload === 'object' && payload !== null && !Array.isArray(payload)
+        && typeof payload.adUnitId === 'string'
+        && payload.adUnitId.length > 0;
+}
+/**
+ * Verse8 Ads SDK callback evidence. Mirrors `verse8AdsRewardEvidenceSchema`
+ * from `@mpgd/adapter-verse8`; the adapter owns the schema and the backend
+ * verifier consumes it, so the value must stay byte-identical on both sides.
+ */
+export const verse8ClientRewardEvidenceSchema = 'verse8.ads.reward.v1';
+/**
+ * Evidence schemas that a client adapter may return with
+ * `status: 'completed' | 'pending'`, `rewardGranted: false`, and no
+ * `ledgerEntryId`. They are claim candidates only: the backend ledger decides
+ * whether a reward is granted.
+ */
+export const clientRewardEvidenceSchemas = Object.freeze([
+    admobClientRewardEvidenceSchema,
+    verse8ClientRewardEvidenceSchema,
+]);
+/** True when a rewarded-ad result carries ungranted evidence from an allow-listed schema. */
+export function isClientRewardEvidence(value) {
+    return isAdMobClientRewardEvidence(value) || isVerse8ClientRewardEvidence(value);
+}
+export function isVerse8ClientRewardEvidence(value) {
+    const payload = readUngrantedEvidencePayload(value, verse8ClientRewardEvidenceSchema);
+    return payload !== undefined
+        && isNonEmptyString(payload.requestId)
+        && isNonEmptyString(payload.placementId);
+}
+/**
+ * Resolve the platform impression identifier to forward with a backend claim.
+ * Authoritative adapters return `ledgerEntryId`; client-evidence adapters
+ * expose the impression identifier inside the evidence payload instead.
+ */
+export function resolveRewardPlatformImpressionId(reward) {
+    if (reward.ledgerEntryId !== undefined) {
+        return reward.ledgerEntryId;
+    }
+    if (isVerse8ClientRewardEvidence(reward)) {
+        return reward.evidence?.payload.requestId;
+    }
+    return undefined;
+}
+function readUngrantedEvidencePayload(value, schema) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const reward = value;
+    const evidence = reward.evidence;
+    if ((reward.status !== 'completed' && reward.status !== 'pending')
+        || reward.rewardGranted !== false
+        || reward.ledgerEntryId !== undefined
+        || typeof evidence !== 'object' || evidence === null || Array.isArray(evidence)) {
+        return undefined;
+    }
+    const envelope = evidence;
+    const payload = envelope.payload;
+    if (envelope.schema !== schema
+        || typeof payload !== 'object' || payload === null || Array.isArray(payload)) {
+        return undefined;
+    }
+    return payload;
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}

package/dist/admob-ssv.d.ts

@@ -2,6 +2,8 @@ import type { AdPlacementEntry } from '@mpgd/catalog';
 import type { GameServicesEvidenceVerifier } from './evidence-verification.js';
 import type { ClaimAdRewardRequest } from './types.js';
 export declare const admobSsvCustomDataSchema = "mpgd.admob.ssv.binding.v1";
+/** Maximum field length accepted by the shipped game-services SSV receiver. */
+export declare const admobSsvMaximumBindingFieldLength = 256;
 export declare const defaultAdMobSsvMaximumCallbackAgeMs = 86400000;
 export declare const defaultAdMobSsvMaximumFutureSkewMs = 300000;
 export interface AdMobSsvCustomDataBinding {

package/dist/admob-ssv.js

@@ -1,5 +1,7 @@
 import { Point, verify as verifySecp256k1 } from '@noble/secp256k1';
 export const admobSsvCustomDataSchema = 'mpgd.admob.ssv.binding.v1';
+/** Maximum field length accepted by the shipped game-services SSV receiver. */
+export const admobSsvMaximumBindingFieldLength = 256;
 export const defaultAdMobSsvMaximumCallbackAgeMs = 86_400_000;
 export const defaultAdMobSsvMaximumFutureSkewMs = 300_000;
 const signatureMarker = '&signature=';
@@ -214,10 +216,13 @@ async function verifyAdMobSsvReward(context, input) {
     if (callback.timestampMs < nowMs - context.maximumCallbackAgeMs) {
         return rejected('ADMOB_SSV_CALLBACK_EXPIRED');
     }
+    // SSV never validates the client-reported `platformImpressionId`, so the signed
+    // transaction becomes the platform evidence identity instead of the client value.
     return {
         status: 'verified',
         verificationId: `admob:ssv:${callback.transactionId}`,
         verifiedAt: new Date(callback.timestampMs).toISOString(),
+        platformEvidenceId: callback.transactionId,
         payload: {
             admobSsvTransactionId: callback.transactionId,
             admobSsvAdNetwork: callback.adNetwork,

package/dist/app-store-recovery.d.ts

@@ -0,0 +1,38 @@
+import { type ProductCatalog } from '@mpgd/catalog';
+import { type AppStoreEnvironment } from './app-store-verifier.js';
+import type { PurchaseVerificationApi } from './client.js';
+import type { GameServicesEvidenceVerifier } from './evidence-verification.js';
+import type { GameServicesStore } from './server.js';
+import type { VerifyPurchaseRequest, VerifyPurchaseResponse } from './types.js';
+export type AppStoreRecoveryRequest = Omit<VerifyPurchaseRequest, 'target' | 'idempotencyKey' | 'evidence'> & {
+  readonly target: 'ios';
+};
+export interface AppStoreRestoredTransactionIdentity {
+  readonly originalTransactionId?: string;
+  readonly productType?: 'consumable' | 'non_consumable';
+}
+export interface CreateAppStoreRecoveryBackendOptions {
+  /** Bind this instance to a player authenticated by the game server. */
+  readonly playerId: string;
+  readonly deploymentTarget?: string;
+  readonly purchases: PurchaseVerificationApi;
+  readonly store: GameServicesStore;
+  /** Required to re-verify restored non-consumables whose current transaction ID changed. */
+  readonly restoredNonConsumables?: {
+    readonly catalog: ProductCatalog;
+    readonly evidenceVerifier: GameServicesEvidenceVerifier;
+    readonly bundleId: string;
+    readonly environment: AppStoreEnvironment;
+    readonly timeoutMs?: number;
+  };
+  /** Look up the original, durable checkout key; never derive one from the transaction ID. */
+  readonly resolveOriginalIdempotencyKey?: (input: AppStoreRecoveryRequest & AppStoreRestoredTransactionIdentity) => Promise<string | undefined>;
+}
+export interface AppStoreRecoveryBackend {
+  recoverPurchase(input: AppStoreRecoveryRequest & AppStoreRestoredTransactionIdentity): Promise<VerifyPurchaseResponse>;
+}
+/**
+* Connect StoreKit recovery to the existing authoritative purchase ledger.
+* This is a server-side helper, not an authentication or Apple verifier.
+*/
+export declare function createAppStoreRecoveryBackend(options: CreateAppStoreRecoveryBackendOptions): AppStoreRecoveryBackend;

package/dist/app-store-recovery.js

@@ -0,0 +1,271 @@
+import { resolveProductPlatformId } from '@mpgd/catalog';
+import { createAppStoreVerificationId, isAppStoreVerificationId, } from './app-store-verifier.js';
+/**
+ * Connect StoreKit recovery to the existing authoritative purchase ledger.
+ * This is a server-side helper, not an authentication or Apple verifier.
+ */
+export function createAppStoreRecoveryBackend(options) {
+    if (options.playerId.trim() === '') {
+        throw new TypeError('App Store recovery requires an authenticated player ID.');
+    }
+    const restoreTimeoutMs = options.restoredNonConsumables?.timeoutMs;
+    if (restoreTimeoutMs !== undefined
+        && (!Number.isSafeInteger(restoreTimeoutMs) || restoreTimeoutMs <= 0)) {
+        throw new TypeError('Restored App Store verification timeout must be positive.');
+    }
+    return {
+        async recoverPurchase(input) {
+            if (input?.target !== 'ios' || input.playerId !== options.playerId
+                || typeof input.productId !== 'string' || input.productId.trim() === ''
+                || typeof input.platformTransactionId !== 'string'
+                || input.platformTransactionId.trim() === ''
+                || typeof input.purchasedAt !== 'string' || input.purchasedAt.trim() === ''
+                || (options.deploymentTarget !== undefined
+                    && input.deploymentTarget !== undefined
+                    && input.deploymentTarget !== options.deploymentTarget)) {
+                return rejected('APP_STORE_RECOVERY_IDENTITY_MISMATCH');
+            }
+            let request = {
+                ...input,
+                ...(options.deploymentTarget === undefined
+                    ? {}
+                    : { deploymentTarget: options.deploymentTarget }),
+            };
+            try {
+                const restoreConfig = options.restoredNonConsumables;
+                if (input.productType === 'non_consumable'
+                    && input.originalTransactionId !== undefined
+                    && input.originalTransactionId !== input.platformTransactionId
+                    && restoreConfig !== undefined) {
+                    const candidateId = createAppStoreVerificationId({
+                        environment: restoreConfig.environment,
+                        bundleId: restoreConfig.bundleId,
+                        transactionId: input.originalTransactionId,
+                    });
+                    const candidate = await findByVerificationId(options.store, candidateId);
+                    if (candidate !== undefined) {
+                        if (candidate.source !== 'purchase'
+                            || candidate.playerId !== request.playerId
+                            || candidate.grantId !== request.productId
+                            || candidate.payload.target !== 'ios'
+                            || candidate.payload.productType !== 'non_consumable'
+                            || candidate.payload.appStoreOriginalTransactionId
+                                !== input.originalTransactionId) {
+                            return rejected('APP_STORE_RECOVERY_IDENTITY_MISMATCH');
+                        }
+                        if (typeof candidate.payload.deploymentTarget === 'string') {
+                            if (request.deploymentTarget !== undefined
+                                && request.deploymentTarget !== candidate.payload.deploymentTarget) {
+                                return rejected('APP_STORE_RECOVERY_IDENTITY_MISMATCH');
+                            }
+                            request = { ...request, deploymentTarget: candidate.payload.deploymentTarget };
+                        }
+                    }
+                    else if (options.deploymentTarget === undefined) {
+                        // A request-supplied target is not a server-bound deployment identity.
+                        return pending('APP_STORE_RECOVERY_DEPLOYMENT_TARGET_REQUIRED');
+                    }
+                }
+                const restoredVerificationId = await verifyRestoredNonConsumable(input, request, options);
+                if (typeof restoredVerificationId !== 'string') {
+                    return restoredVerificationId;
+                }
+                const platformGrant = await findByPlatformEvidence(options.store, request.platformTransactionId);
+                const originalGrant = restoredVerificationId === ''
+                    ? undefined
+                    : await findByVerificationId(options.store, restoredVerificationId);
+                if (platformGrant !== undefined && originalGrant !== undefined
+                    && platformGrant.ledgerEntryId !== originalGrant.ledgerEntryId) {
+                    return rejected('APP_STORE_RECOVERY_IDENTITY_MISMATCH');
+                }
+                const existing = platformGrant ?? originalGrant;
+                if (existing !== undefined
+                    && !matchesRecovery(existing, request, restoredVerificationId)) {
+                    return rejected('APP_STORE_RECOVERY_IDENTITY_MISMATCH');
+                }
+                let key = existing?.idempotencyKey;
+                if (key === undefined) {
+                    key = await options.resolveOriginalIdempotencyKey?.(request);
+                }
+                if (key === undefined || key.trim() === '') {
+                    return pending('APP_STORE_ORIGINAL_PURCHASE_NOT_FOUND');
+                }
+                const keyedGrant = await findByIdempotency(options.store, options.playerId, key);
+                if (keyedGrant !== undefined
+                    && !matchesRecovery(keyedGrant, request, restoredVerificationId)) {
+                    return rejected('APP_STORE_RECOVERY_IDENTITY_MISMATCH');
+                }
+                const priorGrant = existing ?? keyedGrant;
+                if (request.deploymentTarget === undefined
+                    && typeof priorGrant?.payload.deploymentTarget === 'string') {
+                    request = { ...request, deploymentTarget: priorGrant.payload.deploymentTarget };
+                }
+                // A stored grant lets the backend's normal retry path return its original entry.
+                const response = await options.purchases.verifyPurchase({
+                    ...request,
+                    idempotencyKey: key,
+                });
+                if (!response.verified) {
+                    return response;
+                }
+                if (response.ledgerEntryId === undefined) {
+                    return pending('APP_STORE_RECOVERY_LEDGER_UNAVAILABLE');
+                }
+                const recorded = await options.store.getEntitlementTransaction(response.ledgerEntryId);
+                if (recorded === undefined) {
+                    return pending('APP_STORE_RECOVERY_LEDGER_UNAVAILABLE');
+                }
+                return matchesRecovery(recorded, request, restoredVerificationId)
+                    ? response
+                    : rejected('APP_STORE_RECOVERY_IDENTITY_MISMATCH');
+            }
+            catch {
+                return pending('APP_STORE_RECOVERY_DEPENDENCY_UNAVAILABLE');
+            }
+        },
+    };
+}
+async function verifyRestoredNonConsumable(input, request, options) {
+    if (input.productType !== 'non_consumable'
+        || input.originalTransactionId === undefined
+        || input.originalTransactionId === input.platformTransactionId) {
+        return '';
+    }
+    const config = options.restoredNonConsumables;
+    if (config === undefined) {
+        return pending('APP_STORE_RESTORE_VERIFIER_REQUIRED');
+    }
+    const product = config.catalog.products.find((item) => item.id === request.productId);
+    if (product?.type !== 'non_consumable') {
+        return rejected('APP_STORE_RECOVERY_PRODUCT_TYPE_MISMATCH');
+    }
+    const platformProductId = resolveProductPlatformId(product, request.deploymentTarget ?? request.target);
+    if (platformProductId === undefined) {
+        return rejected('APP_STORE_RECOVERY_PRODUCT_UNAVAILABLE');
+    }
+    const timeoutMs = config.timeoutMs ?? 10_000;
+    const controller = new AbortController();
+    let timeoutHandle;
+    const timeout = new Promise((resolve) => {
+        timeoutHandle = setTimeout(() => {
+            resolve({ status: 'pending', reason: 'APP_STORE_RESTORE_VERIFICATION_TIMEOUT' });
+            controller.abort();
+        }, timeoutMs);
+    });
+    // This probe calls only the evidence verifier; it never writes a ledger grant.
+    let decision;
+    try {
+        decision = await Promise.race([
+            config.evidenceVerifier.verifyPurchase({
+                request: { ...request, idempotencyKey: 'app-store-recovery-evidence-probe' },
+                product,
+                platformProductId,
+                signal: controller.signal,
+                timeoutMs,
+            }),
+            timeout,
+        ]);
+    }
+    finally {
+        if (timeoutHandle !== undefined) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+    if (decision.status === 'pending') {
+        return pending(decision.reason ?? 'APP_STORE_RESTORE_VERIFICATION_PENDING');
+    }
+    if (decision.status === 'rejected') {
+        return rejected(decision.reason);
+    }
+    const originalTransactionId = decision.payload?.appStoreOriginalTransactionId;
+    const environment = decision.payload?.appStoreEnvironment;
+    const bundleId = decision.payload?.appStoreBundleId;
+    if (decision.payload?.appStoreTransactionType !== 'Non-Consumable'
+        || originalTransactionId !== input.originalTransactionId
+        || (environment !== 'Production' && environment !== 'Sandbox')
+        || environment !== config.environment
+        || bundleId !== config.bundleId
+        || decision.verificationId !== createAppStoreVerificationId({
+            environment,
+            bundleId,
+            transactionId: originalTransactionId,
+        })) {
+        return rejected('APP_STORE_RESTORE_EVIDENCE_MISMATCH');
+    }
+    return decision.verificationId;
+}
+async function findByPlatformEvidence(store, platformTransactionId) {
+    const identity = {
+        source: 'purchase',
+        target: 'ios',
+        platformEvidenceId: platformTransactionId,
+    };
+    if (store.findEntitlementTransactionByPlatformEvidence !== undefined) {
+        return store.findEntitlementTransactionByPlatformEvidence(identity);
+    }
+    return (await store.listEntitlementTransactions()).find((transaction) => {
+        return transaction.source === identity.source
+            && transaction.payload.target === identity.target
+            && transaction.payload.platformTransactionId === identity.platformEvidenceId;
+    });
+}
+async function findByIdempotency(store, playerId, idempotencyKey) {
+    const identity = { source: 'purchase', playerId, idempotencyKey };
+    if (store.findEntitlementTransactionByIdempotency !== undefined) {
+        return store.findEntitlementTransactionByIdempotency(identity);
+    }
+    return (await store.listEntitlementTransactions()).find((transaction) => {
+        return transaction.source === identity.source
+            && transaction.playerId === identity.playerId
+            && transaction.idempotencyKey === identity.idempotencyKey;
+    });
+}
+async function findByVerificationId(store, evidenceVerificationId) {
+    const identity = { source: 'purchase', evidenceVerificationId };
+    if (store.findEntitlementTransactionByEvidenceVerificationId !== undefined) {
+        return store.findEntitlementTransactionByEvidenceVerificationId(identity);
+    }
+    return (await store.listEntitlementTransactions()).find((transaction) => {
+        return transaction.source === identity.source
+            && (transaction.evidenceVerificationId
+                ?? transaction.payload.evidenceVerificationId) === identity.evidenceVerificationId;
+    });
+}
+function matchesRecovery(transaction, request, restoredVerificationId = '') {
+    const verificationId = transaction.evidenceVerificationId
+        ?? transaction.payload.evidenceVerificationId;
+    const environment = transaction.payload.appStoreEnvironment;
+    const bundleId = transaction.payload.appStoreBundleId;
+    const originalTransactionId = transaction.payload.appStoreOriginalTransactionId;
+    const grantTransactionId = restoredVerificationId === ''
+        ? request.platformTransactionId
+        : originalTransactionId;
+    return transaction.source === 'purchase'
+        && transaction.playerId === request.playerId
+        && transaction.grantId === request.productId
+        && transaction.payload.target === 'ios'
+        && (request.deploymentTarget === undefined
+            || transaction.payload.deploymentTarget === request.deploymentTarget)
+        && (restoredVerificationId === ''
+            ? transaction.payload.platformTransactionId === request.platformTransactionId
+            : transaction.payload.productType === 'non_consumable'
+                && transaction.payload.appStoreOriginalTransactionId
+                    === request.originalTransactionId
+                && verificationId === restoredVerificationId)
+        && typeof verificationId === 'string'
+        && isAppStoreVerificationId(verificationId)
+        && (environment === 'Production' || environment === 'Sandbox')
+        && typeof bundleId === 'string'
+        && typeof grantTransactionId === 'string'
+        && verificationId === createAppStoreVerificationId({
+            environment,
+            bundleId,
+            transactionId: grantTransactionId,
+        });
+}
+function pending(reason) {
+    return { verified: false, disposition: 'pending', alreadyProcessed: false, reason };
+}
+function rejected(reason) {
+    return { verified: false, disposition: 'rejected', alreadyProcessed: false, reason };
+}

package/dist/app-store-verifier.d.ts

@@ -84,4 +84,11 @@ export type AppStoreFetch = (url: string, init: {
 }) => Promise<AppStoreFetchResponse>;
 export declare function createAppStoreServerApiClient(options: CreateAppStoreServerApiClientOptions): AppStoreServerApiClient;
 export declare function createAppStoreGameServicesEvidenceVerifier(options: CreateAppStoreEvidenceVerifierOptions): GameServicesEvidenceVerifier;
+export declare function createAppStoreVerificationId(input: {
+  readonly environment: AppStoreEnvironment;
+  readonly bundleId: string;
+  readonly transactionId: string;
+}): string;
+/** Identify IDs emitted by this verifier without duplicating its encoding format. */
+export declare function isAppStoreVerificationId(verificationId: string): boolean;
 export declare function assertAppStoreTransactionPayload(input: unknown): AppStoreTransactionPayload;

package/dist/app-store-verifier.js

@@ -248,13 +248,51 @@ function createVerificationId(transaction) {
     const grantTransactionId = transaction.type === 'Non-Consumable'
         ? transaction.originalTransactionId
         : transaction.transactionId;
+    return createAppStoreVerificationId({
+        environment: transaction.environment,
+        bundleId: transaction.bundleId,
+        transactionId: grantTransactionId,
+    });
+}
+export function createAppStoreVerificationId(input) {
     return [
         'app-store',
-        transaction.environment,
-        transaction.bundleId,
-        grantTransactionId,
+        input.environment,
+        input.bundleId,
+        input.transactionId,
     ].map(encodeVerificationIdSegment).join(':');
 }
+/** Identify IDs emitted by this verifier without duplicating its encoding format. */
+export function isAppStoreVerificationId(verificationId) {
+    const parts = verificationId.split(':');
+    if (parts.length !== 8) {
+        return false;
+    }
+    const values = [];
+    for (let index = 0; index < parts.length; index += 2) {
+        const rawLength = parts[index];
+        const encoded = parts[index + 1];
+        if (rawLength === undefined || encoded === undefined
+            || !/^(0|[1-9][0-9]*)$/u.test(rawLength)) {
+            return false;
+        }
+        try {
+            const value = decodeURIComponent(encoded);
+            if (value.length !== Number(rawLength)
+                || encodeVerificationIdSegment(value) !== `${rawLength}:${encoded}`) {
+                return false;
+            }
+            values.push(value);
+        }
+        catch {
+            return false;
+        }
+    }
+    return values[0] === 'app-store'
+        && (values[1] === 'Production' || values[1] === 'Sandbox')
+        && typeof values[2] === 'string' && values[2].length > 0
+        && typeof values[3] === 'string' && /^[1-9][0-9]{0,19}$/u.test(values[3]);
+}
 function encodeVerificationIdSegment(value) {
     return `${value.length}:${encodeURIComponent(value)}`;
 }

package/dist/authoritative-purchase.d.ts

@@ -0,0 +1,9 @@
+import type { PurchaseResult } from '@mpgd/platform';
+/**
+* Internal: the Microsoft Store adapter completes the ledger grant before it returns this
+* checkout result, so no further backend verification is requested for it.
+*/
+export declare function isAuthoritativeMicrosoftStoreCompletion(target: string, purchase: PurchaseResult): purchase is PurchaseResult & {
+  readonly status: 'completed';
+  readonly transactionId: string;
+};

package/dist/authoritative-purchase.js

@@ -0,0 +1,10 @@
+/**
+ * Internal: the Microsoft Store adapter completes the ledger grant before it returns this
+ * checkout result, so no further backend verification is requested for it.
+ */
+export function isAuthoritativeMicrosoftStoreCompletion(target, purchase) {
+    return target === 'microsoft-store'
+        && purchase.status === 'completed'
+        && purchase.transactionId !== undefined
+        && purchase.authoritativeGrant?.ledgerEntryId === purchase.transactionId;
+}

package/dist/client.d.ts

@@ -98,6 +98,8 @@ export interface CreateGameServicesClientInput {
   readonly analytics?: AnalyticsSink;
   readonly analyticsSessionId?: string;
   readonly now?: () => string;
+  /** Override backend evidence timestamps without backdating analytics events. */
+  readonly requestNow?: () => string;
 }
 export interface GameServicesLeaderboardInput extends LeaderboardScoreInput {
 }