Initial commit

test/e2e-prod/_setup/adminClient.ts

@@ -0,0 +1,77 @@
+// Minimal fetch wrapper for the LiveOps platform/admin HTTP API used by the seed
+// and by tests' admin-side assertions. Retries network errors and 5xx with backoff;
+// fails fast on 4xx.
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+export class ApiError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly path: string,
+    public readonly body: string,
+  ) {
+    super(`HTTP ${status} on ${path}: ${body.slice(0, 400)}`);
+    this.name = 'ApiError';
+  }
+}
+
+export interface AdminClient {
+  setToken(token: string): void;
+  readonly token: string | undefined;
+  get<T>(path: string, opts?: { auth?: boolean }): Promise<T>;
+  post<T>(path: string, body?: unknown, opts?: { auth?: boolean }): Promise<T>;
+  put<T>(path: string, body?: unknown, opts?: { auth?: boolean }): Promise<T>;
+  del<T>(path: string, opts?: { auth?: boolean }): Promise<T>;
+}
+
+export function createAdminClient(baseUrl: string): AdminClient {
+  let token: string | undefined;
+
+  async function request<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+    opts?: { auth?: boolean },
+  ): Promise<T> {
+    const url = `${baseUrl}${path}`;
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+    if (opts?.auth !== false && token) headers['Authorization'] = `Bearer ${token}`;
+
+    let lastErr: unknown;
+    for (let attempt = 0; attempt < 4; attempt++) {
+      try {
+        const res = await fetch(url, {
+          method,
+          headers,
+          body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const text = await res.text();
+        if (res.status >= 500) {
+          lastErr = new ApiError(res.status, path, text);
+          await sleep(300 * (attempt + 1));
+          continue;
+        }
+        if (!res.ok) throw new ApiError(res.status, path, text);
+        return (text ? JSON.parse(text) : undefined) as T;
+      } catch (err) {
+        if (err instanceof ApiError) throw err; // 4xx — don't retry
+        lastErr = err; // network error — retry
+        await sleep(300 * (attempt + 1));
+      }
+    }
+    throw lastErr;
+  }
+
+  return {
+    setToken(t: string) {
+      token = t;
+    },
+    get token() {
+      return token;
+    },
+    get: (path, opts) => request('GET', path, undefined, opts),
+    post: (path, body, opts) => request('POST', path, body, opts),
+    put: (path, body, opts) => request('PUT', path, body, opts),
+    del: (path, opts) => request('DELETE', path, undefined, opts),
+  };
+}

test/e2e-prod/_setup/artifact.ts

@@ -0,0 +1,19 @@
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import type { SeedArtifact } from './types.js';
+
+export const ARTIFACT_PATH = resolve(process.cwd(), '.e2e-prod.local.json');
+
+export function writeArtifact(artifact: SeedArtifact): void {
+  writeFileSync(ARTIFACT_PATH, JSON.stringify(artifact, null, 2));
+}
+
+export function readArtifact(): SeedArtifact | null {
+  if (!existsSync(ARTIFACT_PATH)) return null;
+  return JSON.parse(readFileSync(ARTIFACT_PATH, 'utf8')) as SeedArtifact;
+}
+
+export function removeArtifact(): void {
+  if (existsSync(ARTIFACT_PATH)) rmSync(ARTIFACT_PATH);
+}

test/e2e-prod/_setup/globalSetup.ts

@@ -0,0 +1,48 @@
+// Vitest globalSetup for the production e2e suite.
+//
+// Setup: seeds a fresh project on prod (unless RUDDER_E2E_PROJECT_KEY is provided) and
+// writes .e2e-prod.local.json for the tests to read.
+// Teardown: deletes the seeded project (default). Set RUDDER_E2E_KEEP=1 to keep it.
+
+import { runSeed, deleteProject } from './seed.js';
+import { readArtifact, writeArtifact, removeArtifact } from './artifact.js';
+import type { SeedArtifact } from './types.js';
+
+export default async function setup(): Promise<() => Promise<void>> {
+  const baseUrl = process.env.RUDDER_E2E_BASE_URL ?? 'https://api.rudder.build';
+
+  // Externally-provided project: skip seeding, just verify an artifact/env exists.
+  if (process.env.RUDDER_E2E_PROJECT_KEY) {
+    const existing = readArtifact();
+    if (!existing) {
+      writeArtifact({
+        baseUrl,
+        projectKey: process.env.RUDDER_E2E_PROJECT_KEY,
+        // Remaining fields are unknown for an external project; tests relying on the
+        // seeded dataset/admin token will require a real seed run.
+      } as unknown as SeedArtifact);
+    }
+    return async () => {};
+  }
+
+  const log = (m: string) => console.log(`[seed] ${m}`);
+  log(`seeding ${baseUrl} ...`);
+  const artifact = await runSeed(baseUrl, log);
+  writeArtifact(artifact);
+  log(`seed complete: project=${artifact.projectId}`);
+
+  return async () => {
+    if (process.env.RUDDER_E2E_KEEP === '1') {
+      console.log('[seed] RUDDER_E2E_KEEP=1 — leaving project in place');
+      return;
+    }
+    try {
+      await deleteProject(artifact);
+      console.log(`[seed] deleted project ${artifact.projectId}`);
+    } catch (err) {
+      console.warn(`[seed] failed to delete project ${artifact.projectId}: ${String(err)}`);
+    } finally {
+      removeArtifact();
+    }
+  };
+}

test/e2e-prod/_setup/harness.ts

@@ -0,0 +1,99 @@
+// Test-side helpers: load the seed artifact, build SDK clients against prod, and
+// reach the admin API for wallet grants / player inspection.
+
+import { RudderClient } from '../../../src/client/RudderClient.js';
+import type { RemoteConfigShape } from '../../../src/state/RemoteConfigState.js';
+import type { TokenStore } from '../../../src/token/TokenStore.js';
+import { createAdminClient, type AdminClient } from './adminClient.js';
+import { readArtifact } from './artifact.js';
+import type { SeedArtifact } from './types.js';
+
+type RuntimeOptions = {
+  planStateStore?: {
+    state: string | null;
+    load(): Promise<void>;
+    save(state: string | null): Promise<void>;
+  } | null;
+  loginEvent?: string | null;
+};
+
+/** Loads the seed artifact; RUDDER_E2E_* env vars override file values. */
+export function loadArtifact(): SeedArtifact {
+  const file = readArtifact();
+  if (!file) {
+    throw new Error(
+      'No seed artifact (.e2e-prod.local.json). Run `npm run test:e2e-prod` (globalSetup seeds automatically).',
+    );
+  }
+  return {
+    ...file,
+    baseUrl: process.env.RUDDER_E2E_BASE_URL ?? file.baseUrl,
+    projectKey: process.env.RUDDER_E2E_PROJECT_KEY ?? file.projectKey,
+  };
+}
+
+export function createInMemoryTokenStore(): TokenStore {
+  let access: string | null = null;
+  let refresh: string | null = null;
+  return {
+    getAccessToken: () => access,
+    getRefreshToken: () => refresh,
+    saveTokens: (a, r) => {
+      access = a;
+      refresh = r;
+    },
+    clear: () => {
+      access = null;
+      refresh = null;
+    },
+  };
+}
+
+/** A client with no auth yet (in-memory tokens, no IndexedDB persistence). */
+export function makeProdClient<TConfig extends RemoteConfigShape = RemoteConfigShape>(
+  artifact: SeedArtifact = loadArtifact(),
+  runtime: RuntimeOptions = { planStateStore: null, loginEvent: null },
+): RudderClient<TConfig> {
+  return new RudderClient<TConfig>({
+    baseUrl: artifact.baseUrl,
+    projectKey: artifact.projectKey,
+    tokenStore: createInMemoryTokenStore(),
+    runtime,
+  });
+}
+
+/** A device-authenticated client. In Node each call mints a fresh player (ephemeral device id). */
+export async function freshPlayer<TConfig extends RemoteConfigShape = RemoteConfigShape>(
+  artifact: SeedArtifact = loadArtifact(),
+  runtime?: RuntimeOptions,
+): Promise<RudderClient<TConfig>> {
+  const client = makeProdClient<TConfig>(artifact, runtime);
+  await client.auth.loginWithDevice({ region: 'en', language: 'en' });
+  return client;
+}
+
+/** Admin (operator) API client authenticated with the seeded operator token. */
+export function adminApi(artifact: SeedArtifact = loadArtifact()): AdminClient {
+  const api = createAdminClient(artifact.baseUrl);
+  api.setToken(artifact.adminToken);
+  return api;
+}
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+/** Retries a read until ok(result) holds — absorbs release/cache reload lag. */
+export async function withReadRetry<T>(
+  fn: () => Promise<T>,
+  ok: (value: T) => boolean,
+  tries = 8,
+  gapMs = 1500,
+): Promise<T> {
+  let last = await fn();
+  if (ok(last)) return last;
+  for (let i = 1; i < tries; i++) {
+    await sleep(gapMs);
+    last = await fn();
+    if (ok(last)) return last;
+  }
+  return last;
+}

test/e2e-prod/_setup/seed.ts

@@ -0,0 +1,311 @@
+// Production seed: registers an operator, creates a project, configures staging
+// content (items, remote configs, leaderboard, store with free+paid offers, a
+// global quest, a scenario), and promotes it to the prod snapshot the runtime SDK serves.
+// Excludes realtime & analytics.
+//
+// The scenario flow uses the SDK runtime's exact node `data` keys and handle names —
+// the game's plan builder copies node.data verbatim into the execution plan
+// (see liveops-game/shared/fsm/plan_builder.go), so what we store is what the SDK runs.
+
+import { createAdminClient, type AdminClient } from './adminClient.js';
+import type { SeedArtifact } from './types.js';
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+interface ReleaseResponse {
+  id: string;
+  status: string;
+  version: number;
+}
+
+interface QuestResponse {
+  id: string;
+  name: string;
+  status: string;
+  objectives?: Array<{ id: string; metric: string; target: number }>;
+  rewards?: Array<{ itemId?: string; currency?: string; amount: number }>;
+}
+
+interface StoreResponse {
+  id: string;
+  name: string;
+  data?: { slug?: string };
+  offers?: Array<{
+    id: string;
+    name: string;
+    contents?: Array<{ itemId: string; amount: number }>;
+  }>;
+}
+
+function buildFlow(scenarioSlug: string) {
+  return {
+    nodes: [
+      { id: 'trigger_1', type: 'trigger', data: { triggerType: 'event', onEvent: 'session_start' } },
+      { id: 'notify_1', type: 'notification', data: { title: 'Welcome', message: 'Welcome to the game!' } },
+      {
+        id: 'rc_1',
+        type: 'remote_config_override',
+        data: { patches: [{ path: 'spawn_rate', valueType: 'float', value: '3.0' }] },
+      },
+      { id: 'store_1', type: 'store', data: { storeSlug: scenarioSlug } },
+      { id: 'cond_1', type: 'condition', data: { logic: 'AND', rules: [] } },
+      { id: 'notify_2', type: 'notification', data: { title: 'Thanks', message: 'Enjoy your purchase!' } },
+    ],
+    edges: [
+      { id: 'e1', source: 'trigger_1', sourceHandle: 'onActivate', target: 'notify_1' },
+      { id: 'e2', source: 'notify_1', sourceHandle: 'output', target: 'rc_1' },
+      { id: 'e3', source: 'rc_1', sourceHandle: 'output', target: 'store_1' },
+      { id: 'e4', source: 'store_1', sourceHandle: 'onPurchase', target: 'cond_1' },
+      { id: 'e5', source: 'cond_1', sourceHandle: 'true', target: 'notify_2' },
+    ],
+  };
+}
+
+async function pollRelease(
+  api: AdminClient,
+  projPath: string,
+  env: string,
+  releaseId: string,
+  log: (m: string) => void,
+): Promise<void> {
+  const deadline = Date.now() + 60_000;
+  while (Date.now() < deadline) {
+    const releases = await api.get<ReleaseResponse[]>(
+      `${projPath}/releases?environment=${env}&limit=20&offset=0`,
+    );
+    const rel = releases.find((r) => r.id === releaseId);
+    if (rel) {
+      if (rel.status === 'completed') {
+        log(`release ${releaseId} completed (v${rel.version})`);
+        return;
+      }
+      if (rel.status === 'failed') {
+        throw new Error(`release ${releaseId} failed`);
+      }
+    }
+    await sleep(1500);
+  }
+  throw new Error(`release ${releaseId} did not complete within 60s`);
+}
+
+export async function runSeed(
+  baseUrl: string,
+  log: (m: string) => void = () => {},
+): Promise<SeedArtifact> {
+  const api = createAdminClient(baseUrl);
+  const ts = Date.now();
+  const authoringEnv = 'staging';
+  const runtimeEnv = 'prod';
+  const q = `?environment=${authoringEnv}`;
+  const prodQ = `?environment=${runtimeEnv}`;
+  const adminEmail = `e2e+${ts}@rudder.build`;
+  const password = `Passw0rd!e2e-${ts}`;
+
+  // 1. Register operator (open registration; no approval gate at the API layer).
+  const auth = await api.post<{ accessToken: string; refreshToken: string }>(
+    '/platform/v1/authorization/register',
+    { email: adminEmail, password, fullName: 'E2E Bot' },
+    { auth: false },
+  );
+  api.setToken(auth.accessToken);
+  log(`registered ${adminEmail}`);
+
+  // 2. Project.
+  const project = await api.post<{ id: string; key: string; name: string }>(
+    '/platform/v1/projects',
+    { name: `e2e-${ts}` },
+  );
+  const projPath = `/platform/v1/projects/${project.id}`;
+  log(`project ${project.id} key=${project.key}`);
+
+  // 3. Staging environment (idempotent — may already exist).
+  try {
+    await api.post(`${projPath}/environments`, { projectId: project.id, name: authoringEnv });
+  } catch {
+    // already exists / not required — content POSTs below are the real test
+  }
+
+  // 4. Item (granted as a paid offer's contents).
+  const item = await api.post<{ id: string; name: string }>(`${projPath}/items${q}`, {
+    projectId: project.id,
+    environment: authoringEnv,
+    name: 'Gold Coin',
+    tags: ['currency'],
+  });
+
+  // 5. Remote configs — one per value type.
+  const remoteConfigs: Array<{ key: string; value: string; valueType: string }> = [
+    { key: 'max_energy', value: '100', valueType: 'int' },
+    { key: 'spawn_rate', value: '1.5', valueType: 'float' },
+    { key: 'feature_x', value: 'true', valueType: 'bool' },
+    { key: 'welcome_text', value: 'hi', valueType: 'string' },
+    { key: 'shop_layout', value: '{"cols":3}', valueType: 'json' },
+  ];
+  for (const rc of remoteConfigs) {
+    await api.post(`${projPath}/remote-configs${q}`, {
+      projectId: project.id,
+      environment: authoringEnv,
+      ...rc,
+    });
+  }
+  log(`created ${remoteConfigs.length} remote configs`);
+
+  // 6. Leaderboard.
+  await api.post(`${projPath}/leaderboards${q}`, {
+    projectId: project.id,
+    environment: authoringEnv,
+    name: 'Weekly Score',
+    slug: 'weekly-score',
+    metric: 'score',
+    resetPeriod: 'weekly',
+    sortingOrder: 'desc',
+    maxEntries: 100,
+  });
+
+  // 7. Store with a free offer and a paid (currency) offer with a purchase limit.
+  // The runtime resolves a store's slug from data.slug (liveops-game shop cache), and
+  // the CreateStore API has no slug field — so we set it via data.
+  const storeSlug = 'starter-shop';
+  const store = await api.post<{ id: string; offers: Array<{ id: string; name: string }> }>(
+    `${projPath}/stores${q}`,
+    {
+      projectId: project.id,
+      environment: authoringEnv,
+      name: 'Starter Shop',
+      description: 'E2E shop',
+      data: { slug: storeSlug },
+      offers: [
+        { name: 'Welcome Gift', contents: [{ itemId: item.id, amount: 10 }], price: { currency: 'soft', amount: 0 } },
+        {
+          name: 'Gold Pack',
+          contents: [{ itemId: item.id, amount: 50 }],
+          price: { currency: 'soft', amount: 100 },
+          maxPurchases: 2,
+        },
+      ],
+    },
+  );
+  log(`store ${storeSlug} (${store.id}) with ${store.offers?.length ?? 0} offers`);
+  const paidOffer = store.offers?.find((o) => o.name === 'Gold Pack');
+  if (!paidOffer?.id) {
+    throw new Error('seeded paid offer did not return an id');
+  }
+
+  // 8. Global quest: buying the paid offer completes it; claim grants extra item reward.
+  const questName = 'Buy Gold Pack Quest';
+  const questObjectiveId = 'buy-gold-pack';
+  const questTarget = 1;
+  const questMetric = `purchase.offer:${paidOffer.id}`;
+  const questRewardAmount = 7;
+  const quest = await api.post<QuestResponse>(`${projPath}/quests${q}`, {
+    projectId: project.id,
+    environment: authoringEnv,
+    name: questName,
+    objectives: [{ id: questObjectiveId, metric: questMetric, target: questTarget }],
+    rewards: [{ itemId: item.id, amount: questRewardAmount }],
+  });
+  log(`quest ${quest.id} staged for metric ${questMetric}`);
+
+  // 9. Scenario (must be live now: startAt <= now <= endAt).
+  const startAt = new Date(ts - 3600_000).toISOString();
+  const endAt = new Date(ts + 365 * 24 * 3600_000).toISOString();
+  const scenario = await api.post<{ id: string }>(`${projPath}/scenarios${q}`, {
+    projectId: project.id,
+    environment: authoringEnv,
+    name: 'Onboarding',
+    description: 'e2e onboarding',
+    startAt,
+    endAt,
+  });
+
+  // 10. Scenario flow (trigger -> notification -> rc override -> store -> boundary -> notification).
+  await api.put(`${projPath}/scenarios/${scenario.id}`, {
+    projectId: project.id,
+    scenarioId: scenario.id,
+    flow: buildFlow(storeSlug),
+  });
+  log(`scenario ${scenario.id} flow set`);
+
+  // 11. Promote staging content to prod (the runtime serves prod/latest.json).
+  const release = await api.post<ReleaseResponse>(`${projPath}/releases/promote`);
+  await pollRelease(api, projPath, runtimeEnv, release.id, log);
+
+  const prodStores = await api.get<StoreResponse[]>(`${projPath}/stores${prodQ}`);
+  const prodStore = prodStores.find((s) => s.data?.slug === storeSlug || s.name === 'Starter Shop');
+  if (!prodStore) {
+    throw new Error(`promoted store ${storeSlug} was not found in ${runtimeEnv}`);
+  }
+  const prodPaidOffer = prodStore.offers?.find((o) => o.name === 'Gold Pack');
+  if (!prodPaidOffer?.id) {
+    throw new Error('promoted paid offer did not return an id');
+  }
+  const prodRewardItemId = prodPaidOffer.contents?.[0]?.itemId;
+  if (!prodRewardItemId) {
+    throw new Error('promoted paid offer did not return a reward item id');
+  }
+
+  const prodQuests = await api.get<QuestResponse[]>(`${projPath}/quests${prodQ}`);
+  const prodQuest = prodQuests.find((q) => q.name === questName);
+  if (!prodQuest?.id) {
+    throw new Error(`promoted quest ${questName} was not found in ${runtimeEnv}`);
+  }
+  const prodQuestMetric = prodQuest.objectives?.find((o) => o.id === questObjectiveId)?.metric;
+  if (!prodQuestMetric) {
+    throw new Error(`promoted quest ${questName} did not return metric ${questObjectiveId}`);
+  }
+  const prodQuestRewardItemId = prodQuest.rewards?.[0]?.itemId;
+  if (!prodQuestRewardItemId) {
+    throw new Error(`promoted quest ${questName} did not return reward item id`);
+  }
+
+  // 12. Settle: let the game service hot-reload caches from the new snapshot.
+  await sleep(3000);
+
+  return {
+    baseUrl,
+    projectId: project.id,
+    projectKey: project.key,
+    adminToken: auth.accessToken,
+    adminEmail,
+    environment: runtimeEnv,
+    seededAt: new Date(ts).toISOString(),
+    releaseId: release.id,
+    store: {
+      name: 'Starter Shop',
+      slug: storeSlug,
+      freeOfferName: 'Welcome Gift',
+      paidOfferName: 'Gold Pack',
+      paidOfferId: prodPaidOffer.id,
+      paidPrice: { currency: 'soft', amount: 100 },
+      paidMaxPurchases: 2,
+      grantedItemName: 'Gold Coin',
+      paidGrantAmount: 50,
+    },
+    quest: {
+      id: prodQuest.id,
+      name: questName,
+      objectiveId: questObjectiveId,
+      metric: prodQuestMetric,
+      target: questTarget,
+      rewardItemId: prodQuestRewardItemId,
+      rewardAmount: questRewardAmount,
+    },
+    leaderboard: { slug: 'weekly-score', metric: 'score' },
+    item: { id: prodRewardItemId, name: item.name },
+    remoteConfigs: {
+      maxEnergy: 100,
+      spawnRate: 1.5,
+      featureX: true,
+      welcomeText: 'hi',
+      shopLayout: { cols: 3 },
+      spawnRateOverride: 3.0,
+    },
+    scenario: { id: scenario.id, event: 'session_start' },
+  };
+}
+
+export async function deleteProject(artifact: SeedArtifact): Promise<void> {
+  const api = createAdminClient(artifact.baseUrl);
+  api.setToken(artifact.adminToken);
+  await api.del(`/platform/v1/projects/${artifact.projectId}`);
+}

test/e2e-prod/_setup/types.ts

@@ -0,0 +1,46 @@
+// Shared types for the production e2e harness.
+
+/** Persisted seed output, written to .e2e-prod.local.json and read by tests. */
+export interface SeedArtifact {
+  baseUrl: string;
+  projectId: string;
+  projectKey: string;
+  /** Operator (platform) bearer token — used for admin calls (wallet grant, player details). */
+  adminToken: string;
+  adminEmail: string;
+  environment: string;
+  seededAt: string;
+  releaseId: string;
+  store: {
+    name: string;
+    slug: string;
+    freeOfferName: string;
+    paidOfferName: string;
+    paidOfferId: string;
+    paidPrice: { currency: string; amount: number };
+    paidMaxPurchases: number;
+    grantedItemName: string;
+    paidGrantAmount: number;
+  };
+  quest: {
+    id: string;
+    name: string;
+    objectiveId: string;
+    metric: string;
+    target: number;
+    rewardItemId: string;
+    rewardAmount: number;
+  };
+  leaderboard: { slug: string; metric: string };
+  item: { id: string; name: string };
+  remoteConfigs: {
+    maxEnergy: number;
+    spawnRate: number;
+    featureX: boolean;
+    welcomeText: string;
+    shopLayout: Record<string, unknown>;
+    /** spawn_rate value the scenario's remote_config_override applies. */
+    spawnRateOverride: number;
+  };
+  scenario: { id: string; event: string };
+}

test/e2e-prod/health.e2e.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { loadArtifact } from './_setup/harness.js';
+
+// Smoke gate: if egress to prod is blocked or the gateway is down, fail fast here.
+describe('e2e-prod: health', () => {
+  let baseUrl: string;
+  beforeAll(() => {
+    baseUrl = loadArtifact().baseUrl;
+  });
+
+  it('GET /health is ok', async () => {
+    const res = await fetch(`${baseUrl}/health`);
+    expect(res.ok).toBe(true);
+    const body = (await res.json()) as { status?: string };
+    expect(body.status).toBe('ok');
+  });
+
+  it('content + game gRPC backends are serving', async () => {
+    // /readyz may be 503 if analytics is not_serving (out of scope here); assert the
+    // backends this suite actually uses are serving.
+    const res = await fetch(`${baseUrl}/readyz`);
+    const body = (await res.json()) as { grpc?: Record<string, string> };
+    expect(body.grpc?.content).toBe('serving');
+    expect(body.grpc?.game).toBe('serving');
+  });
+});

test/e2e-prod/leaderboards.e2e.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { freshPlayer, loadArtifact, withReadRetry } from './_setup/harness.js';
+import type { SeedArtifact } from './_setup/types.js';
+
+describe('e2e-prod: leaderboards', () => {
+  let artifact: SeedArtifact;
+  beforeAll(() => {
+    artifact = loadArtifact();
+  });
+
+  it('submits a score and sees it in the ranking', async () => {
+    const client = await freshPlayer(artifact);
+    const me = (await client.player.reload()).player?.id;
+    expect(me).toBeTruthy();
+
+    const lb = client.leaderboards.findBySlug(artifact.leaderboard.slug);
+    const score = 4242;
+    await lb.submit(score);
+
+    const entries = await withReadRetry(
+      () => lb.list(50),
+      (list) => list.some((e) => e.playerId === me),
+    );
+    const mine = entries.find((e) => e.playerId === me);
+    expect(mine).toBeDefined();
+    // int64 fields (score, rank) serialize as JSON strings via protojson — coerce to number.
+    expect(Number(mine?.score)).toBe(score);
+    expect(Number(mine?.rank ?? 0)).toBeGreaterThanOrEqual(1);
+  });
+});

test/e2e-prod/player.e2e.test.ts

@@ -0,0 +1,11 @@
+import { describe, it, expect } from 'vitest';
+import { freshPlayer } from './_setup/harness.js';
+
+describe('e2e-prod: player', () => {
+  it('device login yields a profile with a player id and wallets array', async () => {
+    const client = await freshPlayer();
+    const profile = await client.player.reload();
+    expect(profile.player?.id).toBeTruthy();
+    expect(Array.isArray(profile.wallets)).toBe(true);
+  });
+});

test/e2e-prod/purchase.e2e.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { adminApi, freshPlayer, loadArtifact, withReadRetry } from './_setup/harness.js';
+import type { SeedArtifact } from './_setup/types.js';
+import type { RudderClient } from '../../src/client/RudderClient.js';
+import type { OfferHandle } from '../../src/state/shops.js';
+
+// Exercises the (newly implemented) wallet + inventory + purchase backend end-to-end:
+// admin grant -> debit on buy -> inventory credit -> idempotency -> max_purchases -> insufficient funds.
+interface AdminWalletDetails {
+  currencyCode: string;
+  balance: number;
+}
+interface AdminInventoryItem {
+  itemId: string;
+  amount: number;
+}
+interface AdminPlayerDetails {
+  wallets?: AdminWalletDetails[];
+  inventory?: AdminInventoryItem[];
+}
+
+describe('e2e-prod: purchase (wallet/inventory/limits)', () => {
+  let artifact: SeedArtifact;
+  beforeAll(() => {
+    artifact = loadArtifact();
+  });
+
+  async function resolvePaidOffer(client: RudderClient): Promise<OfferHandle> {
+    const stores = await withReadRetry(
+      () => client.stores.reload(),
+      (s) => s.some((store) => store.name === artifact.store.name && store.offers.length > 0),
+    );
+    const store = stores.find((s) => s.name === artifact.store.name)!;
+    return store.offers.find((o) => o.name === artifact.store.paidOfferName)!;
+  }
+
+  async function balance(client: RudderClient, currency: string): Promise<number> {
+    const profile = await client.player.reload();
+    // int64 fields serialize as JSON strings via protojson — coerce to number.
+    return Number(profile.wallets?.find((w) => w.currency === currency)?.balance ?? 0);
+  }
+
+  it('grants currency, debits on buy, credits inventory, is idempotent, and enforces the purchase limit', async () => {
+    const client = await freshPlayer(artifact);
+    const playerId = (await client.player.reload()).player!.id!;
+    const api = adminApi(artifact);
+    const currency = artifact.store.paidPrice.currency;
+    const price = artifact.store.paidPrice.amount;
+    const offer = await resolvePaidOffer(client);
+
+    // 1. Grant currency via the new admin endpoint.
+    await api.post(`/game/v1/projects/${artifact.projectId}/players/${playerId}/wallet/adjust`, {
+      currencyCode: currency,
+      amount: 1000,
+      reason: 'e2e grant',
+    });
+    const granted = await withReadRetry(
+      () => balance(client, currency),
+      (b) => b === 1000,
+    );
+    expect(granted).toBe(1000);
+
+    // 2. First paid buy: success + wallet debited.
+    const buy1 = await offer.buy();
+    expect(buy1.success).toBe(true);
+    expect(buy1.purchaseId).toBeTruthy();
+    expect(await balance(client, currency)).toBe(1000 - price);
+
+    // 3. Inventory credited (verified via admin player details).
+    const details = await api.get<AdminPlayerDetails>(
+      `/game/v1/projects/${artifact.projectId}/players/${playerId}`,
+    );
+    const inv = details.inventory?.find((i) => i.itemId === artifact.item.id);
+    expect(Number(inv?.amount)).toBe(artifact.store.paidGrantAmount);
+
+    // 4. Idempotency: the same key twice charges once.
+    const key = crypto.randomUUID();
+    const a = await offer.buy({ idempotencyKey: key });
+    const b = await offer.buy({ idempotencyKey: key });
+    expect(a.success).toBe(true);
+    expect(b.success).toBe(true);
+    expect(await balance(client, currency)).toBe(1000 - price * 2);
+
+    // 5. max_purchases (2) reached -> a new distinct buy fails (no charge).
+    const overLimit = await offer.buy();
+    expect(overLimit.success).toBe(false);
+    expect(overLimit.error ?? '').toContain('limit');
+    expect(await balance(client, currency)).toBe(1000 - price * 2);
+  });
+
+  it('rejects a paid purchase with insufficient funds', async () => {
+    const poor = await freshPlayer(artifact);
+    const offer = await resolvePaidOffer(poor);
+    const res = await offer.buy();
+    expect(res.success).toBe(false);
+    expect(res.error ?? '').toContain('insufficient');
+  });
+});

test/e2e-prod/remoteConfig.e2e.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { freshPlayer, loadArtifact, withReadRetry } from './_setup/harness.js';
+import type { SeedArtifact } from './_setup/types.js';
+
+interface GameRemoteConfig extends Record<string, unknown> {
+  max_energy: number;
+  spawn_rate: number;
+  feature_x: boolean;
+  welcome_text: string;
+  shop_layout: Record<string, unknown>;
+}
+
+describe('e2e-prod: remoteConfig', () => {
+  let artifact: SeedArtifact;
+  beforeAll(() => {
+    artifact = loadArtifact();
+  });
+
+  it('loads typed configs matching the seeded values', async () => {
+    const rc = artifact.remoteConfigs;
+    const client = await withReadRetry(
+      () => freshPlayer<GameRemoteConfig>(artifact),
+      (candidate) => candidate.remoteConfig.get('max_energy', 0) === rc.maxEnergy,
+    );
+    expect(client.remoteConfig.status).toBe('ready');
+
+    expect(client.remoteConfig.get('max_energy', 0)).toBe(rc.maxEnergy);
+    expect(client.remoteConfig.get('spawn_rate', 0)).toBeCloseTo(rc.spawnRate);
+    expect(client.remoteConfig.get('feature_x', false)).toBe(rc.featureX);
+    expect(client.remoteConfig.get('welcome_text', '')).toBe(rc.welcomeText);
+    expect(client.remoteConfig.get('shop_layout', {} as Record<string, unknown>)).toEqual(rc.shopLayout);
+  });
+});

test/e2e-prod/scenarios.e2e.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, beforeAll, vi } from 'vitest';
+import { loadArtifact, makeProdClient } from './_setup/harness.js';
+import type { SeedArtifact } from './_setup/types.js';
+import type { NotificationEffect, StoreOfferEffect } from '../../src/index.js';
+import { getScenarioRuntime } from '../../src/client/RudderClient.js';
+
+describe('e2e-prod: scenarios', () => {
+  let artifact: SeedArtifact;
+  beforeAll(() => {
+    artifact = loadArtifact();
+  });
+
+  it('runs onboarding: notification -> rc override -> store -> boundary callback -> notification', async () => {
+    const notifications: NotificationEffect[] = [];
+    let storeOffer: StoreOfferEffect | undefined;
+    let runCompleted = false;
+
+    const client = makeProdClient(artifact, {
+      planStateStore: null,
+      loginEvent: artifact.scenario.event,
+    });
+
+    client.effects.onNotification((effect) => { notifications.push(effect); });
+    client.effects.onStoreOffer((effect) => {
+      storeOffer = effect;
+    });
+    const runtime = await getScenarioRuntime(client);
+    runtime.onRunCompleted = () => {
+      runCompleted = true;
+    };
+    await client.auth.loginWithDevice({ region: 'en', language: 'en' });
+
+    // First notification dispatched.
+    await vi.waitFor(() => expect(notifications.length).toBe(1), { timeout: 10_000 });
+    await notifications[0].done();
+
+    // remote_config_override applies, then the store offer surfaces.
+    await vi.waitFor(() => expect(storeOffer).toBeDefined(), { timeout: 10_000 });
+    expect(client.remoteConfig.get('spawn_rate', 0)).toBeCloseTo(
+      artifact.remoteConfigs.spawnRateOverride,
+    );
+
+    // Buy crosses the server boundary (POST /sdk/v1/scenarios/callback) -> second notification.
+    const offer = storeOffer!.offers.find((o) => o.name === artifact.store.paidOfferName)!;
+    await storeOffer!.buy(offer);
+    await vi.waitFor(() => expect(notifications.length).toBe(2), { timeout: 15_000 });
+    await notifications[1].done();
+
+    await vi.waitFor(() => expect(runtime.isRunning).toBe(false), { timeout: 10_000 });
+    expect(runCompleted).toBe(true);
+  });
+});

