@mpgd/game-services 0.8.2 → 0.10.0

package/dist/verified-leaderboard-durability-conformance.js

@@ -0,0 +1,193 @@
+import { assertRecordVerifiedLeaderboardAttemptResponse, assertVerifiedLeaderboardSnapshot, } from './verified-leaderboard';
+export const verifiedLeaderboardDurabilityConformanceScenarios = [
+    'replacement-after-interrupted-retained-write',
+    'concurrent-retry-after-interrupted-retained-write',
+    'snapshot-after-interrupted-retained-write',
+];
+const durabilityScenarioRunners = {
+    'replacement-after-interrupted-retained-write': runReplacementAfterInterruptedRetainedWriteScenario,
+    'concurrent-retry-after-interrupted-retained-write': runConcurrentRetryAfterInterruptedRetainedWriteScenario,
+    'snapshot-after-interrupted-retained-write': runSnapshotAfterInterruptedRetainedWriteScenario,
+};
+/**
+ * Runs provider-neutral recovery checks that require a provider-specific fault
+ * boundary. It complements the semantic conformance suite and deliberately
+ * does not prescribe a shared persistence implementation.
+ */
+export async function runVerifiedLeaderboardDurabilityConformance(input) {
+    const now = input.now ?? '2030-01-02T03:04:05.000Z';
+    const passedScenarios = [];
+    for (const scenario of verifiedLeaderboardDurabilityConformanceScenarios) {
+        const runScenario = durabilityScenarioRunners[scenario];
+        let fixture;
+        let scenarioError;
+        let scenarioFailed = false;
+        try {
+            fixture = await input.createFixture({ scenario, now });
+            await runScenario(fixture);
+        }
+        catch (error) {
+            scenarioError = error;
+            scenarioFailed = true;
+        }
+        let cleanupError;
+        let cleanupFailed = false;
+        try {
+            await fixture?.dispose?.();
+        }
+        catch (error) {
+            cleanupError = error;
+            cleanupFailed = true;
+        }
+        if (scenarioFailed) {
+            throw new Error(`Verified leaderboard durability conformance failed: ${scenario}.`, {
+                cause: cleanupFailed
+                    ? new AggregateError([scenarioError, cleanupError], `Scenario and fixture cleanup both failed: ${scenario}.`)
+                    : scenarioError,
+            });
+        }
+        if (cleanupFailed) {
+            const message = `Verified leaderboard durability conformance cleanup failed: ${scenario}.`;
+            throw new Error(message, { cause: cleanupError });
+        }
+        passedScenarios.push(scenario);
+    }
+    return { passedScenarios };
+}
+/**
+ * Wraps an atomic provider so the next armed record commits successfully but
+ * its caller observes an interruption. Use a provider-specific fixture when
+ * the implementation has a recoverable boundary inside a multi-write flow.
+ */
+export function createAmbiguousCommitVerifiedLeaderboardDurabilityFixture(provider, dispose) {
+    let interruptNextRecord = false;
+    return {
+        service: {
+            async recordVerifiedAttempt(input) {
+                const response = await provider.recordVerifiedAttempt(input);
+                if (interruptNextRecord) {
+                    interruptNextRecord = false;
+                    throw new Error('Simulated verified leaderboard response interruption.');
+                }
+                return response;
+            },
+            getSnapshot: (input) => provider.getSnapshot(input),
+        },
+        interruptNextRetainedRecord() {
+            if (interruptNextRecord) {
+                throw new Error('A verified leaderboard interruption is already armed.');
+            }
+            interruptNextRecord = true;
+        },
+        ...(dispose === undefined ? {} : { dispose }),
+    };
+}
+async function runReplacementAfterInterruptedRetainedWriteScenario(fixture) {
+    const interrupted = createAttempt('replacement-after-interrupted-retained-write', 'interrupted', 10, '2030-01-02T03:00:00.000Z');
+    const later = createAttempt('replacement-after-interrupted-retained-write', 'later-better', 20, '2030-01-02T03:01:00.000Z');
+    fixture.interruptNextRetainedRecord();
+    await assertRejects(() => fixture.service.recordVerifiedAttempt(interrupted), 'the armed retained record must surface an interruption');
+    const laterResponse = await fixture.service.recordVerifiedAttempt(later);
+    assertRecordVerifiedLeaderboardAttemptResponse(laterResponse);
+    assertEqual(laterResponse.retained, true, 'the later better attempt must be retained');
+    assertEqual(laterResponse.entry.attemptId, later.attempt.attemptId, 'the later better attempt must replace the interrupted retained entry');
+    const retry = await fixture.service.recordVerifiedAttempt(interrupted);
+    assertOriginalInterruptedDecision(retry, interrupted);
+    const snapshot = await fixture.service.getSnapshot({
+        leaderboardId: interrupted.definition.leaderboardId,
+        participantId: interrupted.attempt.participantId,
+    });
+    assert(snapshot !== undefined, 'the recovered board must return a snapshot');
+    assertVerifiedLeaderboardSnapshot(snapshot);
+    assertEqual(snapshot.totalParticipants, 1, 'the replacement must keep one participant');
+    assertEqual(snapshot.entries.length, 1, 'the replacement must keep one ranked entry');
+    assertEqual(snapshot.entries[0]?.participantId, later.attempt.participantId, 'the ranked snapshot must contain the replacement participant');
+    assertEqual(snapshot.entries[0]?.attemptId, later.attempt.attemptId, 'the ranked snapshot must contain the later better attempt');
+    assertEqual(snapshot.entries[0]?.score, later.attempt.score, 'the ranked snapshot must contain the later better score');
+    assertEqual(snapshot.participantEntry?.attemptId, later.attempt.attemptId, 'the final snapshot must retain the later better attempt');
+}
+async function runConcurrentRetryAfterInterruptedRetainedWriteScenario(fixture) {
+    const interrupted = createAttempt('concurrent-retry-after-interrupted-retained-write', 'interrupted', 10, '2030-01-02T03:00:00.000Z');
+    fixture.interruptNextRetainedRecord();
+    await assertRejects(() => fixture.service.recordVerifiedAttempt(interrupted), 'the armed retained record must surface an interruption');
+    const retries = await Promise.all([
+        fixture.service.recordVerifiedAttempt(interrupted),
+        fixture.service.recordVerifiedAttempt(interrupted),
+    ]);
+    for (const retry of retries) {
+        assertOriginalInterruptedDecision(retry, interrupted);
+    }
+    const snapshot = await fixture.service.getSnapshot({
+        leaderboardId: interrupted.definition.leaderboardId,
+    });
+    assert(snapshot !== undefined, 'the concurrently recovered board must return a snapshot');
+    assertVerifiedLeaderboardSnapshot(snapshot);
+    assertEqual(snapshot.totalParticipants, 1, 'concurrent retries must not duplicate participants');
+    assertEqual(snapshot.entries.length, 1, 'concurrent retries must not duplicate retained rows');
+}
+async function runSnapshotAfterInterruptedRetainedWriteScenario(fixture) {
+    const interrupted = createAttempt('snapshot-after-interrupted-retained-write', 'interrupted', 10, '2030-01-02T03:00:00.000Z');
+    fixture.interruptNextRetainedRecord();
+    await assertRejects(() => fixture.service.recordVerifiedAttempt(interrupted), 'the armed retained record must surface an interruption');
+    const snapshot = await fixture.service.getSnapshot({
+        leaderboardId: interrupted.definition.leaderboardId,
+        participantId: interrupted.attempt.participantId,
+    });
+    assert(snapshot !== undefined, 'reads must recover an interrupted retained record');
+    assertVerifiedLeaderboardSnapshot(snapshot);
+    assertEqual(snapshot.totalParticipants, 1, 'recovery must restore one participant');
+    assertEqual(snapshot.entries.length, 1, 'recovery must restore one ranked entry');
+    assertEqual(snapshot.entries[0]?.participantId, interrupted.attempt.participantId, 'reads must expose the recovered participant in ranked entries');
+    assertEqual(snapshot.entries[0]?.attemptId, interrupted.attempt.attemptId, 'reads must expose the recovered attempt in ranked entries');
+    assertEqual(snapshot.entries[0]?.score, interrupted.attempt.score, 'reads must expose the recovered score in ranked entries');
+    assertEqual(snapshot.participantEntry?.attemptId, interrupted.attempt.attemptId, 'reads must expose the recovered retained entry');
+    const retry = await fixture.service.recordVerifiedAttempt(interrupted);
+    assertOriginalInterruptedDecision(retry, interrupted);
+}
+function assertOriginalInterruptedDecision(response, interrupted) {
+    assertRecordVerifiedLeaderboardAttemptResponse(response);
+    assertEqual(response.alreadyProcessed, true, 'retries must detect the interrupted write');
+    assertEqual(response.retained, true, 'retries must preserve the original retained decision');
+    assertEqual(response.entry.attemptId, interrupted.attempt.attemptId, 'retries must preserve the original response entry');
+    assertEqual(response.entry.score, interrupted.attempt.score, 'retries must preserve the original response score');
+}
+function createAttempt(scenario, suffix, score, completedAt) {
+    return {
+        definition: {
+            leaderboardId: `durability:${scenario}`,
+            scoreOrder: 'descending',
+            attemptSelection: 'best',
+        },
+        attempt: {
+            participantId: `participant:${scenario}`,
+            attemptId: `attempt:${scenario}:${suffix}`,
+            score,
+            completedAt,
+            verification: {
+                authorityId: 'verified-leaderboard-durability-conformance',
+                evidenceId: `evidence:${scenario}:${suffix}`,
+                verifiedAt: completedAt,
+            },
+        },
+    };
+}
+async function assertRejects(callback, message) {
+    let rejected = false;
+    try {
+        await callback();
+    }
+    catch {
+        rejected = true;
+    }
+    assert(rejected, message);
+}
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+function assertEqual(actual, expected, message) {
+    if (actual !== expected) {
+        throw new Error(`${message}: expected ${String(expected)}, received ${String(actual)}.`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/game-services",
-  "version": "0.8.2",
+  "version": "0.10.0",
   "description": "Client, contract, server, store, and test helpers for authoritative mpgd game services.",
   "license": "MIT",
   "repository": {
@@ -29,6 +29,30 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./admob-ssv": {
+      "types": "./dist/admob-ssv.d.ts",
+      "default": "./dist/admob-ssv.js"
+    },
+    "./admob-ssv-conformance": {
+      "types": "./dist/admob-ssv-conformance.d.ts",
+      "default": "./dist/admob-ssv-conformance.js"
+    },
+    "./app-store-verifier": {
+      "types": "./dist/app-store-verifier.d.ts",
+      "default": "./dist/app-store-verifier.js"
+    },
+    "./app-store-verifier-conformance": {
+      "types": "./dist/app-store-verifier-conformance.d.ts",
+      "default": "./dist/app-store-verifier-conformance.js"
+    },
+    "./apps-in-toss-evidence-verification": {
+      "types": "./dist/apps-in-toss-evidence-verification.d.ts",
+      "default": "./dist/apps-in-toss-evidence-verification.js"
+    },
+    "./apps-in-toss-evidence-verification-conformance": {
+      "types": "./dist/apps-in-toss-evidence-verification-conformance.d.ts",
+      "default": "./dist/apps-in-toss-evidence-verification-conformance.js"
+    },
     "./client": {
       "types": "./dist/client.d.ts",
       "default": "./dist/client.js"
@@ -41,6 +65,14 @@
       "types": "./dist/evidence-verification.d.ts",
       "default": "./dist/evidence-verification.js"
     },
+    "./google-play-purchase": {
+      "types": "./dist/google-play-purchase.d.ts",
+      "default": "./dist/google-play-purchase.js"
+    },
+    "./google-play-purchase-conformance": {
+      "types": "./dist/google-play-purchase-conformance.d.ts",
+      "default": "./dist/google-play-purchase-conformance.js"
+    },
     "./notification-delivery": {
       "types": "./dist/notification-delivery.d.ts",
       "default": "./dist/notification-delivery.js"
@@ -76,18 +108,23 @@
     "./verified-leaderboard-conformance": {
       "types": "./dist/verified-leaderboard-conformance.d.ts",
       "default": "./dist/verified-leaderboard-conformance.js"
+    },
+    "./verified-leaderboard-durability-conformance": {
+      "types": "./dist/verified-leaderboard-durability-conformance.d.ts",
+      "default": "./dist/verified-leaderboard-durability-conformance.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
+    "@noble/secp256k1": "3.1.0",
     "@orpc/client": "2.0.0-beta.14",
     "@orpc/contract": "2.0.0-beta.14",
     "@orpc/server": "2.0.0-beta.14",
-    "@mpgd/analytics": "0.3.6",
-    "@mpgd/catalog": "0.4.0",
-    "@mpgd/platform": "0.6.0"
+    "@mpgd/catalog": "0.5.0",
+    "@mpgd/platform": "0.7.0",
+    "@mpgd/analytics": "0.3.7"
   },
   "devDependencies": {
     "ttsc": "0.18.4",
@@ -103,6 +140,6 @@
     "lint": "ttsc --noEmit",
     "format": "ttsc format",
     "fix": "ttsc fix",
-    "test": "cd ../.. && node tools/run-ttsx.mjs packages/game-services/src/client.test.ts && node tools/run-ttsx.mjs packages/game-services/src/runtime.test.ts && node tools/run-ttsx.mjs packages/game-services/src/server.test.ts && node tools/run-ttsx.mjs packages/game-services/src/platform-order.test.ts && node tools/run-ttsx.mjs packages/game-services/src/progress-link.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notification-delivery.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-transport.test.ts"
+    "test": "cd ../.. && node tools/run-ttsx.mjs packages/game-services/src/client.test.ts && node tools/run-ttsx.mjs packages/game-services/src/runtime.test.ts && node tools/run-ttsx.mjs packages/game-services/src/types.test.ts && node tools/run-ttsx.mjs packages/game-services/src/server.test.ts && node tools/run-ttsx.mjs packages/game-services/src/google-play-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/platform-order.test.ts && node tools/run-ttsx.mjs packages/game-services/src/progress-link.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notification-delivery.test.ts && node tools/run-ttsx.mjs packages/game-services/src/admob-ssv.test.ts && node tools/run-ttsx.mjs packages/game-services/src/app-store-verifier.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-evidence-verification-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-durability-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-transport.test.ts"
   }
 }