@mpgd/game-services 0.9.0 → 0.11.0

package/dist/google-play-purchase.js

@@ -0,0 +1,559 @@
+export const googlePlayProductPurchaseEvidenceSchema = 'google-play.product-purchase.v2';
+export function createGooglePlayProductPurchaseBoundary(input) {
+    const packageName = assertIdentifier(input.packageName, 'packageName', 256);
+    if (input.resolveObfuscatedAccountId === undefined
+        && input.resolveObfuscatedProfileId === undefined
+        && input.allowUnboundAuthenticatedPlayer !== true) {
+        throw new TypeError('Google Play purchases require account binding or explicit authenticated-player attribution.');
+    }
+    const now = input.now ?? (() => new Date().toISOString());
+    const inFlightFinalizations = new Map();
+    return {
+        supportsPurchaseGrant(finalizationInput) {
+            return finalizationInput.request.target === 'android'
+                && finalizationInput.product.type !== 'subscription'
+                && finalizationInput.request.evidence?.schema
+                    === googlePlayProductPurchaseEvidenceSchema;
+        },
+        async verifyPurchase(verificationInput) {
+            if (verificationInput.request.target !== 'android') {
+                return {
+                    status: 'rejected',
+                    reason: 'GOOGLE_PLAY_TARGET_REQUIRED',
+                };
+            }
+            if (verificationInput.product.type === 'subscription') {
+                return {
+                    status: 'rejected',
+                    reason: 'GOOGLE_PLAY_SUBSCRIPTION_VERIFIER_REQUIRED',
+                };
+            }
+            const purchaseToken = readPurchaseToken(verificationInput.request.evidence);
+            if (purchaseToken === undefined) {
+                return {
+                    status: 'rejected',
+                    reason: 'GOOGLE_PLAY_PURCHASE_TOKEN_REQUIRED',
+                };
+            }
+            const accountBinding = await resolveGooglePlayAccountBinding(input, verificationInput.request.playerId, verificationInput.signal);
+            if (accountBinding.status === 'rejected') {
+                return rejected(accountBinding.reason);
+            }
+            const inspection = await inspectGooglePlayPurchase({
+                client: input.client,
+                packageName,
+                purchaseToken,
+                expectedProductId: verificationInput.platformProductId,
+                expectedProductType: verificationInput.product.type,
+                orderMatch: {
+                    mode: 'if-present',
+                    orderId: verificationInput.request.platformTransactionId,
+                },
+                accountBinding,
+                allowConsumed: false,
+                signal: verificationInput.signal,
+            });
+            if (inspection.status !== 'verified') {
+                return inspection;
+            }
+            return {
+                status: 'verified',
+                verificationId: createGooglePlayVerificationId(inspection.purchase.purchaseTokenDigest),
+                verifiedAt: now(),
+                platformEvidenceId: inspection.purchase.orderId ?? null,
+                payload: createVerificationPayload(packageName, inspection.purchase),
+            };
+        },
+        async finalizePurchaseGrant(finalizationInput) {
+            if (finalizationInput.product.type === 'subscription') {
+                return {
+                    status: 'pending',
+                    alreadyCompleted: false,
+                    reason: 'GOOGLE_PLAY_SUBSCRIPTION_VERIFIER_REQUIRED',
+                };
+            }
+            const action = finalizationInput.product.type === 'consumable'
+                ? 'consume'
+                : 'acknowledge';
+            const purchaseToken = readPurchaseToken(finalizationInput.request.evidence);
+            if (purchaseToken === undefined) {
+                return {
+                    status: 'pending',
+                    action,
+                    alreadyCompleted: false,
+                    reason: 'GOOGLE_PLAY_PURCHASE_TOKEN_REQUIRED',
+                };
+            }
+            const purchaseTokenDigest = await digestPurchaseToken(packageName, purchaseToken);
+            if (finalizationInput.evidenceVerificationId
+                !== createGooglePlayVerificationId(purchaseTokenDigest)) {
+                return {
+                    status: 'pending',
+                    action,
+                    alreadyCompleted: false,
+                    reason: 'GOOGLE_PLAY_FINALIZATION_EVIDENCE_MISMATCH',
+                };
+            }
+            const verifiedContext = readGooglePlayVerifiedContext(finalizationInput.evidencePayload, packageName, finalizationInput.platformProductId, purchaseTokenDigest);
+            const existing = inFlightFinalizations.get(finalizationInput.evidenceVerificationId);
+            if (existing !== undefined) {
+                return existing;
+            }
+            const finalization = finalizeGooglePlayPurchase(input, packageName, purchaseToken, finalizationInput.product.type, action, verifiedContext, finalizationInput);
+            inFlightFinalizations.set(finalizationInput.evidenceVerificationId, finalization);
+            const releaseFinalization = () => {
+                finalizationInput.signal.removeEventListener('abort', releaseFinalization);
+                if (inFlightFinalizations.get(finalizationInput.evidenceVerificationId) === finalization) {
+                    inFlightFinalizations.delete(finalizationInput.evidenceVerificationId);
+                }
+            };
+            finalizationInput.signal.addEventListener('abort', releaseFinalization, { once: true });
+            if (finalizationInput.signal.aborted) {
+                releaseFinalization();
+            }
+            try {
+                return await finalization;
+            }
+            finally {
+                releaseFinalization();
+            }
+        },
+    };
+}
+async function finalizeGooglePlayPurchase(input, packageName, purchaseToken, productType, action, verifiedContext, finalizationInput) {
+    if (finalizationInput.request.target !== 'android') {
+        return {
+            status: 'pending',
+            action,
+            alreadyCompleted: false,
+            reason: 'GOOGLE_PLAY_TARGET_REQUIRED',
+        };
+    }
+    try {
+        const accountBinding = verifiedContext?.accountBinding
+            ?? await resolveGooglePlayAccountBinding(input, finalizationInput.request.playerId, finalizationInput.signal);
+        if (accountBinding.status === 'rejected') {
+            return {
+                status: 'pending',
+                action,
+                alreadyCompleted: false,
+                reason: accountBinding.reason,
+            };
+        }
+        const inspection = await inspectGooglePlayPurchase({
+            client: input.client,
+            packageName,
+            purchaseToken,
+            expectedProductId: finalizationInput.platformProductId,
+            expectedProductType: productType,
+            orderMatch: createGooglePlayFinalizationOrderMatch(verifiedContext, finalizationInput.request.platformTransactionId),
+            accountBinding,
+            allowConsumed: true,
+            signal: finalizationInput.signal,
+        });
+        if (inspection.status !== 'verified') {
+            return {
+                status: 'pending',
+                action,
+                alreadyCompleted: false,
+                reason: inspection.reason,
+            };
+        }
+        if (action === 'consume') {
+            if (inspection.purchase.consumptionState === 'CONSUMPTION_STATE_CONSUMED') {
+                return {
+                    status: 'completed',
+                    action,
+                    alreadyCompleted: true,
+                };
+            }
+            if (inspection.purchase.consumptionState
+                !== 'CONSUMPTION_STATE_YET_TO_BE_CONSUMED') {
+                return {
+                    status: 'pending',
+                    action,
+                    alreadyCompleted: false,
+                    reason: 'GOOGLE_PLAY_CONSUMPTION_STATE_UNSPECIFIED',
+                };
+            }
+            await input.client.consumeProductPurchase({
+                packageName,
+                productId: finalizationInput.platformProductId,
+                purchaseToken,
+                signal: finalizationInput.signal,
+            });
+        }
+        else {
+            if (inspection.purchase.acknowledgementState
+                === 'ACKNOWLEDGEMENT_STATE_ACKNOWLEDGED') {
+                return {
+                    status: 'completed',
+                    action,
+                    alreadyCompleted: true,
+                };
+            }
+            if (inspection.purchase.acknowledgementState
+                !== 'ACKNOWLEDGEMENT_STATE_PENDING') {
+                return {
+                    status: 'pending',
+                    action,
+                    alreadyCompleted: false,
+                    reason: 'GOOGLE_PLAY_ACKNOWLEDGEMENT_STATE_UNSPECIFIED',
+                };
+            }
+            await input.client.acknowledgeProductPurchase({
+                packageName,
+                productId: finalizationInput.platformProductId,
+                purchaseToken,
+                signal: finalizationInput.signal,
+            });
+        }
+        return {
+            status: 'completed',
+            action,
+            alreadyCompleted: false,
+        };
+    }
+    catch (error) {
+        if (isAbortError(error)) {
+            throw error;
+        }
+        return {
+            status: 'pending',
+            action,
+            alreadyCompleted: false,
+            reason: 'GOOGLE_PLAY_API_ERROR',
+        };
+    }
+}
+async function inspectGooglePlayPurchase(input) {
+    const raw = await input.client.getProductPurchaseV2({
+        packageName: input.packageName,
+        purchaseToken: input.purchaseToken,
+        signal: input.signal,
+    });
+    if (!isRecord(raw)) {
+        return rejected('GOOGLE_PLAY_RESPONSE_INVALID');
+    }
+    const stateContext = raw.purchaseStateContext;
+    const purchaseState = isRecord(stateContext)
+        ? readPurchaseState(stateContext.purchaseState)
+        : undefined;
+    if (purchaseState === 'PENDING') {
+        return {
+            status: 'pending',
+            reason: 'GOOGLE_PLAY_PURCHASE_PENDING',
+        };
+    }
+    if (purchaseState === 'CANCELLED') {
+        return rejected('GOOGLE_PLAY_PURCHASE_CANCELLED');
+    }
+    if (purchaseState !== 'PURCHASED') {
+        return rejected('GOOGLE_PLAY_PURCHASE_STATE_UNSPECIFIED');
+    }
+    const lineItems = raw.productLineItem;
+    if (!Array.isArray(lineItems) || lineItems.length !== 1 || !isRecord(lineItems[0])) {
+        return rejected('GOOGLE_PLAY_LINE_ITEM_COUNT_UNSUPPORTED');
+    }
+    const lineItem = lineItems[0];
+    if (lineItem.productId !== input.expectedProductId) {
+        return rejected('GOOGLE_PLAY_PRODUCT_MISMATCH');
+    }
+    const offerDetails = lineItem.productOfferDetails;
+    if (!isRecord(offerDetails)) {
+        return rejected('GOOGLE_PLAY_OFFER_DETAILS_INVALID');
+    }
+    if (offerDetails.rentOfferDetails !== undefined) {
+        return rejected('GOOGLE_PLAY_RENTAL_UNSUPPORTED');
+    }
+    const quantity = offerDetails.quantity;
+    if (!Number.isSafeInteger(quantity) || quantity !== 1) {
+        return rejected('GOOGLE_PLAY_QUANTITY_UNSUPPORTED');
+    }
+    const refundableQuantity = offerDetails.refundableQuantity;
+    if (typeof refundableQuantity !== 'number'
+        || !Number.isSafeInteger(refundableQuantity)
+        || refundableQuantity < 0
+        || refundableQuantity > quantity) {
+        return rejected('GOOGLE_PLAY_REFUNDABLE_QUANTITY_INVALID');
+    }
+    if (refundableQuantity !== quantity) {
+        return rejected('GOOGLE_PLAY_PURCHASE_REFUNDED');
+    }
+    const consumptionState = readConsumptionState(offerDetails.consumptionState);
+    if (input.expectedProductType === 'consumable'
+        && consumptionState === 'CONSUMPTION_STATE_UNSPECIFIED') {
+        return rejected('GOOGLE_PLAY_CONSUMPTION_STATE_UNSPECIFIED');
+    }
+    if (!input.allowConsumed
+        && consumptionState === 'CONSUMPTION_STATE_CONSUMED') {
+        return rejected('GOOGLE_PLAY_PURCHASE_ALREADY_CONSUMED');
+    }
+    const acknowledgementState = readAcknowledgementState(raw.acknowledgementState);
+    if (input.expectedProductType === 'non_consumable'
+        && acknowledgementState === 'ACKNOWLEDGEMENT_STATE_UNSPECIFIED') {
+        return rejected('GOOGLE_PLAY_ACKNOWLEDGEMENT_STATE_UNSPECIFIED');
+    }
+    const orderId = readOptionalIdentifier(raw.orderId, 512);
+    if (raw.orderId !== undefined && orderId === undefined) {
+        return rejected('GOOGLE_PLAY_ORDER_INVALID');
+    }
+    if ((input.orderMatch.mode === 'exact' && orderId !== input.orderMatch.orderId)
+        || (input.orderMatch.mode === 'if-present'
+            && orderId !== undefined
+            && orderId !== input.orderMatch.orderId)) {
+        return rejected('GOOGLE_PLAY_ORDER_MISMATCH');
+    }
+    // `token-only` deliberately skips order matching because the stored token
+    // digest is the authoritative replay identity when Google omitted the order.
+    const purchaseCompletionTime = readTimestamp(raw.purchaseCompletionTime);
+    if (purchaseCompletionTime === undefined) {
+        return rejected('GOOGLE_PLAY_COMPLETION_TIME_INVALID');
+    }
+    const obfuscatedExternalAccountId = readOptionalIdentifier(raw.obfuscatedExternalAccountId, 256);
+    if (raw.obfuscatedExternalAccountId !== undefined
+        && obfuscatedExternalAccountId === undefined) {
+        return rejected('GOOGLE_PLAY_ACCOUNT_INVALID');
+    }
+    const obfuscatedExternalProfileId = readOptionalIdentifier(raw.obfuscatedExternalProfileId, 256);
+    if (raw.obfuscatedExternalProfileId !== undefined
+        && obfuscatedExternalProfileId === undefined) {
+        return rejected('GOOGLE_PLAY_PROFILE_INVALID');
+    }
+    if (input.accountBinding.status === 'bound') {
+        // Defensive invariant: every bound context must carry at least one
+        // identifier, even though the constructors below already enforce it.
+        if (input.accountBinding.accountId === undefined
+            && input.accountBinding.profileId === undefined) {
+            return rejected('GOOGLE_PLAY_ACCOUNT_BINDING_REQUIRED');
+        }
+        if (input.accountBinding.accountId !== undefined
+            && obfuscatedExternalAccountId !== input.accountBinding.accountId) {
+            return rejected('GOOGLE_PLAY_ACCOUNT_MISMATCH');
+        }
+        if (input.accountBinding.profileId !== undefined
+            && obfuscatedExternalProfileId !== input.accountBinding.profileId) {
+            return rejected('GOOGLE_PLAY_PROFILE_MISMATCH');
+        }
+        if (input.accountBinding.profileId === undefined
+            && obfuscatedExternalProfileId !== undefined) {
+            return rejected('GOOGLE_PLAY_PROFILE_BINDING_REQUIRED');
+        }
+        if (input.accountBinding.accountId === undefined
+            && obfuscatedExternalAccountId !== undefined) {
+            return rejected('GOOGLE_PLAY_ACCOUNT_BINDING_REQUIRED');
+        }
+    }
+    // The unbound opt-in is safe only when the provider response is also unbound.
+    if (input.accountBinding.status === 'unbound'
+        && (obfuscatedExternalAccountId !== undefined
+            || obfuscatedExternalProfileId !== undefined)) {
+        return rejected('GOOGLE_PLAY_ACCOUNT_MISMATCH');
+    }
+    return {
+        status: 'verified',
+        purchase: {
+            purchaseToken: input.purchaseToken,
+            purchaseTokenDigest: await digestPurchaseToken(input.packageName, input.purchaseToken),
+            productId: input.expectedProductId,
+            ...(orderId === undefined ? {} : { orderId }),
+            purchaseCompletionTime,
+            consumptionState,
+            acknowledgementState,
+            ...(obfuscatedExternalAccountId === undefined
+                ? {}
+                : { obfuscatedExternalAccountId }),
+            ...(obfuscatedExternalProfileId === undefined
+                ? {}
+                : { obfuscatedExternalProfileId }),
+        },
+    };
+}
+function createGooglePlayFinalizationOrderMatch(verifiedContext, clientOrderId) {
+    if (verifiedContext === undefined) {
+        return { mode: 'if-present', orderId: clientOrderId };
+    }
+    if (verifiedContext.orderId === undefined) {
+        return { mode: 'token-only' };
+    }
+    return { mode: 'exact', orderId: verifiedContext.orderId };
+}
+function readGooglePlayVerifiedContext(payload, packageName, productId, purchaseTokenDigest) {
+    if (payload?.googlePlayPackageName !== packageName
+        || payload.googlePlayProductId !== productId
+        || payload.googlePlayPurchaseTokenDigest !== purchaseTokenDigest) {
+        return undefined;
+    }
+    const orderId = readOptionalIdentifier(payload.googlePlayOrderId, 512);
+    if (payload.googlePlayOrderId !== undefined && orderId === undefined) {
+        return undefined;
+    }
+    const accountId = readOptionalIdentifier(payload.googlePlayObfuscatedExternalAccountId, 256);
+    if (payload.googlePlayObfuscatedExternalAccountId !== undefined
+        && accountId === undefined) {
+        return undefined;
+    }
+    const profileId = readOptionalIdentifier(payload.googlePlayObfuscatedExternalProfileId, 256);
+    if (payload.googlePlayObfuscatedExternalProfileId !== undefined
+        && profileId === undefined) {
+        return undefined;
+    }
+    return {
+        ...(orderId === undefined ? {} : { orderId }),
+        accountBinding: accountId === undefined && profileId === undefined
+            ? { status: 'unbound' }
+            : {
+                status: 'bound',
+                ...(accountId === undefined ? {} : { accountId }),
+                ...(profileId === undefined ? {} : { profileId }),
+            },
+    };
+}
+async function resolveGooglePlayAccountBinding(input, playerId, signal) {
+    if (input.resolveObfuscatedAccountId === undefined
+        && input.resolveObfuscatedProfileId === undefined) {
+        return { status: 'unbound' };
+    }
+    let resolvedAccountId;
+    let resolvedProfileId;
+    try {
+        [resolvedAccountId, resolvedProfileId] = await Promise.all([
+            input.resolveObfuscatedAccountId?.(playerId, signal),
+            input.resolveObfuscatedProfileId?.(playerId, signal),
+        ]);
+    }
+    catch (error) {
+        if (isAbortError(error)) {
+            throw error;
+        }
+        return {
+            status: 'rejected',
+            reason: 'GOOGLE_PLAY_ACCOUNT_BINDING_ERROR',
+        };
+    }
+    if (resolvedAccountId === undefined
+        && resolvedProfileId === undefined
+        && input.allowUnboundAuthenticatedPlayer === true) {
+        return { status: 'unbound' };
+    }
+    const accountId = readOptionalIdentifier(resolvedAccountId, 256);
+    const profileId = readOptionalIdentifier(resolvedProfileId, 256);
+    if (resolvedAccountId !== undefined && accountId === undefined) {
+        return {
+            status: 'rejected',
+            reason: 'GOOGLE_PLAY_ACCOUNT_BINDING_REQUIRED',
+        };
+    }
+    if (resolvedProfileId !== undefined && profileId === undefined) {
+        return {
+            status: 'rejected',
+            reason: 'GOOGLE_PLAY_PROFILE_BINDING_REQUIRED',
+        };
+    }
+    if (accountId === undefined && profileId === undefined) {
+        return {
+            status: 'rejected',
+            reason: input.resolveObfuscatedAccountId === undefined
+                ? 'GOOGLE_PLAY_PROFILE_BINDING_REQUIRED'
+                : 'GOOGLE_PLAY_ACCOUNT_BINDING_REQUIRED',
+        };
+    }
+    return {
+        status: 'bound',
+        ...(accountId === undefined ? {} : { accountId }),
+        ...(profileId === undefined ? {} : { profileId }),
+    };
+}
+function createVerificationPayload(packageName, purchase) {
+    return {
+        googlePlayPackageName: packageName,
+        googlePlayProductId: purchase.productId,
+        googlePlayPurchaseTokenDigest: purchase.purchaseTokenDigest,
+        googlePlayPurchaseCompletionTime: purchase.purchaseCompletionTime,
+        googlePlayConsumptionState: purchase.consumptionState,
+        googlePlayAcknowledgementState: purchase.acknowledgementState,
+        ...(purchase.orderId === undefined ? {} : { googlePlayOrderId: purchase.orderId }),
+        ...(purchase.obfuscatedExternalAccountId === undefined
+            ? {}
+            : { googlePlayObfuscatedExternalAccountId: purchase.obfuscatedExternalAccountId }),
+        ...(purchase.obfuscatedExternalProfileId === undefined
+            ? {}
+            : { googlePlayObfuscatedExternalProfileId: purchase.obfuscatedExternalProfileId }),
+    };
+}
+function readPurchaseToken(evidence) {
+    if (evidence?.schema !== googlePlayProductPurchaseEvidenceSchema) {
+        return undefined;
+    }
+    return readOptionalIdentifier(evidence.payload.purchaseToken, 4096);
+}
+function readPurchaseState(input) {
+    if (input === 'PURCHASED'
+        || input === 'CANCELLED'
+        || input === 'PENDING'
+        || input === 'PURCHASE_STATE_UNSPECIFIED') {
+        return input;
+    }
+    return undefined;
+}
+function readConsumptionState(input) {
+    if (input === 'CONSUMPTION_STATE_YET_TO_BE_CONSUMED'
+        || input === 'CONSUMPTION_STATE_CONSUMED') {
+        return input;
+    }
+    return 'CONSUMPTION_STATE_UNSPECIFIED';
+}
+function readAcknowledgementState(input) {
+    if (input === 'ACKNOWLEDGEMENT_STATE_PENDING'
+        || input === 'ACKNOWLEDGEMENT_STATE_ACKNOWLEDGED') {
+        return input;
+    }
+    return 'ACKNOWLEDGEMENT_STATE_UNSPECIFIED';
+}
+function readTimestamp(input) {
+    if (typeof input !== 'string' || input.length === 0 || !Number.isFinite(Date.parse(input))) {
+        return undefined;
+    }
+    return input;
+}
+function readOptionalIdentifier(input, maxLength) {
+    if (typeof input !== 'string'
+        || input.length === 0
+        || input.length > maxLength
+        || input.trim() !== input
+        || /[\u0000-\u001f\u007f]/u.test(input)) {
+        return undefined;
+    }
+    return input;
+}
+function assertIdentifier(input, label, maxLength) {
+    const identifier = readOptionalIdentifier(input, maxLength);
+    if (identifier === undefined) {
+        throw new TypeError(`${label} must be a non-empty identifier.`);
+    }
+    return identifier;
+}
+async function digestPurchaseToken(packageName, purchaseToken) {
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle === undefined) {
+        throw new Error('Web Crypto is required to hash Google Play purchase tokens.');
+    }
+    const bytes = new TextEncoder().encode(JSON.stringify([packageName, purchaseToken]));
+    const digest = new Uint8Array(await subtle.digest('SHA-256', bytes));
+    return [...digest].map((value) => value.toString(16).padStart(2, '0')).join('');
+}
+function createGooglePlayVerificationId(purchaseTokenDigest) {
+    return `google-play:product:${purchaseTokenDigest}`;
+}
+function rejected(reason) {
+    return { status: 'rejected', reason };
+}
+function isAbortError(input) {
+    return typeof input === 'object'
+        && input !== null
+        && 'name' in input
+        && input.name === 'AbortError';
+}
+function isRecord(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}

