@mpgd/game-services 0.8.2 → 0.10.0

package/dist/client.js

@@ -29,7 +29,7 @@ export function createGameServicesClient(input) {
     return {
         async purchase(purchaseInput) {
             const target = input.target;
-            if (!isGameServicesStoreTarget(target)) {
+            if (!isGameServicesCommerceTarget(target)) {
                 const purchase = {
                     status: 'failed',
                     entitlementIds: [],
@@ -48,6 +48,25 @@ export function createGameServicesClient(input) {
                 };
             }
             const purchase = await input.gateway.commerce.purchase(purchaseInput);
+            if (target === 'verse8') {
+                const status = purchase.status === 'completed' ? 'rejected' : purchase.status;
+                await analytics.track({
+                    name: 'purchase_rejected',
+                    properties: {
+                        productId: purchaseInput.productId,
+                        status,
+                        reason: purchase.status === 'completed'
+                            ? 'verse8_grants_require_agent8_purchase_event'
+                            : purchase.status === 'pending'
+                                ? 'agent8_purchase_event_pending'
+                                : undefined,
+                    },
+                });
+                return {
+                    status,
+                    purchase,
+                };
+            }
             if (purchase.status !== 'completed' || purchase.transactionId === undefined) {
                 await analytics.track({
                     name: 'purchase_rejected',
@@ -93,7 +112,7 @@ export function createGameServicesClient(input) {
         },
         async claimRewardedAd(rewardInput) {
             const target = input.target;
-            if (!isGameServicesStoreTarget(target)) {
+            if (!isGameServicesAdRewardTarget(target)) {
                 const reward = {
                     status: 'unavailable',
                     rewardGranted: false,
@@ -157,6 +176,23 @@ export function createGameServicesClient(input) {
             return result;
         },
         async submitLeaderboardScore(scoreInput) {
+            const target = input.target;
+            if (!isGameServicesLeaderboardTarget(target)) {
+                await analytics.track({
+                    name: 'leaderboard_submitted',
+                    properties: {
+                        leaderboardId: scoreInput.leaderboardId,
+                        score: scoreInput.score,
+                        submitted: false,
+                        reason: 'unsupported_target',
+                    },
+                });
+                return {
+                    submitted: false,
+                    platformSubmitted: false,
+                    alreadyProcessed: false,
+                };
+            }
             const platformResult = await input.gateway.leaderboard.submitScore(scoreInput);
             if (!platformResult.submitted) {
                 await analytics.track({
@@ -174,7 +210,7 @@ export function createGameServicesClient(input) {
                 };
             }
             const record = await input.backend.leaderboard.recordScore({
-                target: input.target,
+                target,
                 playerId: input.playerId,
                 ...scoreInput,
             });
@@ -281,8 +317,18 @@ export function createGameServicesIdempotencyKey(input) {
 function normalizeSegment(value) {
     return value.replaceAll(/[^a-zA-Z0-9_-]+/g, '-').replaceAll(/^-|-$/g, '').slice(0, 64);
 }
-function isGameServicesStoreTarget(target) {
-    return target === 'android' || target === 'ios' || target === 'ait';
+function isGameServicesCommerceTarget(target) {
+    return target === 'android' || target === 'ios' || target === 'ait' || target === 'verse8';
+}
+function isGameServicesAdRewardTarget(target) {
+    return target === 'android' || target === 'ios' || target === 'ait' || target === 'verse8';
+}
+function isGameServicesLeaderboardTarget(target) {
+    return target === 'browser'
+        || target === 'android'
+        || target === 'ios'
+        || target === 'ait'
+        || target === 'reddit';
 }
 async function sendGameServicesBackendRequest(transport, endpoint, body) {
     const response = await transport.send({

package/dist/evidence-verification.d.ts

@@ -1,10 +1,15 @@
 import type { AdPlacements, ProductCatalog } from '@mpgd/catalog';
-import type { ClaimAdRewardRequest, EntitlementLedgerPayload, VerifyPurchaseRequest } from './types';
+import type { ClaimAdRewardRequest, EntitlementLedgerPayload, PurchaseGrantFinalization, VerifyPurchaseRequest } from './types';
 export type EvidenceVerificationDecision = {
   readonly status: 'verified';
   readonly verificationId: string;
   readonly verifiedAt: string;
   readonly payload?: EntitlementLedgerPayload;
+  /**
+  * An authoritative provider identity for cross-idempotency replay checks.
+  * `null` explicitly suppresses the client-reported platform identity.
+  */
+  readonly platformEvidenceId?: string | null;
 } | {
   readonly status: 'pending';
   readonly reason?: string;
@@ -26,6 +31,21 @@ export interface VerifyAdRewardEvidenceInput {
   readonly signal: AbortSignal;
   readonly timeoutMs: number;
 }
+export interface FinalizePurchaseGrantInput {
+  readonly request: VerifyPurchaseRequest;
+  readonly product: ProductCatalog['products'][number];
+  readonly platformProductId: string;
+  readonly evidenceVerificationId: string;
+  readonly evidencePayload?: EntitlementLedgerPayload;
+  readonly ledgerEntryId: string;
+  readonly alreadyProcessed: boolean;
+  readonly signal: AbortSignal;
+  readonly timeoutMs: number;
+}
+export interface GameServicesPurchaseGrantFinalizer {
+  supportsPurchaseGrant?(input: Omit<FinalizePurchaseGrantInput, 'signal'>): boolean;
+  finalizePurchaseGrant(input: FinalizePurchaseGrantInput): Promise<PurchaseGrantFinalization>;
+}
 export interface GameServicesEvidenceVerifier {
   verifyPurchase(input: VerifyPurchaseEvidenceInput): Promise<EvidenceVerificationDecision>;
   verifyAdReward(input: VerifyAdRewardEvidenceInput): Promise<EvidenceVerificationDecision>;

package/dist/google-play-purchase-conformance.d.ts

@@ -0,0 +1,26 @@
+import { type GooglePlayAcknowledgementState, type GooglePlayConsumptionState, type GooglePlayPurchaseState } from './google-play-purchase';
+export declare const googlePlayProductPurchaseConformanceEvidence: Readonly<{
+  schema: "google-play.product-purchase.v2";
+  payload: Readonly<{
+    purchaseToken: "google-play-conformance-token";
+  }>;
+}>;
+export interface CreateGooglePlayProductPurchaseConformanceFixtureInput {
+  readonly productId?: string;
+  readonly orderId?: string;
+  readonly purchaseState?: Exclude<GooglePlayPurchaseState, 'PURCHASE_STATE_UNSPECIFIED'>;
+  readonly purchaseCompletionTime?: string;
+  readonly consumptionState?: Exclude<GooglePlayConsumptionState, 'CONSUMPTION_STATE_UNSPECIFIED'>;
+  readonly acknowledgementState?: Exclude<GooglePlayAcknowledgementState, 'ACKNOWLEDGEMENT_STATE_UNSPECIFIED'>;
+  readonly quantity?: number;
+  readonly refundableQuantity?: number;
+  readonly rentOffer?: boolean;
+  readonly obfuscatedExternalAccountId?: string;
+  readonly obfuscatedExternalProfileId?: string;
+}
+/**
+* Builds a deterministic `purchases.productsv2` response for boundary and
+* provider-client conformance tests. It intentionally contains no credentials,
+* live purchase tokens, or environment-specific endpoints.
+*/
+export declare function createGooglePlayProductPurchaseConformanceFixture(input?: CreateGooglePlayProductPurchaseConformanceFixtureInput): Readonly<Record<string, unknown>>;

package/dist/google-play-purchase-conformance.js

@@ -0,0 +1,39 @@
+import { googlePlayProductPurchaseEvidenceSchema, } from './google-play-purchase';
+export const googlePlayProductPurchaseConformanceEvidence = Object.freeze({
+    schema: googlePlayProductPurchaseEvidenceSchema,
+    payload: Object.freeze({
+        purchaseToken: 'google-play-conformance-token',
+    }),
+});
+/**
+ * Builds a deterministic `purchases.productsv2` response for boundary and
+ * provider-client conformance tests. It intentionally contains no credentials,
+ * live purchase tokens, or environment-specific endpoints.
+ */
+export function createGooglePlayProductPurchaseConformanceFixture(input = {}) {
+    return {
+        productLineItem: [
+            {
+                productId: input.productId ?? 'coins_100_android',
+                productOfferDetails: {
+                    quantity: input.quantity ?? 1,
+                    refundableQuantity: input.refundableQuantity ?? 1,
+                    consumptionState: input.consumptionState ?? 'CONSUMPTION_STATE_YET_TO_BE_CONSUMED',
+                    ...(input.rentOffer === true ? { rentOfferDetails: {} } : {}),
+                },
+            },
+        ],
+        purchaseStateContext: {
+            purchaseState: input.purchaseState ?? 'PURCHASED',
+        },
+        orderId: input.orderId ?? 'GPA.conformance-1',
+        purchaseCompletionTime: input.purchaseCompletionTime ?? '2030-01-02T03:04:05.000Z',
+        acknowledgementState: input.acknowledgementState ?? 'ACKNOWLEDGEMENT_STATE_PENDING',
+        ...(input.obfuscatedExternalAccountId === undefined
+            ? {}
+            : { obfuscatedExternalAccountId: input.obfuscatedExternalAccountId }),
+        ...(input.obfuscatedExternalProfileId === undefined
+            ? {}
+            : { obfuscatedExternalProfileId: input.obfuscatedExternalProfileId }),
+    };
+}

package/dist/google-play-purchase.d.ts

@@ -0,0 +1,40 @@
+import type { GameServicesEvidenceVerifier, GameServicesPurchaseGrantFinalizer, VerifyPurchaseEvidenceInput } from './evidence-verification';
+export declare const googlePlayProductPurchaseEvidenceSchema = "google-play.product-purchase.v2";
+export type GooglePlayPurchaseState = 'PURCHASED' | 'CANCELLED' | 'PENDING' | 'PURCHASE_STATE_UNSPECIFIED';
+export type GooglePlayConsumptionState = 'CONSUMPTION_STATE_YET_TO_BE_CONSUMED' | 'CONSUMPTION_STATE_CONSUMED' | 'CONSUMPTION_STATE_UNSPECIFIED';
+export type GooglePlayAcknowledgementState = 'ACKNOWLEDGEMENT_STATE_PENDING' | 'ACKNOWLEDGEMENT_STATE_ACKNOWLEDGED' | 'ACKNOWLEDGEMENT_STATE_UNSPECIFIED';
+export interface GooglePlayProductPurchaseClient {
+  getProductPurchaseV2(input: {
+    readonly packageName: string;
+    readonly purchaseToken: string;
+    readonly signal: AbortSignal;
+  }): Promise<unknown>;
+  acknowledgeProductPurchase(input: {
+    readonly packageName: string;
+    readonly productId: string;
+    readonly purchaseToken: string;
+    readonly signal: AbortSignal;
+  }): Promise<void>;
+  consumeProductPurchase(input: {
+    readonly packageName: string;
+    readonly productId: string;
+    readonly purchaseToken: string;
+    readonly signal: AbortSignal;
+  }): Promise<void>;
+}
+export interface CreateGooglePlayProductPurchaseBoundaryInput {
+  readonly client: GooglePlayProductPurchaseClient;
+  readonly packageName: string;
+  readonly now?: () => string;
+  /**
+  * Explicitly permits purchases without a Google account identifier. Use only
+  * when the caller binds `playerId` to an authenticated application account.
+  */
+  readonly allowUnboundAuthenticatedPlayer?: boolean;
+  readonly resolveObfuscatedAccountId?: (playerId: string, signal: AbortSignal) => Promise<string | undefined> | string | undefined;
+  readonly resolveObfuscatedProfileId?: (playerId: string, signal: AbortSignal) => Promise<string | undefined> | string | undefined;
+}
+export interface GooglePlayProductPurchaseBoundary extends GameServicesPurchaseGrantFinalizer {
+  verifyPurchase(input: VerifyPurchaseEvidenceInput): ReturnType<GameServicesEvidenceVerifier['verifyPurchase']>;
+}
+export declare function createGooglePlayProductPurchaseBoundary(input: CreateGooglePlayProductPurchaseBoundaryInput): GooglePlayProductPurchaseBoundary;