@mpgd/adapter-verse8 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,7 +1,27 @@
-import { Verse8 } from '@verse8/platform/vanilla';
+import { Verse8Ads, } from '@verse8/ads';
+import { Verse8, VXShop } from '@verse8/platform/vanilla';
 import { createUnsupportedCapabilities, } from '@mpgd/platform';
+import { verse8AdsRewardEvidenceSchema } from './ads-contract.js';
+export { verse8AdsRewardEvidenceSchema } from './ads-contract.js';
+export function createVerse8CommerceProducts(catalog) {
+    return normalizeCommerceProducts(catalog.products.flatMap((product) => {
+        const platformProductId = product.platformProductIds.verse8;
+        return platformProductId === undefined || product.grant.type === 'resource'
+            ? []
+            : [
+                {
+                    id: product.id,
+                    type: product.type,
+                    platformProductId,
+                },
+            ];
+    }));
+}
 export function createVerse8PlatformGateway(options = {}) {
     const authClient = options.authClient ?? createDefaultAuthClient();
+    const adsClient = options.adsClient ?? Verse8Ads;
+    const adsAvailable = options.resolveAdPlacementId !== undefined;
+    const commerce = createVerse8Commerce(options.vxShop);
     const pauseListeners = new Set();
     const resumeListeners = new Set();
     const visibility = options.visibility ?? resolveVisibilitySource();
@@ -17,6 +37,11 @@ export function createVerse8PlatformGateway(options = {}) {
         async getCapabilities() {
             return {
                 ...createUnsupportedCapabilities(),
+                nativeIap: commerce !== undefined,
+                nativeAds: adsAvailable,
+                rewardedAds: adsAvailable,
+                interstitialAds: adsAvailable,
+                cloudSave: options.agent8Storage !== undefined,
                 localizedContent: true,
             };
         },
@@ -28,32 +53,84 @@ export function createVerse8PlatformGateway(options = {}) {
                 return resolveVerse8Identity(authClient).session;
             },
         },
-        commerce: {
-            async getProducts() {
-                return [];
-            },
-            async purchase() {
-                return {
-                    status: 'failed',
-                    entitlementIds: [],
-                };
-            },
-            async getEntitlements() {
-                return [];
-            },
-        },
+        commerce: commerce ?? createUnavailableVerse8Commerce(),
         ads: {
             async preload() { },
-            async showRewarded() {
-                return {
-                    status: 'unavailable',
-                    rewardGranted: false,
-                };
+            async showRewarded(input) {
+                const placementId = options.resolveAdPlacementId?.(input.placementId);
+                if (placementId === undefined) {
+                    return unavailableReward();
+                }
+                try {
+                    const result = await adsClient.showRewarded({
+                        placementId,
+                        ...(options.adsTimeoutMs === undefined
+                            ? {}
+                            : { timeoutMs: options.adsTimeoutMs }),
+                        meta: {
+                            logicalPlacementId: input.placementId,
+                        },
+                    });
+                    if (result.status === 'rewarded') {
+                        return {
+                            status: 'completed',
+                            rewardGranted: true,
+                            ledgerEntryId: result.requestId,
+                            evidence: {
+                                schema: verse8AdsRewardEvidenceSchema,
+                                payload: {
+                                    requestId: result.requestId,
+                                    placementId,
+                                    ...(result.platform === undefined ? {} : { platform: result.platform }),
+                                },
+                            },
+                        };
+                    }
+                    if (result.status === 'dismissed') {
+                        return {
+                            status: 'skipped',
+                            rewardGranted: false,
+                        };
+                    }
+                    return result.error.code === 'unsupported_env'
+                        ? unavailableReward()
+                        : {
+                            status: 'failed',
+                            rewardGranted: false,
+                        };
+                }
+                catch {
+                    return {
+                        status: 'failed',
+                        rewardGranted: false,
+                    };
+                }
             },
-            async showInterstitial() {
-                return {
-                    status: 'unavailable',
-                };
+            async showInterstitial(input) {
+                const placementId = options.resolveAdPlacementId?.(input.placementId);
+                if (placementId === undefined) {
+                    return { status: 'unavailable' };
+                }
+                try {
+                    const result = await adsClient.showInterstitial({
+                        placementId,
+                        ...(options.adsTimeoutMs === undefined
+                            ? {}
+                            : { timeoutMs: options.adsTimeoutMs }),
+                        meta: {
+                            logicalPlacementId: input.placementId,
+                        },
+                    });
+                    if (result.status === 'dismissed') {
+                        return { status: 'shown' };
+                    }
+                    return result.error.code === 'unsupported_env'
+                        ? { status: 'unavailable' }
+                        : { status: 'skipped' };
+                }
+                catch {
+                    return { status: 'skipped' };
+                }
             },
         },
         leaderboard: {
@@ -76,15 +153,21 @@ export function createVerse8PlatformGateway(options = {}) {
         },
         storage: {
             async load(input) {
-                const storage = options.storage ?? resolveStorage();
-                const value = storage?.getItem(storageKey(input.key));
+                if (options.agent8Storage !== undefined) {
+                    return options.agent8Storage.load(input);
+                }
+                const storage = resolveStorage(options.storage);
+                const value = storage.getItem(storageKey(authClient, input.key));
                 return value === undefined || value === null
                     ? null
                     : { value: JSON.parse(value) };
             },
             async save(input) {
-                const storage = options.storage ?? resolveStorage();
-                storage?.setItem(storageKey(input.key), JSON.stringify(input.value));
+                if (options.agent8Storage !== undefined) {
+                    await options.agent8Storage.save(input);
+                    return;
+                }
+                resolveStorage(options.storage).setItem(storageKey(authClient, input.key), serializeStorageValue(input.value));
             },
         },
         presentation: {
@@ -99,6 +182,144 @@ export function createVerse8PlatformGateway(options = {}) {
         },
     };
 }
+function createVerse8Commerce(options) {
+    if (options === undefined) {
+        return undefined;
+    }
+    if (options.purchaseEventAuthority !== 'agent8-server' || options.products.length === 0) {
+        return undefined;
+    }
+    const products = normalizeCommerceProducts(options.products);
+    const client = options.client ?? VXShop;
+    let initialized = false;
+    const ensureInitialized = () => {
+        if (initialized) {
+            return;
+        }
+        if (options.init === undefined) {
+            client.init({ autoRefresh: false });
+        }
+        else {
+            client.init({ ...options.init, autoRefresh: false });
+        }
+        initialized = true;
+    };
+    const loadEntitlements = async () => {
+        try {
+            return [...await options.loadEntitlements()];
+        }
+        catch {
+            return [];
+        }
+    };
+    return {
+        async getProducts() {
+            try {
+                ensureInitialized();
+                await client.refresh();
+                const shopItems = new Map(client.getItems().map((item) => [item.productId, item]));
+                return products.flatMap((product) => {
+                    const item = shopItems.get(product.platformProductId);
+                    return item === undefined
+                        ? []
+                        : [{
+                                id: product.id,
+                                type: product.type,
+                                title: item.name,
+                                description: item.description,
+                                price: {
+                                    formatted: `${item.price} VX`,
+                                    currencyCode: 'VX',
+                                },
+                            }];
+                });
+            }
+            catch {
+                return [];
+            }
+        },
+        async purchase(input) {
+            const product = products.find((candidate) => candidate.id === input.productId);
+            if (product === undefined) {
+                return failedPurchase();
+            }
+            try {
+                if (!(options.canOpenShop ?? canOpenDefaultVerse8Shop)()) {
+                    return failedPurchase();
+                }
+                ensureInitialized();
+                await client.refresh();
+                const item = client.getItem(product.platformProductId);
+                if (item === undefined
+                    || item.purchasable !== true
+                    || item.purchaseLimitReached === true) {
+                    return failedPurchase();
+                }
+                client.buyItem(product.platformProductId);
+                return {
+                    status: 'pending',
+                    entitlementIds: [],
+                };
+            }
+            catch {
+                return failedPurchase();
+            }
+        },
+        async restore() {
+            return {
+                restoredEntitlements: await loadEntitlements(),
+            };
+        },
+        getEntitlements: loadEntitlements,
+    };
+}
+function normalizeCommerceProducts(products) {
+    const logicalIds = new Set();
+    const platformIds = new Set();
+    return products.map((product) => {
+        const platformProductId = product.platformProductId.trim();
+        if (product.id.trim().length === 0 || platformProductId.length === 0) {
+            throw new Error('Verse8 commerce product IDs must be non-empty.');
+        }
+        if (logicalIds.has(product.id) || platformIds.has(platformProductId)) {
+            throw new Error('Verse8 commerce product IDs must be unique.');
+        }
+        logicalIds.add(product.id);
+        platformIds.add(platformProductId);
+        return {
+            ...product,
+            platformProductId,
+        };
+    });
+}
+function createUnavailableVerse8Commerce() {
+    return {
+        async getProducts() {
+            return [];
+        },
+        async purchase() {
+            return failedPurchase();
+        },
+        async getEntitlements() {
+            return [];
+        },
+    };
+}
+function failedPurchase() {
+    return {
+        status: 'failed',
+        entitlementIds: [],
+    };
+}
+function canOpenDefaultVerse8Shop() {
+    return typeof window !== 'undefined' && window.parent !== window;
+}
+function unavailableReward() {
+    return {
+        status: 'unavailable',
+        rewardGranted: false,
+    };
+}
 function createDefaultAuthClient() {
     return {
         getUser(options) {
@@ -139,11 +360,31 @@ function createResolvedIdentity(credential, identityLevel, trustLevel) {
         },
     };
 }
-function storageKey(key) {
-    return `mpgd:verse8:${key}`;
+function storageKey(authClient, key) {
+    const playerId = resolveVerse8Identity(authClient).player?.playerId;
+    const identityNamespace = playerId === undefined ? 'guest' : playerId.toLowerCase();
+    return `mpgd:verse8:${identityNamespace}:${key}`;
 }
-function resolveStorage() {
-    return typeof localStorage === 'undefined' ? undefined : localStorage;
+function resolveStorage(override) {
+    if (override !== undefined) {
+        return override;
+    }
+    try {
+        if (globalThis.localStorage !== undefined) {
+            return globalThis.localStorage;
+        }
+    }
+    catch {
+        // Access to browser storage can be denied by the embedding environment.
+    }
+    throw new Error('Verse8 local storage is unavailable.');
+}
+function serializeStorageValue(value) {
+    const serialized = JSON.stringify(value);
+    if (typeof serialized !== 'string') {
+        throw new Error('Verse8 local storage values must be JSON serializable.');
+    }
+    return serialized;
 }
 function resolveVisibilitySource() {
     return typeof document === 'undefined' ? undefined : document;

package/dist/server.d.ts

@@ -0,0 +1,40 @@
+import type { GameServicesEvidenceVerifier } from '@mpgd/game-services';
+export declare const defaultVerse8AdsVerifierBaseUrl = "https://ads-verifier.verse8.io";
+export interface Verse8AdsVerifierReward {
+  readonly amount: number;
+  readonly type: string;
+}
+export interface Verse8AdsVerificationRecord {
+  readonly verified: boolean;
+  readonly status?: 'verified' | 'consumed' | 'pending';
+  readonly reward?: Verse8AdsVerifierReward;
+  readonly requestId?: string;
+  readonly placementId?: string;
+  readonly userId?: string;
+  readonly adNetwork?: 'google';
+  readonly verifiedAt?: string;
+  readonly consumedAt?: string;
+  readonly error?: string;
+}
+export interface Verse8AdsVerifierClient {
+  consume(input: {
+    readonly requestId: string;
+    readonly signal: AbortSignal;
+  }): Promise<Verse8AdsVerificationRecord>;
+}
+export type Verse8AdsVerifierAuthorization = string | (() => string | Promise<string>);
+export interface CreateVerse8AdsVerifierHttpClientInput {
+  readonly authorization: Verse8AdsVerifierAuthorization;
+  readonly baseUrl?: string;
+  readonly fetch?: typeof fetch;
+}
+export interface CreateVerse8AdsEvidenceVerifierInput {
+  readonly client: Verse8AdsVerifierClient;
+}
+export declare class Verse8AdsVerifierHttpError extends Error {
+  readonly status: number;
+  readonly code: string | undefined;
+  constructor(status: number, code?: string);
+}
+export declare function createVerse8AdsVerifierHttpClient(input: CreateVerse8AdsVerifierHttpClientInput): Verse8AdsVerifierClient;
+export declare function createVerse8AdsEvidenceVerifier(input: CreateVerse8AdsEvidenceVerifierInput): GameServicesEvidenceVerifier;

package/dist/server.js

@@ -0,0 +1,258 @@
+import { verse8AdsRewardEvidenceSchema } from './ads-contract.js';
+export const defaultVerse8AdsVerifierBaseUrl = 'https://ads-verifier.verse8.io';
+const maximumVerifierResponseLength = 65536;
+export class Verse8AdsVerifierHttpError extends Error {
+    status;
+    code;
+    constructor(status, code) {
+        super(`Verse8 Ads verifier request failed with HTTP ${status}.`);
+        this.name = 'Verse8AdsVerifierHttpError';
+        this.status = status;
+        this.code = code;
+    }
+}
+export function createVerse8AdsVerifierHttpClient(input) {
+    const endpoint = verifierEndpoint(input.baseUrl ?? defaultVerse8AdsVerifierBaseUrl);
+    const fetcher = input.fetch ?? readGlobalFetch();
+    return {
+        async consume({ requestId, signal }) {
+            requireNonEmptyString(requestId, 'requestId');
+            const authorization = await resolveAuthorization(input.authorization);
+            const response = await fetcher(endpoint, {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    Authorization: authorization,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ requestId }),
+                signal,
+            });
+            const body = await readBoundedJson(response);
+            if (!response.ok && !isVerse8AdsVerificationRecord(body)) {
+                throw new Verse8AdsVerifierHttpError(response.status, readErrorCode(body));
+            }
+            const record = assertVerse8AdsVerificationRecord(body);
+            if (!response.ok && record.status !== 'consumed') {
+                throw new Verse8AdsVerifierHttpError(response.status, record.error);
+            }
+            return record;
+        },
+    };
+}
+export function createVerse8AdsEvidenceVerifier(input) {
+    return {
+        async verifyPurchase() {
+            return rejected('VERSE8_PURCHASE_EVIDENCE_UNSUPPORTED');
+        },
+        async verifyAdReward(verificationInput) {
+            return verifyVerse8AdReward(input.client, verificationInput);
+        },
+    };
+}
+async function verifyVerse8AdReward(client, input) {
+    const { request, platformPlacementId } = input;
+    if (request.target !== 'verse8') {
+        return rejected('VERSE8_AD_TARGET_REQUIRED');
+    }
+    if (platformPlacementId === undefined || platformPlacementId.length === 0) {
+        return rejected('VERSE8_AD_PLACEMENT_UNCONFIGURED');
+    }
+    const requestId = request.platformImpressionId;
+    if (requestId === undefined) {
+        return rejected('VERSE8_AD_REQUEST_ID_REQUIRED');
+    }
+    if (request.evidence?.schema !== verse8AdsRewardEvidenceSchema) {
+        return rejected('VERSE8_AD_EVIDENCE_SCHEMA_INVALID');
+    }
+    const evidenceRequestId = readEvidenceString(request.evidence.payload, 'requestId');
+    const evidencePlacementId = readEvidenceString(request.evidence.payload, 'placementId');
+    if (evidenceRequestId !== requestId) {
+        return rejected('VERSE8_AD_REQUEST_ID_MISMATCH');
+    }
+    if (evidencePlacementId !== platformPlacementId) {
+        return rejected('VERSE8_AD_PLACEMENT_MISMATCH');
+    }
+    const record = await client.consume({
+        requestId,
+        signal: input.signal,
+    });
+    if (record.status === 'pending') {
+        return {
+            status: 'pending',
+            reason: 'VERSE8_AD_EVIDENCE_PENDING',
+        };
+    }
+    if (record.status === 'consumed') {
+        return rejected('VERSE8_AD_EVIDENCE_CONSUMED');
+    }
+    if (record.status === 'verified' && !record.verified) {
+        return rejected('VERSE8_AD_VERIFIER_RESPONSE_INCONSISTENT');
+    }
+    if (!record.verified) {
+        return {
+            status: 'pending',
+            reason: 'VERSE8_AD_EVIDENCE_PENDING',
+        };
+    }
+    if (record.requestId !== requestId) {
+        return rejected('VERSE8_AD_VERIFIED_REQUEST_MISMATCH');
+    }
+    if (record.placementId !== platformPlacementId) {
+        return rejected('VERSE8_AD_VERIFIED_PLACEMENT_MISMATCH');
+    }
+    if (record.userId === undefined || !sameVerse8User(record.userId, request.playerId)) {
+        return rejected('VERSE8_AD_VERIFIED_USER_MISMATCH');
+    }
+    const verifiedAt = normalizeTimestamp(record.verifiedAt);
+    if (verifiedAt === undefined) {
+        return rejected('VERSE8_AD_VERIFIED_AT_INVALID');
+    }
+    return {
+        status: 'verified',
+        verificationId: `verse8:ad-reward:${requestId}`,
+        verifiedAt,
+        payload: {
+            verse8RequestId: requestId,
+            verse8PlacementId: platformPlacementId,
+            ...(record.adNetwork === undefined ? {} : { verse8AdNetwork: record.adNetwork }),
+        },
+    };
+}
+function verifierEndpoint(baseUrl) {
+    const url = new URL(baseUrl);
+    if (url.protocol !== 'https:') {
+        throw new Error('Verse8 Ads verifier baseUrl must use HTTPS.');
+    }
+    url.hash = '';
+    url.search = '';
+    url.pathname = `${url.pathname.replace(/\/+$/, '')}/ads/verify`;
+    return url.toString();
+}
+function readGlobalFetch() {
+    const fetcher = globalThis.fetch;
+    if (fetcher === undefined) {
+        throw new Error('globalThis.fetch is unavailable. Provide a Verse8 verifier fetch implementation.');
+    }
+    return fetcher.bind(globalThis);
+}
+async function resolveAuthorization(authorization) {
+    const resolved = typeof authorization === 'function' ? await authorization() : authorization;
+    requireNonEmptyString(resolved, 'authorization');
+    return resolved.trim();
+}
+async function readBoundedJson(response) {
+    const body = await readBoundedBody(response);
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        throw new Error('Verse8 Ads verifier response must be valid JSON.');
+    }
+}
+async function readBoundedBody(response) {
+    const declaredLength = response.headers.get('Content-Length');
+    if (declaredLength !== null && Number(declaredLength) > maximumVerifierResponseLength) {
+        throw new Error('Verse8 Ads verifier response exceeds the maximum size.');
+    }
+    if (response.body === null) {
+        return '';
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let byteLength = 0;
+    let body = '';
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done) {
+                return body + decoder.decode();
+            }
+            byteLength += chunk.value.byteLength;
+            if (byteLength > maximumVerifierResponseLength) {
+                await reader.cancel().catch(() => undefined);
+                throw new Error('Verse8 Ads verifier response exceeds the maximum size.');
+            }
+            body += decoder.decode(chunk.value, { stream: true });
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function assertVerse8AdsVerificationRecord(input) {
+    if (!isVerse8AdsVerificationRecord(input)) {
+        throw new Error('Verse8 Ads verifier response has an invalid shape.');
+    }
+    return input;
+}
+function isVerse8AdsVerificationRecord(input) {
+    if (!isRecord(input) || typeof input.verified !== 'boolean') {
+        return false;
+    }
+    if (input.status !== undefined
+        && input.status !== 'verified'
+        && input.status !== 'consumed'
+        && input.status !== 'pending') {
+        return false;
+    }
+    if (!isOptionalString(input.requestId)
+        || !isOptionalString(input.placementId)
+        || !isOptionalString(input.userId)
+        || !isOptionalString(input.verifiedAt)
+        || !isOptionalString(input.consumedAt)
+        || !isOptionalString(input.error)) {
+        return false;
+    }
+    if (input.adNetwork !== undefined && input.adNetwork !== 'google') {
+        return false;
+    }
+    if (input.reward !== undefined) {
+        if (!isRecord(input.reward)
+            || typeof input.reward.amount !== 'number'
+            || !Number.isFinite(input.reward.amount)
+            || typeof input.reward.type !== 'string') {
+            return false;
+        }
+    }
+    return true;
+}
+function readErrorCode(input) {
+    return isRecord(input) && typeof input.error === 'string' ? input.error : undefined;
+}
+function readEvidenceString(payload, key) {
+    const value = payload[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function normalizeTimestamp(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : undefined;
+}
+function sameVerse8User(left, right) {
+    return isHexAccount(left) && isHexAccount(right)
+        ? left.toLowerCase() === right.toLowerCase()
+        : left === right;
+}
+function isHexAccount(value) {
+    return /^0x[0-9a-fA-F]+$/.test(value);
+}
+function rejected(reason) {
+    return {
+        status: 'rejected',
+        reason,
+    };
+}
+function isRecord(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+function isOptionalString(input) {
+    return input === undefined || typeof input === 'string';
+}
+function requireNonEmptyString(input, label) {
+    if (input.trim().length === 0) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/adapter-verse8",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Verse8 iframe platform adapter for mpgd games.",
   "license": "MIT",
   "repository": {
@@ -27,14 +27,25 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./agent8": {
+      "types": "./dist/agent8.d.ts",
+      "default": "./dist/agent8.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
+    "@verse8/ads": "0.4.0",
     "@verse8/platform": "2.1.0",
-    "@mpgd/platform": "0.6.0"
+    "@mpgd/catalog": "0.5.0",
+    "@mpgd/platform": "0.7.0",
+    "@mpgd/game-services": "0.10.0"
   },
   "devDependencies": {
     "ttsc": "0.18.4",
@@ -51,6 +62,6 @@
     "lint": "ttsc --noEmit",
     "format": "ttsc format",
     "fix": "ttsc fix",
-    "test": "vitest run"
+    "test": "vitest run && node test/server-dist-import.mjs && node test/agent8-dist-import.mjs"
   }
 }