package/dist/index.d.ts

@@ -1,6 +1,11 @@
+export * from './admob-ssv.js';
+export * from './app-store-verifier';
+export * from './apps-in-toss-evidence-verification';
+export * from './apps-in-toss-partner-api';
 export * from './client';
 export * from './contract';
 export * from './evidence-verification';
+export * from './google-play-purchase';
 export * from './notification-delivery';
 export * from './platform-order';
 export * from './progress-link';

package/dist/index.js

@@ -1,6 +1,11 @@
+export * from './admob-ssv.js';
+export * from './app-store-verifier';
+export * from './apps-in-toss-evidence-verification';
+export * from './apps-in-toss-partner-api';
 export * from './client';
 export * from './contract';
 export * from './evidence-verification';
+export * from './google-play-purchase';
 export * from './notification-delivery';
 export * from './platform-order';
 export * from './progress-link';

package/dist/server.d.ts

@@ -2,7 +2,7 @@ import { type AnalyticsSink } from '@mpgd/analytics';
 import type { AdPlacements, ProductCatalog } from '@mpgd/catalog';
 import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesBackendTransportRequest, type GameServicesBackendTransportResponse } from './client';
 import { type GameServicesHealthResponse } from './contract';
-import { type GameServicesEvidenceVerifier } from './evidence-verification';
+import { type GameServicesEvidenceVerifier, type GameServicesPurchaseGrantFinalizer } from './evidence-verification';
 import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerResult, type LeaderboardScoreTransaction, type ProductGrantTransaction, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types';
 type CorsHeaders = Record<string, string>;
 export interface CreateGameServicesBackendInput {
@@ -15,6 +15,8 @@ export interface CreateGameServicesBackendInput {
   readonly version?: string;
   readonly evidenceVerifier?: GameServicesEvidenceVerifier;
   readonly evidenceVerificationTimeoutMs?: number;
+  readonly purchaseGrantFinalizationTimeoutMs?: number;
+  readonly purchaseGrantFinalizer?: GameServicesPurchaseGrantFinalizer;
 }
 export interface GameServicesBackendApiHandler {
   readonly version?: string;