@mpgd/game-services 0.6.0 → 0.8.0

package/dist/client.js

@@ -69,6 +69,7 @@ export function createGameServicesClient(input) {
                 platformTransactionId: purchase.transactionId,
                 idempotencyKey: purchaseInput.idempotencyKey,
                 purchasedAt: now(),
+                ...(purchase.evidence === undefined ? {} : { evidence: purchase.evidence }),
             });
             const result = {
                 status: verification.verified ? 'granted' : 'rejected',
@@ -135,6 +136,7 @@ export function createGameServicesClient(input) {
                     : { platformImpressionId: reward.ledgerEntryId }),
                 idempotencyKey: rewardInput.idempotencyKey,
                 completedAt: now(),
+                ...(reward.evidence === undefined ? {} : { evidence: reward.evidence }),
             });
             const result = {
                 status: claim.granted ? 'granted' : 'rejected',

package/dist/evidence-verification.d.ts

@@ -0,0 +1,34 @@
+import type { AdPlacements, ProductCatalog } from '@mpgd/catalog';
+import type { ClaimAdRewardRequest, EntitlementLedgerPayload, VerifyPurchaseRequest } from './types';
+export type EvidenceVerificationDecision = {
+  readonly status: 'verified';
+  readonly verificationId: string;
+  readonly verifiedAt: string;
+  readonly payload?: EntitlementLedgerPayload;
+} | {
+  readonly status: 'pending';
+  readonly reason?: string;
+} | {
+  readonly status: 'rejected';
+  readonly reason: string;
+};
+export interface VerifyPurchaseEvidenceInput {
+  readonly request: VerifyPurchaseRequest;
+  readonly product: ProductCatalog['products'][number];
+  readonly platformProductId: string;
+  readonly signal: AbortSignal;
+  readonly timeoutMs: number;
+}
+export interface VerifyAdRewardEvidenceInput {
+  readonly request: ClaimAdRewardRequest;
+  readonly placement: AdPlacements['placements'][number];
+  readonly platformPlacementId?: string;
+  readonly signal: AbortSignal;
+  readonly timeoutMs: number;
+}
+export interface GameServicesEvidenceVerifier {
+  verifyPurchase(input: VerifyPurchaseEvidenceInput): Promise<EvidenceVerificationDecision>;
+  verifyAdReward(input: VerifyAdRewardEvidenceInput): Promise<EvidenceVerificationDecision>;
+}
+export declare function createDevelopmentGameServicesEvidenceVerifier(now?: () => string): GameServicesEvidenceVerifier;
+export declare function createRejectingGameServicesEvidenceVerifier(): GameServicesEvidenceVerifier;

package/dist/evidence-verification.js

@@ -0,0 +1,34 @@
+export function createDevelopmentGameServicesEvidenceVerifier(now = () => new Date().toISOString()) {
+    return {
+        async verifyPurchase({ request }) {
+            return {
+                status: 'verified',
+                verificationId: `development:purchase:${request.target}:${request.platformTransactionId}`,
+                verifiedAt: now(),
+            };
+        },
+        async verifyAdReward({ request }) {
+            return {
+                status: 'verified',
+                verificationId: `development:ad-reward:${request.target}:${request.platformImpressionId ?? request.idempotencyKey}`,
+                verifiedAt: now(),
+            };
+        },
+    };
+}
+export function createRejectingGameServicesEvidenceVerifier() {
+    return {
+        async verifyPurchase() {
+            return {
+                status: 'rejected',
+                reason: 'EVIDENCE_VERIFIER_UNAVAILABLE',
+            };
+        },
+        async verifyAdReward() {
+            return {
+                status: 'rejected',
+                reason: 'EVIDENCE_VERIFIER_UNAVAILABLE',
+            };
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export * from './client';
 export * from './contract';
+export * from './evidence-verification';
 export * from './notification-delivery';
+export * from './platform-order';
 export * from './progress-link';
 export * from './runtime.js';
 export * from './server';

package/dist/index.js

@@ -1,6 +1,8 @@
 export * from './client';
 export * from './contract';
+export * from './evidence-verification';
 export * from './notification-delivery';
+export * from './platform-order';
 export * from './progress-link';
 export * from './runtime.js';
 export * from './server';

package/dist/platform-order.d.ts

@@ -0,0 +1,22 @@
+import type { PlatformEvidenceEnvelope } from '@mpgd/platform';
+export type PlatformOrderTarget = 'reddit';
+export interface FulfillPlatformOrderInput {
+  readonly target: PlatformOrderTarget;
+  readonly orderId: string;
+  readonly playerId: string;
+  readonly platformSku: string;
+  readonly paidAt: string;
+  readonly evidence: PlatformEvidenceEnvelope;
+}
+export interface RefundPlatformOrderInput {
+  readonly target: PlatformOrderTarget;
+  readonly orderId: string;
+  readonly playerId: string;
+  readonly platformSku: string;
+  readonly refundedAt: string;
+  readonly evidence: PlatformEvidenceEnvelope;
+}
+export type PlatformOrderIdempotencyKey = `${PlatformOrderTarget}:${string}`;
+export declare function createPlatformOrderIdempotencyKey(input: Pick<FulfillPlatformOrderInput, 'target' | 'orderId'>): PlatformOrderIdempotencyKey;
+export declare function assertFulfillPlatformOrderInput(input: FulfillPlatformOrderInput): FulfillPlatformOrderInput;
+export declare function assertRefundPlatformOrderInput(input: RefundPlatformOrderInput): RefundPlatformOrderInput;

package/dist/platform-order.js

@@ -0,0 +1,65 @@
+export function createPlatformOrderIdempotencyKey(input) {
+    assertPlatformOrderTarget(input.target);
+    assertIdentifier(input.orderId, 'orderId');
+    return `${input.target}:${input.orderId}`;
+}
+export function assertFulfillPlatformOrderInput(input) {
+    assertPlatformOrderBase(input, 'FulfillPlatformOrderInput');
+    assertIsoTimestamp(input.paidAt, 'paidAt');
+    return input;
+}
+export function assertRefundPlatformOrderInput(input) {
+    assertPlatformOrderBase(input, 'RefundPlatformOrderInput');
+    assertIsoTimestamp(input.refundedAt, 'refundedAt');
+    return input;
+}
+function assertPlatformOrderBase(input, label) {
+    assertRecord(input, label);
+    assertPlatformOrderTarget(input.target);
+    assertIdentifier(input.orderId, 'orderId');
+    assertIdentifier(input.playerId, 'playerId');
+    assertIdentifier(input.platformSku, 'platformSku');
+    assertEvidenceEnvelope(input.evidence);
+}
+function assertPlatformOrderTarget(input) {
+    if (input !== 'reddit') {
+        throw new TypeError('target must be reddit.');
+    }
+}
+function assertIdentifier(input, label) {
+    if (typeof input !== 'string'
+        || input.length === 0
+        || input.length > 256
+        || input.trim() !== input
+        || /[\u0000-\u001f\u007f]/u.test(input)) {
+        throw new TypeError(`${label} must be a non-empty identifier.`);
+    }
+}
+function assertIsoTimestamp(input, label) {
+    if (typeof input !== 'string'
+        || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/u.test(input)
+        || Number.isNaN(Date.parse(input))) {
+        throw new TypeError(`${label} must be an ISO 8601 UTC timestamp.`);
+    }
+}
+function assertEvidenceEnvelope(input) {
+    assertRecord(input, 'evidence');
+    assertIdentifier(input.schema, 'evidence.schema');
+    assertRecord(input.payload, 'evidence.payload');
+    for (const [key, value] of Object.entries(input.payload)) {
+        assertIdentifier(key, 'evidence.payload key');
+        if (typeof value !== 'string'
+            && typeof value !== 'number'
+            && typeof value !== 'boolean') {
+            throw new TypeError('evidence.payload values must be strings, numbers, or booleans.');
+        }
+        if (typeof value === 'number' && !Number.isFinite(value)) {
+            throw new TypeError('evidence.payload numbers must be finite.');
+        }
+    }
+}
+function assertRecord(input, label) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new TypeError(`${label} must be an object.`);
+    }
+}

package/dist/server.d.ts

@@ -2,6 +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 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 {
@@ -12,6 +13,8 @@ export interface CreateGameServicesBackendInput {
   readonly analyticsSessionId?: string;
   readonly now?: () => string;
   readonly version?: string;
+  readonly evidenceVerifier?: GameServicesEvidenceVerifier;
+  readonly evidenceVerificationTimeoutMs?: number;
 }
 export interface GameServicesBackendApiHandler {
   readonly version?: string;
@@ -22,6 +25,16 @@ export interface GameServicesBackendErrorResponse {
 }
 export interface GameServicesStore {
   recordEntitlementGrant(input: EntitlementLedgerGrant): Promise<EntitlementLedgerResult>;
+  findEntitlementTransactionByIdempotency?(input: {
+    readonly source: EntitlementLedgerGrant['source'];
+    readonly playerId: string;
+    readonly idempotencyKey: string;
+  }): Promise<ProductGrantTransaction | undefined>;
+  findEntitlementTransactionByEvidenceVerificationId?(input: {
+    readonly source: EntitlementLedgerGrant['source'];
+    readonly evidenceVerificationId: string;
+  }): Promise<ProductGrantTransaction | undefined>;
+  findEntitlementTransactionByPlatformEvidence?(input: EntitlementPlatformEvidenceIdentity): Promise<ProductGrantTransaction | undefined>;
   getEntitlementTransaction(ledgerEntryId: string): Promise<ProductGrantTransaction | undefined>;
   listEntitlementTransactions(): Promise<readonly ProductGrantTransaction[]>;
   recordLeaderboardScore(input: RecordLeaderboardScoreRequest, options?: {
@@ -30,6 +43,11 @@ export interface GameServicesStore {
   getLeaderboardTransaction(ledgerEntryId: string): Promise<LeaderboardScoreTransaction | undefined>;
   listLeaderboardTransactions(): Promise<readonly LeaderboardScoreTransaction[]>;
 }
+export interface EntitlementPlatformEvidenceIdentity {
+  readonly source: Extract<EntitlementLedgerGrant['source'], 'purchase' | 'ad_reward'>;
+  readonly target: string;
+  readonly platformEvidenceId: string;
+}
 export interface CreateGameServicesFetchHandlerOptions {
   readonly corsHeaders?: CorsHeaders;
   readonly healthPath?: string;
@@ -43,10 +61,22 @@ export interface GameServicesOrpcContext {
 }
 export declare class InMemoryGameServicesStore implements GameServicesStore {
   private readonly entitlementTransactionsByKey;
+  private readonly entitlementTransactionsByEvidence;
+  private readonly entitlementTransactionsByPlatformEvidence;
   private readonly entitlementTransactionsById;
   private readonly leaderboardTransactionsByRun;
   private readonly leaderboardTransactionsById;
   recordEntitlementGrant(input: EntitlementLedgerGrant): Promise<EntitlementLedgerResult>;
+  findEntitlementTransactionByIdempotency(input: {
+    readonly source: EntitlementLedgerGrant['source'];
+    readonly playerId: string;
+    readonly idempotencyKey: string;
+  }): Promise<ProductGrantTransaction | undefined>;
+  findEntitlementTransactionByEvidenceVerificationId(input: {
+    readonly source: EntitlementLedgerGrant['source'];
+    readonly evidenceVerificationId: string;
+  }): Promise<ProductGrantTransaction | undefined>;
+  findEntitlementTransactionByPlatformEvidence(input: EntitlementPlatformEvidenceIdentity): Promise<ProductGrantTransaction | undefined>;
   getEntitlementTransaction(ledgerEntryId: string): Promise<ProductGrantTransaction | undefined>;
   listEntitlementTransactions(): Promise<readonly ProductGrantTransaction[]>;
   recordLeaderboardScore(input: RecordLeaderboardScoreRequest, options?: {
@@ -57,6 +87,9 @@ export declare class InMemoryGameServicesStore implements GameServicesStore {
   private rankFor;
   private sortedLeaderboardTransactions;
 }
+export declare class EvidenceAlreadyProcessedError extends Error {
+  constructor();
+}
 export declare function createInMemoryGameServicesStore(): InMemoryGameServicesStore;
 export declare function createGameServicesBackend(input: CreateGameServicesBackendInput): GameServicesBackendApi;
 export declare function createGameServicesBackendApiHandler(input: CreateGameServicesBackendInput): GameServicesBackendApiHandler;