test/e2e-prod/storage.e2e.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { freshPlayer } from './_setup/harness.js';
+
+describe('e2e-prod: storage', () => {
+  it('save -> get -> delete round-trip', async () => {
+    const client = await freshPlayer();
+    const payload = JSON.stringify({ level: 7 });
+    const item = { id: 'slot_1', type: 'savegame', data: payload };
+
+    await client.storage.save([item]);
+
+    // The server may assign its own item id, so match on type + data, not the client id.
+    // v0.2 fetches the whole storage; filtering by type is client-side.
+    const got = await client.storage.reload();
+    expect(got.items?.some((i) => i.type === 'savegame' && i.data === payload)).toBe(true);
+
+    await client.storage.delete('savegame');
+
+    const after = await client.storage.reload();
+    expect(after.items?.some((i) => i.data === payload)).toBeFalsy();
+  });
+});

test/e2e-prod/stores.e2e.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { freshPlayer, loadArtifact, withReadRetry } from './_setup/harness.js';
+import type { SeedArtifact } from './_setup/types.js';
+
+describe('e2e-prod: stores', () => {
+  let artifact: SeedArtifact;
+  beforeAll(() => {
+    artifact = loadArtifact();
+  });
+
+  it('lists the seeded store with its free + paid offers', async () => {
+    const client = await freshPlayer(artifact);
+    const stores = await withReadRetry(
+      () => client.stores.reload(),
+      (r) => r.length > 0,
+    );
+    const store = stores.find((s) => s.name === artifact.store.name);
+    expect(store).toBeDefined();
+
+    const offerNames = store!.offers.map((o) => o.name);
+    expect(offerNames).toContain(artifact.store.freeOfferName);
+    expect(offerNames).toContain(artifact.store.paidOfferName);
+  });
+
+  it('buys the free offer successfully', async () => {
+    const client = await freshPlayer(artifact);
+    const stores = await withReadRetry(
+      () => client.stores.reload(),
+      (s) => s.some((store) => store.name === artifact.store.name && store.offers.length > 0),
+    );
+    const store = stores.find((s) => s.name === artifact.store.name)!;
+    const free = store.offers.find((o) => o.name === artifact.store.freeOfferName)!;
+    const res = await free.buy();
+    expect(res.success).toBe(true);
+    expect(res.purchaseId).toBeTruthy();
+  });
+});