@mpgd/adapter-capacitor 0.5.0 → 0.6.1

package/README.md

@@ -52,14 +52,107 @@ provider never silently falls back for purchase, ad, or native leaderboard
 operations; an explicit remote leaderboard route is a separate path. Errors
 retain a stable code and retry hint. The
 provider bridge must return a method-shaped response. In particular, an ad
-`rewardGranted: true` result requires a backend ledger entry. A native callback
-alone is evidence, not a grant. Game-specific product, consent, entitlement,
-and identity policy belongs to the consuming game and its backend.
+`rewardGranted: true` result requires a backend ledger entry. The AdMob SDK
+provider always returns `rewardGranted: false`, even after the SDK fires a
+reward callback. Its explicitly non-authoritative evidence envelope only lets
+the game-services client request a grant; the server must independently verify
+a signed SSV callback before writing its ledger. A native callback alone is
+never a grant. Game-specific product, consent, entitlement, and
+identity policy belongs to the consuming game and its backend.
 
 The source tests and installed-tarball consumer validate composition, types,
 error paths, and fallback behavior. They do not establish that any optional
 SDK works on a physical device or that a store/ad setup is release-ready.
 
+## App Store server-side transaction signatures
+
+For an iOS game backend, install the optional
+`@apple/app-store-server-library@3.1.0` peer and import
+`createAppleSignedTransactionVerifier` from
+`@mpgd/adapter-capacitor/app-store-server`. Supply DER-encoded Apple root
+certificates from the [Apple PKI](https://www.apple.com/certificateauthority/),
+the game's bundle ID, environment, and production App Apple ID. Use the
+result as `signedTransactionVerifier` in
+`createAppStoreGameServicesEvidenceVerifier`. Keep App Store API credentials,
+trust roots, and this verifier on the backend, not in the Capacitor game.
+
+The server fetches the transaction from Apple's API, verifies its JWS, checks
+the product, bundle, environment, account token and transaction ID, then
+writes the game-services grant. A StoreKit device callback is only provisional
+evidence; it never grants a product. Retryable certificate-status failures
+remain pending, while invalid signatures are rejected. Mock verification does
+not prove a real App Store purchase or device delivery.
+
+## Opt-in AdMob rewarded ads
+
+Install `@capacitor-community/admob@8.1.0` in the game-owned Capacitor project,
+configure the distinct AdMob **application ID** in AndroidManifest.xml and
+Info.plist, and run `cap sync`. Use the [plugin installation and native setup
+guide](https://github.com/capacitor-community/admob#installation) for the exact
+Android and iOS keys, SKAdNetwork list, and tracking disclosure. The optional
+`@mpgd/adapter-capacitor/admob` subpath does not load from the base adapter;
+games that do not install AdMob retain their existing SDK-free gateway.
+The community plugin currently targets Google Mobile Ads Android 25.4.x and
+iOS 13.6.0. Its Android default uses a dynamic patch selector; set
+`playServicesAdsVersion = '25.4.0'` in the game-owned `variables.gradle` to
+keep release builds reproducible until the plugin adopts a newer tested SDK.
+
+```ts
+import { createCapacitorPlatformGateway } from '@mpgd/adapter-capacitor';
+import { createCapacitorAdMobRewardedProvider } from '@mpgd/adapter-capacitor/admob';
+
+const admob = createCapacitorAdMobRewardedProvider({
+  adUnits: { CONTINUE_AFTER_FAIL: 'ca-app-pub-1234567890123456/1234567890' },
+  getPlayerId: () => authenticatedPlayerId,
+});
+const gateway = createCapacitorPlatformGateway({
+  target: 'android', appVersion: '1.0.0', buildId: 'game-build',
+  providers: [admob],
+});
+const consentAllowsAds = await admob.requestConsent();
+if (!consentAllowsAds) {
+  // Keep the ad action disabled; never bypass the privacy choice.
+}
+```
+
+Use target-specific ad unit IDs for Android and iOS; the logical placement
+ID must match the game catalog and backend config. `getPlayerId()` must return
+the same authenticated player ID as `GameServicesClient`, not a device ID or
+an unverified local guest label. Re-check consent when the game resumes or
+the privacy choice changes, and expose `admob.showPrivacyOptions()` from game
+settings where required. `getCapabilities()` reports `action-required` until
+consent is ready and `temporarily-unavailable` during a show. A timed-out
+native load or presentation reports non-retryable `action-required` and
+quarantines that SDK instance to avoid overlapping shows
+while its state is unknown. Recreating the Kit provider with the same SDK does
+not clear the quarantine; restart the native app before trying again. Do not
+show rewarded ads through another direct SDK caller concurrently: the plugin's
+reward and dismissal events are global, not tagged with a Kit operation ID.
+
+`gateway.ads.preload()` validates the logical placement but deliberately does
+not load an ad: this SDK attaches SSV data at load time, whereas the Kit's
+operation ID exists only at show time. `gateway.ads.showRewarded()` therefore
+loads a fresh ad with SSV `userId` and encoded player/placement/operation
+binding, waits for native dismissal, then returns SDK reward evidence. Call
+`GameServicesClient.claimRewardedAd()` rather than award currency from that
+result; `rewardGranted` remains `false` in that provisional platform result.
+If dismissal arrives without an observed reward, the provider returns
+`pending` with the same non-authoritative binding. The backend can then look
+for a later signed SSV callback without replaying the ad UI; a genuinely
+skipped ad may remain pending until game-owned support or expiry policy
+settles it. Mediation and asynchronous bridge delivery have no safe universal
+250 ms reward-event cutoff.
+The receiver and ledger described in [AdMob SSV](../../docs/ADMOB_SSV.md)
+remain mandatory. A late SSV callback can leave the claim pending for
+reconciliation. `isTesting: true` is for SDK test ads only; [the plugin notes
+that test ads do not invoke the SSV endpoint](https://github.com/capacitor-community/admob/blob/main/docs/rewarded.md#server-side-verification),
+so they cannot prove a production grant.
+
+The Kit tests cover consent, per-operation binding, reward versus dismissal,
+and bridge contracts with an injected SDK. They are not evidence of a real
+AdMob account, live callback delivery, native device behavior, or store policy
+approval.
+
 `gateway.secureCredentials` uses dedicated native Keychain/Keystore methods for
 opaque session credentials. Its absence or a native error must not be hidden by
 writing the secret into `gateway.storage`. Keys are bounded, values are

package/dist/admob.d.ts

@@ -0,0 +1,26 @@
+import { type AdMobPlugin } from '@capacitor-community/admob';
+import type { CapacitorServiceProvider } from './providers.js';
+/** Only the AdMob subpath imports the optional native SDK. */
+export type RewardedAdMobSdk = Pick<AdMobPlugin, 'initialize' | 'requestConsentInfo' | 'showConsentForm' | 'showPrivacyOptionsForm' | 'prepareRewardVideoAd' | 'showRewardVideoAd' | 'addListener'>;
+export interface CreateCapacitorAdMobRewardedProviderInput {
+  /** Logical placement IDs mapped to target-specific, game-owned AdMob ad units. */
+  readonly adUnits: Readonly<Record<string, string>>;
+  /** Must resolve to the same authenticated player ID used by GameServicesClient. */
+  readonly getPlayerId: () => Promise<string> | string;
+  /** Test ads do not send Google SSV callbacks; server grants remain pending. */
+  readonly isTesting?: boolean;
+  readonly sdk?: RewardedAdMobSdk;
+  readonly showTimeoutMs?: number;
+}
+export interface CapacitorAdMobRewardedProvider extends CapacitorServiceProvider {
+  /** Present UMP when required. Call before the gateway advertises ad readiness. */
+  requestConsent(): Promise<boolean>;
+  /** Game settings should expose this when the privacy message requires it. */
+  showPrivacyOptions(): Promise<void>;
+}
+/**
+* Opt-in rewarded-only provider. The SDK's SSV options are attached when an
+* operation is shown, never to an earlier unbound preload. A local reward
+* callback is only a signal to ask the backend; it is not a ledger grant.
+*/
+export declare function createCapacitorAdMobRewardedProvider(input: CreateCapacitorAdMobRewardedProviderInput): CapacitorAdMobRewardedProvider;

package/dist/admob.js

@@ -0,0 +1,288 @@
+import { AdMob, AdmobConsentStatus, RewardAdPluginEvents, } from '@capacitor-community/admob';
+import { admobClientRewardEvidenceSchema } from '@mpgd/game-services/admob-client-reward';
+import { admobSsvMaximumBindingFieldLength, encodeAdMobSsvCustomData, } from '@mpgd/game-services/admob-ssv';
+const unitPattern = /^ca-app-pub-\d+\/\d+$/u;
+const defaultShowTimeoutMs = 180_000;
+const loadTimeoutMs = 30_000;
+const preflightTimeoutMs = 10_000;
+const listenerCleanupTimeoutMs = 1_000;
+const maximumCustomDataBytes = 1_024;
+// The native plugin's rewarded event stream and prepared-ad table are global.
+// Coordinate Kit providers sharing one SDK instance, even across gateways.
+const activeSdk = new WeakSet();
+const uncertainSdk = new WeakSet();
+function response(input, result) {
+    return { id: input.id, ok: true, data: result };
+}
+function failure(input, code, retryable = false) {
+    return { id: input.id, ok: false, error: { code, message: code, retryable } };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isRewardItem(value) {
+    return isRecord(value)
+        && typeof value.type === 'string'
+        && value.type.length > 0
+        && typeof value.amount === 'number'
+        && Number.isFinite(value.amount)
+        && value.amount > 0;
+}
+class PreflightTimeoutError extends Error {
+}
+async function withTimeout(promise, milliseconds, onLate) {
+    let timer;
+    let expired = false;
+    const watched = promise.then((value) => {
+        if (expired && onLate !== undefined) {
+            void Promise.resolve().then(() => onLate(value)).catch(() => undefined);
+        }
+        return value;
+    });
+    try {
+        return await Promise.race([
+            watched,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    expired = true;
+                    reject(new PreflightTimeoutError('AdMob preflight timed out.'));
+                }, milliseconds);
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+}
+/**
+ * Opt-in rewarded-only provider. The SDK's SSV options are attached when an
+ * operation is shown, never to an earlier unbound preload. A local reward
+ * callback is only a signal to ask the backend; it is not a ledger grant.
+ */
+export function createCapacitorAdMobRewardedProvider(input) {
+    const sdk = input.sdk ?? AdMob;
+    const showTimeoutMs = input.showTimeoutMs ?? defaultShowTimeoutMs;
+    if (!Number.isSafeInteger(showTimeoutMs) || showTimeoutMs < 1_000 || showTimeoutMs > 300_000) {
+        throw new Error('AdMob show timeout must be between 1 and 300 seconds.');
+    }
+    const adUnits = new Map();
+    for (const [placementId, unit] of Object.entries(input.adUnits)) {
+        if (placementId.trim() === '' || !unitPattern.test(unit)) {
+            throw new Error('AdMob rewarded placements require non-empty IDs and production-format ad units.');
+        }
+        adUnits.set(placementId, unit);
+    }
+    if (adUnits.size === 0) {
+        throw new Error('AdMob rewarded provider requires at least one ad unit.');
+    }
+    let initialized;
+    let consentTask;
+    let canRequestAds = false;
+    let privacyOptionsRequired = false;
+    const initialize = async () => {
+        if (initialized === undefined) {
+            initialized = sdk.initialize().catch((error) => {
+                initialized = undefined;
+                throw error;
+            });
+        }
+        await initialized;
+    };
+    const requestConsent = () => {
+        if (consentTask === undefined) {
+            consentTask = (async () => {
+                canRequestAds = false;
+                await initialize();
+                let info = await sdk.requestConsentInfo();
+                if (info.status === AdmobConsentStatus.REQUIRED && info.isConsentFormAvailable) {
+                    info = await sdk.showConsentForm();
+                }
+                canRequestAds = info.canRequestAds === true;
+                privacyOptionsRequired = info.privacyOptionsRequirementStatus === 'REQUIRED';
+                return canRequestAds;
+            })().finally(() => { consentTask = undefined; });
+        }
+        return consentTask;
+    };
+    const showRewarded = async (placementId, idempotencyKey) => {
+        const adId = adUnits.get(placementId);
+        if (adId === undefined || !canRequestAds || activeSdk.has(sdk) || uncertainSdk.has(sdk)) {
+            return { status: 'unavailable', rewardGranted: false };
+        }
+        if (idempotencyKey.trim() === ''
+            || idempotencyKey.length > admobSsvMaximumBindingFieldLength
+            || placementId.length > admobSsvMaximumBindingFieldLength) {
+            return { status: 'failed', rewardGranted: false };
+        }
+        activeSdk.add(sdk);
+        const handles = [];
+        let rewardEarned = false;
+        let timer;
+        let loadTimer;
+        let loadTimedOut = false;
+        let nativePreflightStarted = false;
+        try {
+            const playerId = await withTimeout(Promise.resolve().then(() => input.getPlayerId()), preflightTimeoutMs);
+            if (typeof playerId !== 'string' || playerId.trim() === ''
+                || playerId.length > admobSsvMaximumBindingFieldLength) {
+                return { status: 'failed', rewardGranted: false };
+            }
+            const customData = encodeAdMobSsvCustomData({ playerId, placementId, idempotencyKey });
+            if (new TextEncoder().encode(customData).byteLength > maximumCustomDataBytes) {
+                return { status: 'failed', rewardGranted: false };
+            }
+            // This plugin resolves showRewardVideoAd on reward, but on Android a
+            // dismissal without reward leaves that promise unresolved. Observe the
+            // terminal native events separately, and hold lifecycle through close.
+            let finish;
+            const terminal = new Promise((resolve) => {
+                finish = resolve;
+            });
+            nativePreflightStarted = true;
+            handles.push(await withTimeout(sdk.addListener(RewardAdPluginEvents.Rewarded, (reward) => {
+                if (isRewardItem(reward)) {
+                    rewardEarned = true;
+                }
+            }), preflightTimeoutMs, (handle) => handle.remove()));
+            handles.push(await withTimeout(sdk.addListener(RewardAdPluginEvents.Dismissed, () => {
+                // Let a same-turn Rewarded event settle before reading the flag.
+                queueMicrotask(() => finish('dismissed'));
+            }), preflightTimeoutMs, (handle) => handle.remove()));
+            handles.push(await withTimeout(sdk.addListener(RewardAdPluginEvents.FailedToShow, () => {
+                finish('failed');
+            }), preflightTimeoutMs, (handle) => handle.remove()));
+            const loaded = await Promise.race([
+                sdk.prepareRewardVideoAd({
+                    adId,
+                    ...(input.isTesting === undefined ? {} : { isTesting: input.isTesting }),
+                    ssv: { userId: playerId, customData },
+                }),
+                new Promise((_resolve, reject) => {
+                    loadTimer = setTimeout(() => {
+                        loadTimedOut = true;
+                        reject(new Error('AdMob load timed out.'));
+                    }, loadTimeoutMs);
+                }),
+            ]);
+            if (loadTimer !== undefined) {
+                clearTimeout(loadTimer);
+                loadTimer = undefined;
+            }
+            if (typeof loaded.adUnitId !== 'string' || loaded.adUnitId.length === 0) {
+                return { status: 'failed', rewardGranted: false };
+            }
+            timer = setTimeout(() => finish('timeout'), showTimeoutMs);
+            // Always observe rejection, even if a Dismissed event wins the race.
+            const showResult = sdk.showRewardVideoAd({ adId: loaded.adUnitId });
+            const onReward = (reward) => {
+                if (isRewardItem(reward)) {
+                    rewardEarned = true;
+                }
+            };
+            const onShowError = () => finish('failed');
+            void showResult.then(onReward, onShowError);
+            const outcome = await terminal;
+            if (outcome === 'timeout') {
+                // Native presentation state is unknown: do not allow another show.
+                uncertainSdk.add(sdk);
+            }
+            let status = 'failed';
+            if (rewardEarned) {
+                status = 'completed';
+            }
+            else if (outcome === 'dismissed') {
+                // Mediation may deliver reward after dismissal. Only signed SSV can
+                // later distinguish a true skip from an earned reward.
+                status = 'pending';
+            }
+            else if (outcome === 'timeout') {
+                status = 'pending';
+            }
+            return {
+                status,
+                rewardGranted: false,
+                ...(status === 'completed' || status === 'pending' ? { evidence: {
+                        schema: admobClientRewardEvidenceSchema,
+                        payload: { adUnitId: adId },
+                    } } : {}),
+            };
+        }
+        catch (error) {
+            const uncertain = loadTimedOut
+                || (nativePreflightStarted && error instanceof PreflightTimeoutError);
+            if (uncertain) {
+                uncertainSdk.add(sdk);
+            }
+            return { status: uncertain ? 'pending' : 'failed', rewardGranted: false };
+        }
+        finally {
+            if (loadTimer !== undefined) {
+                clearTimeout(loadTimer);
+            }
+            if (timer !== undefined) {
+                clearTimeout(timer);
+            }
+            try {
+                const removals = handles.map((handle) => {
+                    const removal = Promise.resolve().then(() => handle.remove());
+                    return withTimeout(removal, listenerCleanupTimeoutMs);
+                });
+                const settled = await Promise.allSettled(removals);
+                if (settled.some((result) => result.status === 'rejected')) {
+                    uncertainSdk.add(sdk);
+                }
+            }
+            finally {
+                activeSdk.delete(sdk);
+            }
+        }
+    };
+    return {
+        id: 'admob-rewarded',
+        features: ['rewardedAds'],
+        methods: ['ads.preload', 'ads.showRewarded'],
+        async getAvailability() {
+            if (uncertainSdk.has(sdk) || !canRequestAds) {
+                return { rewardedAds: 'action-required' };
+            }
+            return { rewardedAds: activeSdk.has(sdk) ? 'temporarily-unavailable' : 'available' };
+        },
+        requestConsent,
+        async showPrivacyOptions() {
+            if (!privacyOptionsRequired) {
+                return;
+            }
+            canRequestAds = false;
+            await initialize();
+            try {
+                await sdk.showPrivacyOptionsForm();
+            }
+            finally {
+                await requestConsent();
+            }
+        },
+        bridge: {
+            async request(request) {
+                if (request.method === 'ads.preload') {
+                    const payload = request.payload;
+                    if (!isRecord(payload)
+                        || (payload.format !== undefined && payload.format !== 'rewarded')
+                        || typeof payload.placementId !== 'string'
+                        || !adUnits.has(payload.placementId)) {
+                        return failure(request, 'ADMOB_PLACEMENT_INVALID');
+                    }
+                    // Preloading an unbound ad would omit the operation's SSV key.
+                    return response(request, undefined);
+                }
+                if (request.method !== 'ads.showRewarded' || !isRecord(request.payload)
+                    || typeof request.payload.placementId !== 'string'
+                    || typeof request.payload.idempotencyKey !== 'string') {
+                    return failure(request, 'ADMOB_REQUEST_INVALID');
+                }
+                return response(request, await showRewarded(request.payload.placementId, request.payload.idempotencyKey));
+            },
+        },
+    };
+}

package/dist/app-store-server.d.ts

@@ -0,0 +1,12 @@
+import { type AppStoreEnvironment, type AppStoreSignedTransactionVerifier } from '@mpgd/game-services/app-store-verifier';
+export interface CreateAppleSignedTransactionVerifierOptions {
+  /** DER-encoded Apple root certificates, supplied by the server operator. */
+  readonly rootCertificates: readonly Uint8Array[];
+  readonly environment: AppStoreEnvironment;
+  readonly bundleId: string;
+  /** Required by Apple's verifier in production. */
+  readonly appAppleId?: number;
+  readonly enableOnlineChecks?: boolean;
+}
+/** Verify the App Store JWS before exposing any decoded purchase fields. */
+export declare function createAppleSignedTransactionVerifier(options: CreateAppleSignedTransactionVerifierOptions): AppStoreSignedTransactionVerifier;

package/dist/app-store-server.js

@@ -0,0 +1,119 @@
+import { Environment, SignedDataVerifier, VerificationException, VerificationStatus, } from '@apple/app-store-server-library';
+import { AppStoreDependencyUnavailableError, } from '@mpgd/game-services/app-store-verifier';
+/** Verify the App Store JWS before exposing any decoded purchase fields. */
+export function createAppleSignedTransactionVerifier(options) {
+    if (!Array.isArray(options.rootCertificates)
+        || options.rootCertificates.length === 0
+        || options.rootCertificates.some((certificate) => !(certificate instanceof Uint8Array)
+            || certificate.length === 0)) {
+        throw new TypeError('Apple root certificates are required.');
+    }
+    if (options.environment !== 'Production' && options.environment !== 'Sandbox') {
+        throw new TypeError('App Store environment must be Production or Sandbox.');
+    }
+    if (options.bundleId.trim() === '') {
+        throw new TypeError('App Store bundle ID is required.');
+    }
+    if (options.environment === 'Production'
+        && (!Number.isSafeInteger(options.appAppleId) || (options.appAppleId ?? 0) <= 0)) {
+        throw new TypeError('Production App Store verification requires appAppleId.');
+    }
+    if (options.environment === 'Production' && options.enableOnlineChecks === false) {
+        throw new TypeError('Production App Store verification requires online certificate checks.');
+    }
+    const verifier = new SignedDataVerifier(options.rootCertificates.map((certificate) => Buffer.from(certificate)), options.enableOnlineChecks ?? true, options.environment === 'Production' ? Environment.PRODUCTION : Environment.SANDBOX, options.bundleId, options.appAppleId);
+    return {
+        async verifyAndDecode(input) {
+            if (input.environment !== options.environment || input.bundleId !== options.bundleId) {
+                return { status: 'rejected', reason: 'APP_STORE_VERIFIER_SCOPE_MISMATCH' };
+            }
+            if (typeof input.signedTransaction !== 'string'
+                || input.signedTransaction.length === 0
+                || input.signedTransaction.length > 512 * 1024) {
+                return { status: 'rejected', reason: 'APP_STORE_SIGNED_TRANSACTION_INVALID' };
+            }
+            input.signal.throwIfAborted();
+            let decoded;
+            try {
+                decoded = await waitForVerification(verifier.verifyAndDecodeTransaction(input.signedTransaction), input.signal);
+                input.signal.throwIfAborted();
+            }
+            catch (error) {
+                if (input.signal.aborted) {
+                    throw input.signal.reason;
+                }
+                if (error instanceof VerificationException) {
+                    if (error.status === VerificationStatus.RETRYABLE_VERIFICATION_FAILURE) {
+                        throw new AppStoreDependencyUnavailableError('Apple signature checks are temporarily unavailable.', error);
+                    }
+                    return { status: 'rejected', reason: 'APP_STORE_SIGNATURE_INVALID' };
+                }
+                // Only Apple's explicit retryable status is a transient dependency
+                // failure. Unexpected adapter/library faults must reach the caller.
+                throw error;
+            }
+            const payload = decodeOneTimeTransaction(decoded);
+            return payload === undefined
+                ? { status: 'rejected', reason: 'APP_STORE_SIGNED_TRANSACTION_INVALID' }
+                : { status: 'verified', payload };
+        },
+    };
+}
+async function waitForVerification(operation, signal) {
+    signal.throwIfAborted();
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason ?? new Error('Verification was aborted.'));
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted) {
+            onAbort();
+        }
+    });
+    try {
+        return await Promise.race([operation, aborted]);
+    }
+    finally {
+        if (onAbort !== undefined) {
+            signal.removeEventListener('abort', onAbort);
+        }
+    }
+}
+function decodeOneTimeTransaction(decoded) {
+    if (!nonEmpty(decoded.transactionId)
+        || !nonEmpty(decoded.originalTransactionId)
+        || !nonEmpty(decoded.bundleId)
+        || !nonEmpty(decoded.productId)
+        || !validTimestamp(decoded.purchaseDate)
+        || !validTimestamp(decoded.signedDate)
+        || (decoded.environment !== 'Production' && decoded.environment !== 'Sandbox')
+        || (decoded.type !== 'Consumable' && decoded.type !== 'Non-Consumable')
+        || (decoded.quantity !== undefined
+            && (!Number.isSafeInteger(decoded.quantity) || decoded.quantity <= 0))
+        || (decoded.appAccountToken !== undefined && !nonEmpty(decoded.appAccountToken))
+        || (decoded.revocationDate !== undefined && !validTimestamp(decoded.revocationDate))
+        || (decoded.expiresDate !== undefined && !validTimestamp(decoded.expiresDate))
+        || (decoded.isUpgraded !== undefined && typeof decoded.isUpgraded !== 'boolean')) {
+        return undefined;
+    }
+    return {
+        transactionId: decoded.transactionId,
+        originalTransactionId: decoded.originalTransactionId,
+        bundleId: decoded.bundleId,
+        productId: decoded.productId,
+        purchaseDate: decoded.purchaseDate,
+        signedDate: decoded.signedDate,
+        environment: decoded.environment,
+        type: decoded.type,
+        ...(decoded.quantity === undefined ? {} : { quantity: decoded.quantity }),
+        ...(decoded.appAccountToken === undefined ? {} : { appAccountToken: decoded.appAccountToken }),
+        ...(decoded.revocationDate === undefined ? {} : { revocationDate: decoded.revocationDate }),
+        ...(decoded.expiresDate === undefined ? {} : { expiresDate: decoded.expiresDate }),
+        ...(decoded.isUpgraded === undefined ? {} : { isUpgraded: decoded.isUpgraded }),
+    };
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+function validTimestamp(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}

package/dist/providers.js

@@ -1,3 +1,4 @@
+import { isAdMobClientRewardEvidence } from '@mpgd/game-services/admob-client-reward';
 import { PlatformOperationError, } from '@mpgd/platform';
 const featureMethods = {
     nativeIap: [
@@ -253,11 +254,13 @@ function isValidProviderData(method, value) {
             return isVoidData(value);
         case 'ads.showRewarded':
             return isRecord(value)
-                && ['completed', 'skipped', 'unavailable', 'failed'].includes(value.status)
+                && ['completed', 'pending', 'skipped', 'unavailable', 'failed'].includes(value.status)
                 && typeof value.rewardGranted === 'boolean'
                 && (!value.rewardGranted || (value.status === 'completed'
                     && isString(value.ledgerEntryId)
                     && value.ledgerEntryId.length > 0))
+                && (value.status !== 'completed' || value.rewardGranted
+                    || value.evidence === undefined || isAdMobClientRewardEvidence(value))
                 && (value.evidence === undefined || isEvidence(value.evidence));
         case 'ads.showInterstitial':
             return isRecord(value)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/adapter-capacitor",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Capacitor platform adapter for mpgd Android and iOS shells.",
   "license": "MIT",
   "repository": {
@@ -28,6 +28,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./admob": {
+      "types": "./dist/admob.d.ts",
+      "default": "./dist/admob.js"
+    },
+    "./app-store-server": {
+      "types": "./dist/app-store-server.d.ts",
+      "default": "./dist/app-store-server.js"
     }
   },
   "files": [
@@ -35,20 +43,32 @@
   ],
   "dependencies": {
     "@capacitor/app": "8.1.1",
+    "@mpgd/bridge": "0.10.0",
+    "@mpgd/platform": "0.14.0",
+    "@mpgd/target-config": "0.17.0",
     "@mpgd/capacitor-game-services": "0.6.0",
-    "@mpgd/platform": "0.13.0",
-    "@mpgd/target-config": "0.16.0",
-    "@mpgd/bridge": "0.10.0"
+    "@mpgd/game-services": "0.17.1"
   },
   "peerDependencies": {
+    "@apple/app-store-server-library": "^3.1.0",
+    "@capacitor-community/admob": "^8.1.0",
     "@capacitor/core": "^8.5.1"
   },
+  "peerDependenciesMeta": {
+    "@apple/app-store-server-library": {
+      "optional": true
+    },
+    "@capacitor-community/admob": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@apple/app-store-server-library": "3.1.0",
+    "@capacitor-community/admob": "8.1.0",
     "@capacitor/core": "8.5.2",
     "ttsc": "0.30.4",
     "typescript": "7.0.2",
-    "vitest": "^4.0.0",
-    "@mpgd/game-services": "0.16.0"
+    "vitest": "^4.0.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",