@mpgd/adapter-verse8 0.3.12 → 0.4.0

package/dist/ad-provider.d.ts

@@ -0,0 +1,17 @@
+import { type AdProvider } from '@mpgd/platform/ads';
+import type { Verse8AdsClient } from './index.js';
+export interface Verse8AdPresentationEvent {
+  readonly requestId: string;
+  readonly sequence: number;
+  readonly state: 'open' | 'closed' | 'not-started' | 'unknown';
+}
+/** Trusted host facts, scoped to the original SDK request. Reward telemetry is not closure. */
+export interface Verse8AdPresentationSource {
+  subscribe(listener: (event: Verse8AdPresentationEvent) => void): () => void;
+}
+export declare function createVerse8AdProvider(input: {
+  readonly client: Verse8AdsClient;
+  readonly resolvePlacement?: (placementId: string) => string | undefined;
+  readonly presentation?: Verse8AdPresentationSource;
+  readonly timeoutMs?: number;
+}): AdProvider;

package/dist/ad-provider.js

@@ -0,0 +1,276 @@
+import { adProtocol, adProtocolVersion, assertAdPresentationEvent, assertAdShowInput, assertAdShowResult, } from '@mpgd/platform/ads';
+import { verse8AdsRewardEvidenceSchema } from './ads-contract.js';
+const owners = new WeakMap();
+export function createVerse8AdProvider(input) {
+    const id = 'verse8-ads';
+    const timeoutMs = input.timeoutMs ?? 30000;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647) {
+        throw new RangeError('Verse8 ad timeout must be a positive timer duration.');
+    }
+    const listeners = new Set();
+    function availability(request) {
+        const placement = input.resolvePlacement?.(request.placementId);
+        if (typeof placement !== 'string' || placement.trim() === '' || placement.length > 512) {
+            return {
+                state: 'configuration-required',
+                reason: 'configuration-required',
+            };
+        }
+        // SDK 0.4 resolves rewarded H5 ads at adViewed, before adBreakDone. It has
+        // no reliable rewarded closure port; require a trusted host integration.
+        if (request.format === 'rewarded' && input.presentation === undefined) {
+            return {
+                state: 'configuration-required',
+                reason: 'configuration-required',
+            };
+        }
+        const owner = owners.get(input.client);
+        if (owner?.state === 'unknown') {
+            return {
+                state: 'action-required',
+                reason: 'action-required',
+            };
+        }
+        if (owner !== undefined) {
+            return { state: 'temporarily-unavailable', reason: 'busy' };
+        }
+        return { state: 'available' };
+    }
+    async function show(supplied) {
+        const request = assertAdShowInput(supplied);
+        const make = (value) => assertAdShowResult({ providerId: id, invocationId: request.invocationId, format: request.format, ...value });
+        const negative = (reason, outcome = 'unavailable') => make({
+            outcome,
+            presentation: 'not-started',
+            eligibility: request.format === 'rewarded' ? 'not-earned' : 'not-applicable',
+            reason,
+        });
+        const available = availability(request);
+        if (available.state !== 'available') {
+            return negative(available.reason ?? 'configuration-required');
+        }
+        const placement = input.resolvePlacement?.(request.placementId);
+        if (placement === undefined) {
+            return negative('configuration-required');
+        }
+        const owner = { state: 'requested' };
+        owners.set(input.client, owner);
+        const release = () => {
+            if (owners.get(input.client) === owner) {
+                owners.delete(input.client);
+            }
+        };
+        let started = false;
+        let closed = false;
+        let called = false;
+        let delivered = false;
+        let sdkSettled = false;
+        let nativeSequence = 0;
+        let sequence = 0;
+        let earned;
+        let notEarned = false;
+        let didNotStart = false;
+        const candidate = {
+            schema: verse8AdsRewardEvidenceSchema,
+            payload: { requestId: request.invocationId, placementId: placement },
+        };
+        let unsubscribe;
+        let cleaned = false;
+        let resolve;
+        const pending = new Promise((done) => {
+            resolve = done;
+        });
+        const clean = () => {
+            if (cleaned || !closed || !sdkSettled || unsubscribe === undefined) {
+                return;
+            }
+            cleaned = true;
+            try {
+                unsubscribe();
+            }
+            catch { /* Native closure is already known. */ }
+        };
+        const emit = (event) => {
+            const safe = assertAdPresentationEvent({
+                ...event,
+                providerId: id,
+                invocationId: request.invocationId,
+                sequence: ++sequence,
+            });
+            for (const listener of [...listeners]) {
+                try {
+                    void Promise.resolve(listener(safe)).catch(() => undefined);
+                }
+                catch { /* Isolate observation. */ }
+            }
+        };
+        const eligibility = () => {
+            if (request.format === 'interstitial') {
+                return 'not-applicable';
+            }
+            if (notEarned) {
+                return 'not-earned';
+            }
+            return earned === undefined ? 'unknown' : 'eligible';
+        };
+        const result = () => make({
+            outcome: closed ? 'shown' : 'pending',
+            presentation: closed ? 'closed' : 'unknown',
+            eligibility: eligibility(),
+            ...(!closed ? { reason: 'outcome-unknown' } : {}),
+            ...(earned === undefined ? {} : { evidence: earned }),
+            ...(request.format === 'rewarded' && !notEarned ? { claimEvidence: candidate } : {}),
+        });
+        const finish = (value) => {
+            if (!delivered) {
+                delivered = true;
+                clearTimeout(timer);
+                resolve(value);
+            }
+        };
+        const unknown = () => {
+            if (!closed) {
+                owner.state = 'unknown';
+                emit({ type: 'unknown' });
+            }
+            finish(result());
+        };
+        const close = () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            release();
+            emit({ type: 'closed' });
+            finish(result());
+            clean();
+        };
+        try {
+            unsubscribe = input.presentation?.subscribe((event) => {
+                if (!called || event.requestId !== request.invocationId || closed || !Number.isSafeInteger(event.sequence) || event.sequence <= nativeSequence) {
+                    return;
+                }
+                if (!['open', 'closed', 'not-started', 'unknown'].includes(event.state)) {
+                    return;
+                }
+                nativeSequence = event.sequence;
+                if (event.state === 'open') {
+                    if (!started) {
+                        started = true;
+                        owner.state = 'open';
+                        emit({ type: 'started' });
+                    }
+                }
+                else if (event.state === 'closed') {
+                    close();
+                }
+                else if (event.state === 'not-started') {
+                    if (started || earned !== undefined) {
+                        unknown();
+                    }
+                    else {
+                        closed = true;
+                        didNotStart = true;
+                        notEarned = true;
+                        release();
+                        emit({ type: 'failed', reason: 'transient-failure' });
+                        finish(negative('transient-failure', 'failed'));
+                        clean();
+                    }
+                }
+                else {
+                    unknown();
+                }
+            });
+        }
+        catch {
+            release();
+            return negative('transient-failure', 'failed');
+        }
+        emit({
+            type: 'requested',
+            ...(request.format === 'rewarded' && !notEarned ? { claimEvidence: candidate } : {}),
+        });
+        const timer = setTimeout(unknown, timeoutMs);
+        called = true;
+        const sdkInput = {
+            placementId: placement,
+            requestId: request.invocationId,
+            timeoutMs,
+            meta: { logicalPlacementId: request.placementId },
+        };
+        try {
+            const promise = request.format === 'rewarded'
+                ? input.client.showRewarded(sdkInput)
+                : input.client.showInterstitial(sdkInput);
+            void Promise.resolve(promise).then((value) => {
+                sdkSettled = true;
+                if (value.requestId !== request.invocationId) {
+                    unknown();
+                    clean();
+                    return;
+                }
+                if (didNotStart) {
+                    clean();
+                    return;
+                }
+                if (value.status === 'rewarded' && request.format === 'rewarded') {
+                    earned = candidate;
+                    if (!started && !closed) {
+                        started = true;
+                        owner.state = 'open';
+                        emit({ type: 'started' });
+                    }
+                    emit({ type: 'reward-earned', evidence: candidate });
+                    // Rewarded completion is eligibility only. The host must close UI.
+                    if (closed) {
+                        finish(result());
+                    }
+                }
+                else if (value.status === 'dismissed') {
+                    notEarned = earned === undefined;
+                    close();
+                }
+                else if (value.status === 'failed' && !started && !closed && (value.error.code === 'unsupported_env' || value.error.code === 'busy')) {
+                    closed = true;
+                    release();
+                    emit({ type: 'failed', reason: value.error.code === 'busy' ? 'busy' : 'unsupported' });
+                    finish(negative(value.error.code === 'busy' ? 'busy' : 'unsupported'));
+                }
+                else {
+                    unknown();
+                }
+                clean();
+            }, () => { sdkSettled = true; unknown(); clean(); }).catch(() => { sdkSettled = true; unknown(); clean(); });
+        }
+        catch {
+            sdkSettled = true;
+            unknown();
+            clean();
+        }
+        return pending;
+    }
+    return {
+        id,
+        protocol: adProtocol,
+        protocolVersion: adProtocolVersion,
+        rewardSignal: 'delayed',
+        getAvailability: async (request) => availability(request),
+        async preload(request) {
+            const available = availability(request);
+            return available.state === 'available'
+                ? { status: 'deferred' }
+                : {
+                    status: 'unavailable',
+                    ...(available.reason === undefined ? {} : { reason: available.reason }),
+                };
+        },
+        show,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 import { type InterstitialAdResult as Verse8InterstitialAdResult, type RewardedAdResult as Verse8RewardedAdResult } from '@verse8/ads';
 import { type CatalogTarget, type ProductCatalog } from '@mpgd/catalog';
 import { type Entitlement, type LogicalAdPlacementId, type LogicalProductId, type PlatformGateway, type ProductType, type StorageAdapter } from '@mpgd/platform';
+import { type Verse8AdPresentationSource } from './ad-provider.js';
 export { verse8AdsRewardEvidenceSchema } from './ads-contract.js';
+export type { Verse8AdPresentationEvent, Verse8AdPresentationSource } from './ad-provider.js';
 export interface Verse8Credential {
   readonly account: `0x${string}`;
   readonly verse: string;
@@ -31,11 +33,13 @@ export interface Verse8AdsClient {
   showRewarded(input: {
     readonly placementId: string;
     readonly timeoutMs?: number;
+    readonly requestId?: string;
     readonly meta?: Record<string, unknown>;
   }): Promise<Verse8RewardedAdResult>;
   showInterstitial(input: {
     readonly placementId: string;
     readonly timeoutMs?: number;
+    readonly requestId?: string;
     readonly meta?: Record<string, unknown>;
   }): Promise<Verse8InterstitialAdResult>;
 }
@@ -84,6 +88,8 @@ export interface Verse8PlatformGatewayOptions {
   readonly authClient?: Verse8AuthClient;
   readonly adsClient?: Verse8AdsClient;
   readonly adsTimeoutMs?: number;
+  /** Required for rewarded v2: SDK 0.4 reward completion does not prove native closure. */
+  readonly adPresentation?: Verse8AdPresentationSource;
   readonly resolveAdPlacementId?: (placementId: LogicalAdPlacementId) => string | undefined;
   readonly vxShop?: Verse8CommerceOptions;
   readonly agent8Storage?: Verse8Agent8StorageClient;

package/dist/index.js

@@ -2,7 +2,8 @@ import { Verse8Ads, } from '@verse8/ads';
 import { Verse8, VXShop } from '@verse8/platform/vanilla';
 import { resolveProductPlatformId } from '@mpgd/catalog';
 import { createUnsupportedCapabilities, } from '@mpgd/platform';
-import { verse8AdsRewardEvidenceSchema } from './ads-contract.js';
+import { createVerse8AdProvider } from './ad-provider.js';
+import { toAdAdapter } from '@mpgd/platform/ads';
 import { defaultVerse8CatalogTarget } from './catalog-target.js';
 export { verse8AdsRewardEvidenceSchema } from './ads-contract.js';
 export function createVerse8CommerceProducts(catalog, target = defaultVerse8CatalogTarget) {
@@ -23,6 +24,12 @@ export function createVerse8PlatformGateway(options = {}) {
     const authClient = options.authClient ?? createDefaultAuthClient();
     const adsClient = options.adsClient ?? Verse8Ads;
     const adsAvailable = options.resolveAdPlacementId !== undefined;
+    const ads = toAdAdapter(createVerse8AdProvider({
+        client: adsClient,
+        ...(options.resolveAdPlacementId === undefined ? {} : { resolvePlacement: options.resolveAdPlacementId }),
+        ...(options.adPresentation === undefined ? {} : { presentation: options.adPresentation }),
+        ...(options.adsTimeoutMs === undefined ? {} : { timeoutMs: options.adsTimeoutMs }),
+    }));
     const commerce = createVerse8Commerce(options.vxShop);
     const pauseListeners = new Set();
     const resumeListeners = new Set();
@@ -56,87 +63,7 @@ export function createVerse8PlatformGateway(options = {}) {
             },
         },
         commerce: commerce ?? createUnavailableVerse8Commerce(),
-        ads: {
-            async preload() { },
-            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') {
-                        // The SDK callback is a claim candidate only. `requestId` is a Verse8
-                        // impression id, not a ledger entry; the backend verifier consumes it
-                        // from the evidence payload before any reward is granted.
-                        return {
-                            status: 'completed',
-                            rewardGranted: false,
-                            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(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' };
-                }
-            },
-        },
+        ads,
         leaderboard: {
             async submitScore() {
                 return {
@@ -318,12 +245,6 @@ function failedPurchase() {
 function canOpenDefaultVerse8Shop() {
     return typeof window !== 'undefined' && window.parent !== window;
 }
-function unavailableReward() {
-    return {
-        status: 'unavailable',
-        rewardGranted: false,
-    };
-}
 function createDefaultAuthClient() {
     return {
         getUser(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/adapter-verse8",
-  "version": "0.3.12",
+  "version": "0.4.0",
   "description": "Verse8 iframe platform adapter for mpgd games.",
   "license": "MIT",
   "repository": {
@@ -43,14 +43,16 @@
   "dependencies": {
     "@verse8/ads": "0.4.0",
     "@verse8/platform": "2.1.0",
-    "@mpgd/catalog": "0.7.6",
-    "@mpgd/game-services": "0.17.2",
-    "@mpgd/platform": "0.14.0"
+    "@mpgd/catalog": "0.7.7",
+    "@mpgd/game-services": "0.18.0",
+    "@mpgd/platform": "0.15.0"
   },
   "devDependencies": {
+    "@types/node": "^24.0.0",
     "ttsc": "0.30.4",
     "typescript": "7.0.2",
-    "vitest": "^4.0.0"
+    "vitest": "^4.0.0",
+    "@mpgd/game-runtime": "0.3.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",