@mpgd/capacitor-storekit 0.1.9 → 0.2.0

package/README.md

@@ -12,6 +12,122 @@ must resolve the same UUID for the player. Product lookup, purchase results,
 entitlements provide **provisional evidence**, never a wallet or entitlement
 grant. A completed native purchase returns no `authoritativeGrant`.
 
+## Commerce v2 provider
+
+Commerce v2 ([RFC](../../docs/specs/commerce/commerce-v2-rfc.md), PR B3)
+adds a second surface next to the v1 provider above. The package exposes the
+native plugin as a `StoreSdk` from `@mpgd/adapter-capacitor` and a
+`CommerceProvider` from `@mpgd/platform/commerce` built on
+`createStoreCommerceProvider`. Register the v2 service provider **or** the v1
+`createCapacitorStoreKitProvider` in a gateway, never both.
+
+```ts
+import { createCapacitorPlatformGateway } from '@mpgd/adapter-capacitor';
+import { createCapacitorStoreKitServiceProvider } from '@mpgd/capacitor-storekit';
+
+export function createIosGateway(getAppAccountToken: () => Promise<string>) {
+  return createCapacitorPlatformGateway({
+    target: 'ios',
+    appVersion: '1.0.0',
+    buildId: 'game-build',
+    providers: [
+      createCapacitorStoreKitServiceProvider({
+        products: [
+          { logicalId: 'gems_small', storeSku: 'com.example.game.gems.small', kind: 'consumable' },
+          { logicalId: 'remove_ads', storeSku: 'com.example.game.remove.ads', kind: 'durable' },
+        ],
+        // Authenticated, stable UUID; the backend's resolveAppAccountToken returns the same.
+        getAppAccountToken,
+        bundleId: 'com.example.game',
+      }),
+    ],
+  });
+}
+```
+
+`createCapacitorStoreKitStoreSdk({ products, getAppAccountToken, sdk?, isIos?,
+onDiagnostic? })` is the `StoreSdk`: `store: 'app-store'`; capabilities
+consumable and durable, no subscription, no quantity, `pending` (Ask to
+Buy), `restore` (`AppStore.sync()`), and `finish: 'client'`; `fetchProducts`
+over `getProducts` (subscription lookups are empty without a native call);
+`requestPurchase` over `purchase` with the `app-account-token` binding as the
+`appAccountToken` (a missing binding fails with `ACCOUNT_BINDING_REQUIRED`,
+a non-UUID one with `STOREKIT_CONFIGURATION_ERROR`, and the store never
+opens), answering `purchased` with the transaction, `launched` for a pending
+Ask to Buy, and `cancelled` for a dismissed sheet; `getAvailablePurchases`
+over `getTransactions`, listing unfinished transactions once (a current
+non-consumable entitlement the native side marks `unfinished: false` is not
+listed, a `revokedAt` maps to `state: 'revoked'`, and one malformed
+transaction is reported as a `purchaseError` without blocking its siblings);
+`finishTransaction({ transactionId, ledgerEntryId })` over the native finish;
+`restorePurchases` over `sync`; `transactionUpdated` as `purchaseUpdated`;
+and the v1 availability probe as `getAvailability`, probing the configured
+SKUs batch by batch until one is sold. Every purchase carries the
+StoreKit-verified `signedTransaction` JWS as its `token`, the
+`transactionId`, `originalTransactionId`, `purchasedAt`, `quantity: 1`, and
+the `app-account-token` binding. `storeKitStoreSdkErrorCodeMap` maps every
+`STOREKIT_*` plugin code onto the RFC "Errors" codes;
+`STOREKIT_PURCHASE_UNCERTAIN` and `STOREKIT_UNKNOWN_RESULT` normalize to
+`OUTCOME_UNKNOWN`, which `createStoreCommerceProvider` keeps recoverable (the
+attempt stays `launched` and the reconciler resolves it from
+`getAvailablePurchases`).
+
+Before any purchase sheet opens, the SDK checks the store product against
+the catalog's declared kind (fetching it once if `fetchProducts` has not
+seen it): a mapping that declares `durable` for an App Store consumable, or
+the reverse, fails with `STOREKIT_CONFIGURATION_ERROR`
+(`CONFIGURATION_REQUIRED`), an unmapped SKU with `STOREKIT_PRODUCT_UNKNOWN`
+and a SKU the store does not sell with `STOREKIT_PRODUCT_UNAVAILABLE` (both
+`ITEM_UNAVAILABLE`), so the player is never charged for a purchase the
+backend would reject with `APP_STORE_PRODUCT_TYPE_MISMATCH`; the purchased
+transaction's type is checked against the mapping as well. The SDK also
+answers only for the configured catalog and the active account, on the
+polling and the event path alike: a transaction for a retired or otherwise
+unmapped SKU, one whose signed `appAccountToken` is not the token
+`getAppAccountToken` resolves (a shared device or an in-game account switch;
+it is listed again once that player signs back in), or one whose StoreKit
+type disagrees with the catalog kind is never listed or emitted, so the
+reconciler never journals a purchase it cannot resolve or that belongs to
+another player, and never blocks a valid sibling on one. Each exclusion is
+reported through `onDiagnostic` (`unmapped-sku`, `account-mismatch`,
+`kind-mismatch`); diagnostics are never a grant signal. The native
+`transactionUpdated` listener is attached while either a `purchaseUpdated`
+or a `purchaseError` subscriber exists.
+
+`createCapacitorStoreKitCommerceProvider({ products, getAppAccountToken,
+bundleId?, sdk?, isIos?, mapError?, onDiagnostic? })` builds the provider
+with `authority: { evidence: 'client-token', accountBinding: 'required' }`
+and evidence `{ schema: 'app-store.signed-transaction.v1', payload: {
+signedTransaction, transactionId, originalTransactionId?, bundleId? } }`,
+where `signedTransaction` is the same JWS as `StorePurchase.token`.
+`@mpgd/game-services/app-store-verifier` verifies that JWS offline through
+its `signedTransactionVerifier` (authenticity and transaction id binding)
+and then, by default, decides the grant on the transaction's current status
+from the App Store Server API, so a JWS retained from before a refund never
+grants; see the backend guide for the opt-in offline-only mode. Subscription
+mappings are rejected at construction. `createCapacitorStoreKitServiceProvider`
+wraps the provider as a `CapacitorServiceProvider` (id `apple-storekit` by
+default) so the gateway serves the `commerce.v2.*` and v1 `commerce.*`
+bridge methods from it and exposes it as `gateway.commerceV2`.
+
+Finishing never grants. The v2 SDK finishes any transaction it is given a
+`ledgerEntryId` for: the commerce v2 reconciler is the gate, and it calls
+`finishTransaction` only after the backend ledger granted the purchase. The
+v1 `finishGrantedTransaction` allow-list guard is not reproduced; the real
+control stays server-side, in the verifier that checks the JWS before the
+ledger grant, and in the native plugin never granting anything on finish.
+The v1 recovery helpers (`recoverStoreKitPurchases`,
+`getRecoverableTransactions`, `finishGrantedTransaction`) are deprecated in
+favor of the single reconciler (RFC C1) and are removed in C4.
+
+The conformance test runs every store vector whose profile the App Store
+supports against a fake plugin, directly and through the gateway bridge path,
+and lists each skipped vector with its reason (host or server finish,
+quantity, server-push, an asynchronous store error event StoreKit never
+emits, and a pending transaction state StoreKit never reports).
+
+## v1 provider and recovery
+
 On startup, account restoration, and after a pending or uncertain checkout,
 call `recoverStoreKitPurchases({ provider, backend, playerId })`. It sends only
 transactions whose `appAccountToken` matches the current authenticated game

package/dist/commerce-provider.d.ts

@@ -0,0 +1,58 @@
+import { type CapacitorCommerceServiceProvider, type StoreCommerceProductMapping, type StoreCommerceProvider, type StoreSdkErrorCodeMap } from '@mpgd/adapter-capacitor';
+import { type CapacitorStoreKitDiagnostic, type CapacitorStoreKitStoreSdkPlugin } from './store-sdk.js';
+/**
+* Evidence schema of a commerce v2 App Store purchase. The payload carries
+* the StoreKit-verified JWS so `@mpgd/game-services/app-store-verifier`
+* verifies it offline and falls back to the Server API only without it.
+*/
+export declare const appStoreSignedTransactionEvidenceSchema = "app-store.signed-transaction.v1";
+/** Payload of an `app-store.signed-transaction.v1` envelope. */
+export interface AppStoreSignedTransactionEvidencePayload {
+  readonly signedTransaction: string;
+  readonly transactionId: string;
+  readonly originalTransactionId?: string;
+  readonly bundleId?: string;
+}
+export interface CreateCapacitorStoreKitCommerceProviderInput {
+  /** Consumable and durable products only; StoreKit subscriptions are out of scope (RFC D-02). */
+  readonly products: readonly StoreCommerceProductMapping[];
+  /**
+  * Authenticated, stable UUID app account token of the current player. The
+  * backend's `resolveAppAccountToken` must resolve the same value.
+  */
+  readonly getAppAccountToken: () => string | Promise<string>;
+  /** Recorded in the evidence payload when known; the backend checks the signed value anyway. */
+  readonly bundleId?: string;
+  readonly sdk?: CapacitorStoreKitStoreSdkPlugin;
+  readonly isIos?: () => boolean;
+  /** Extra store codes merged over the StoreKit table. */
+  readonly mapError?: StoreSdkErrorCodeMap;
+  /**
+  * Observes transactions the SDK keeps away from the reconciler: unmapped
+  * SKUs, transactions bound to another app account token, and StoreKit
+  * types that disagree with the catalog kind. Diagnostics only.
+  */
+  readonly onDiagnostic?: (diagnostic: CapacitorStoreKitDiagnostic) => void;
+}
+/**
+* Commerce v2 `CommerceProvider` for the App Store: `createStoreCommerceProvider`
+* over `createCapacitorStoreKitStoreSdk` with the App Store profile,
+* `authority: { evidence: 'client-token', accountBinding: 'required' }`, and
+* `app-store.signed-transaction.v1` evidence whose `signedTransaction` is the
+* same JWS as `StorePurchase.token`. The provider never grants: the game
+* backend verifies the JWS, writes the ledger entry, and only then does the
+* reconciler call `finishTransaction` with that entry id.
+*/
+export declare function createCapacitorStoreKitCommerceProvider(input: CreateCapacitorStoreKitCommerceProviderInput): StoreCommerceProvider;
+export interface CreateCapacitorStoreKitServiceProviderInput extends CreateCapacitorStoreKitCommerceProviderInput {
+  /** Registry id. Defaults to `apple-storekit`, the v1 provider id. */
+  readonly id?: string;
+}
+/**
+* The commerce v2 provider wrapped as a `CapacitorServiceProvider` for
+* `createCapacitorPlatformGateway({ providers })`: the registry serves the
+* `commerce.v2.*` and v1 `commerce.*` bridge methods from it and exposes it
+* as `gateway.commerceV2`. Register either this or the v1
+* `createCapacitorStoreKitProvider`, never both.
+*/
+export declare function createCapacitorStoreKitServiceProvider(input: CreateCapacitorStoreKitServiceProviderInput): CapacitorCommerceServiceProvider;

package/dist/commerce-provider.js

@@ -0,0 +1,108 @@
+import { createCommerceServiceProvider, createStoreCommerceProvider, } from '@mpgd/adapter-capacitor';
+import { CommerceError } from '@mpgd/platform/commerce';
+import { capacitorStoreKitErrorCodeMap, createCapacitorStoreKitStoreSdk, readAppAccountToken, } from './store-sdk.js';
+/**
+ * Evidence schema of a commerce v2 App Store purchase. The payload carries
+ * the StoreKit-verified JWS so `@mpgd/game-services/app-store-verifier`
+ * verifies it offline and falls back to the Server API only without it.
+ */
+export const appStoreSignedTransactionEvidenceSchema = 'app-store.signed-transaction.v1';
+/**
+ * Commerce v2 `CommerceProvider` for the App Store: `createStoreCommerceProvider`
+ * over `createCapacitorStoreKitStoreSdk` with the App Store profile,
+ * `authority: { evidence: 'client-token', accountBinding: 'required' }`, and
+ * `app-store.signed-transaction.v1` evidence whose `signedTransaction` is the
+ * same JWS as `StorePurchase.token`. The provider never grants: the game
+ * backend verifies the JWS, writes the ledger entry, and only then does the
+ * reconciler call `finishTransaction` with that entry id.
+ */
+export function createCapacitorStoreKitCommerceProvider(input) {
+    if (!Array.isArray(input.products) || input.products.length === 0) {
+        throw new TypeError('StoreKit requires at least one product mapping.');
+    }
+    for (const product of input.products) {
+        if (product.kind === 'subscription') {
+            throw new TypeError(`StoreKit product ${product.logicalId} is a subscription; only one-time products are sold.`);
+        }
+    }
+    if (typeof input.getAppAccountToken !== 'function') {
+        throw new TypeError('StoreKit requires getAppAccountToken.');
+    }
+    if (input.bundleId !== undefined
+        && (typeof input.bundleId !== 'string' || input.bundleId.trim() === '')) {
+        throw new TypeError('StoreKit bundleId must be a non-empty string when provided.');
+    }
+    const bundleId = input.bundleId;
+    const sdk = createCapacitorStoreKitStoreSdk({
+        products: input.products.map((product) => ({
+            sku: product.storeSku,
+            kind: product.kind === 'consumable' ? 'consumable' : 'durable',
+        })),
+        getAppAccountToken: input.getAppAccountToken,
+        ...(input.sdk === undefined ? {} : { sdk: input.sdk }),
+        ...(input.isIos === undefined ? {} : { isIos: input.isIos }),
+        ...(input.onDiagnostic === undefined ? {} : { onDiagnostic: input.onDiagnostic }),
+    });
+    return createStoreCommerceProvider({
+        sdk,
+        store: 'app-store',
+        products: input.products,
+        evidenceSchema: appStoreSignedTransactionEvidenceSchema,
+        evidencePayload: (purchase) => {
+            const payload = {
+                signedTransaction: purchase.token,
+                transactionId: purchase.transactionId,
+                ...(purchase.originalTransactionId === undefined
+                    ? {}
+                    : { originalTransactionId: purchase.originalTransactionId }),
+                ...(bundleId === undefined ? {} : { bundleId }),
+            };
+            return { ...payload };
+        },
+        accountBinding: async () => {
+            let value;
+            try {
+                value = await input.getAppAccountToken();
+            }
+            catch (error) {
+                throw new CommerceError('ACCOUNT_BINDING_REQUIRED', {
+                    message: 'The StoreKit app account token could not be resolved.',
+                    storeCode: 'STOREKIT_ACCOUNT_LOOKUP_FAILED',
+                    cause: error,
+                });
+            }
+            try {
+                return {
+                    kind: 'app-account-token',
+                    value: readAppAccountToken({
+                        kind: 'app-account-token',
+                        ...(typeof value === 'string' ? { value } : {}),
+                    }),
+                };
+            }
+            catch (error) {
+                throw new CommerceError('CONFIGURATION_REQUIRED', {
+                    message: 'StoreKit requires a non-nil UUID app account token.',
+                    storeCode: 'STOREKIT_CONFIGURATION_ERROR',
+                    cause: error,
+                });
+            }
+        },
+        authority: { evidence: 'client-token', accountBinding: 'required' },
+        mapError: { ...capacitorStoreKitErrorCodeMap, ...input.mapError },
+    });
+}
+/**
+ * The commerce v2 provider wrapped as a `CapacitorServiceProvider` for
+ * `createCapacitorPlatformGateway({ providers })`: the registry serves the
+ * `commerce.v2.*` and v1 `commerce.*` bridge methods from it and exposes it
+ * as `gateway.commerceV2`. Register either this or the v1
+ * `createCapacitorStoreKitProvider`, never both.
+ */
+export function createCapacitorStoreKitServiceProvider(input) {
+    const { id, ...providerInput } = input;
+    return createCommerceServiceProvider({
+        id: id ?? 'apple-storekit',
+        commerce: createCapacitorStoreKitCommerceProvider(providerInput),
+    });
+}

package/dist/definitions.d.ts

@@ -17,6 +17,13 @@ export interface StoreKitTransaction {
   readonly revokedAt?: string;
   /** StoreKit-verified JWS; the game backend independently verifies Apple data. */
   readonly signedTransaction: string;
+  /**
+  * Present on `getTransactions` results: true for `Transaction.unfinished`
+  * entries, false for current non-consumable entitlements that are already
+  * finished. Omitted by native builds predating the field and by
+  * `purchase` and `transactionUpdated` payloads.
+  */
+  readonly unfinished?: boolean;
 }
 export type StoreKitPurchaseOutcome = {
   readonly status: 'purchased';

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export * from './commerce-provider.js';
 export * from './definitions.js';
 export * from './plugin.js';
 export * from './provider.js';
+export * from './store-sdk.js';

package/dist/index.js

@@ -1,3 +1,5 @@
+export * from './commerce-provider.js';
 export * from './definitions.js';
 export * from './plugin.js';
 export * from './provider.js';
+export * from './store-sdk.js';

package/dist/provider.d.ts

@@ -46,8 +46,17 @@ export interface CapacitorStoreKitProvider {
     nativeIap: 'available' | 'configuration-required' | 'temporarily-unavailable' | 'unsupported';
   }>>;
   getAppAccountToken(): Promise<string>;
+  /**
+  * @deprecated v1 recovery driver. Commerce v2 lists unfinished transactions
+  * through `createCapacitorStoreKitCommerceProvider().getAvailablePurchases`
+  * and the single reconciler (RFC C1) resolves them; removed in C4.
+  */
   getRecoverableTransactions(): Promise<StoreKitRecoverySnapshot>;
   /**
+  * @deprecated v1 recovery driver. Commerce v2 finishes through
+  * `CommerceProvider.finishTransaction` after the ledger grant, driven by
+  * the single reconciler (RFC C1); removed in C4.
+  *
   * Finish a transaction the backend already granted. The provider accepts
   * only a transaction and ledger entry pair that recoverStoreKitPurchases
   * recorded from a backend answer in this session, and consumes the pair
@@ -97,7 +106,12 @@ export interface RecoveredStoreKitPurchase {
   readonly finishPending?: boolean;
   readonly verification?: StoreKitPurchaseVerification;
 }
-/** Submit unfinished purchases to the backend before asking StoreKit to finish. */
+/**
+* Submit unfinished purchases to the backend before asking StoreKit to finish.
+*
+* @deprecated v1 recovery driver. The commerce v2 reconciler (RFC C1) over
+* `createCapacitorStoreKitCommerceProvider` replaces it; removed in C4.
+*/
 export declare function recoverStoreKitPurchases(input: {
   readonly provider: CapacitorStoreKitProvider;
   readonly backend: StoreKitRecoveryBackend;

package/dist/provider.js

@@ -17,7 +17,12 @@ const transactionPattern = /^[1-9][0-9]{0,19}$/u;
  * grants, and in the native plugin never granting anything on finish.
  */
 const verifiedGrants = new WeakMap();
-/** Submit unfinished purchases to the backend before asking StoreKit to finish. */
+/**
+ * Submit unfinished purchases to the backend before asking StoreKit to finish.
+ *
+ * @deprecated v1 recovery driver. The commerce v2 reconciler (RFC C1) over
+ * `createCapacitorStoreKitCommerceProvider` replaces it; removed in C4.
+ */
 export async function recoverStoreKitPurchases(input) {
     if (input.playerId.trim() === '') {
         throw new TypeError('StoreKit recovery requires an authenticated player ID.');

package/dist/store-sdk.d.ts

@@ -0,0 +1,82 @@
+import { type StoreSdk, type StoreSdkCapabilities, type StoreSdkErrorCodeMap, type StoreSdkPurchase } from '@mpgd/adapter-capacitor';
+import type { StorePurchaseAccountBinding } from '@mpgd/platform/commerce';
+import type { CapacitorStoreKitPlugin, StoreKitTransaction } from './definitions.js';
+/** The plugin surface the commerce v2 SDK drives; `CapacitorStoreKit` by default. */
+export type CapacitorStoreKitStoreSdkPlugin = Pick<CapacitorStoreKitPlugin, 'getProducts' | 'purchase' | 'getTransactions' | 'sync' | 'finishTransaction' | 'addListener'>;
+/** One-time kinds the App Store sells; `durable` is a StoreKit non-consumable. */
+export type StoreKitOneTimeKind = 'consumable' | 'durable';
+/** A store SKU the SDK is configured to sell and the kind the catalog declares for it. */
+export interface CapacitorStoreKitStoreSdkProduct {
+  readonly sku: string;
+  readonly kind: StoreKitOneTimeKind;
+}
+/**
+* A transaction the SDK saw and deliberately kept away from the reconciler:
+* one for a SKU outside the configured catalog, one bound to another app
+* account token (shared device or in-game account switch), or one whose
+* StoreKit type disagrees with the catalog kind. Diagnostics only; nothing
+* here is a purchase the game may act on.
+*/
+export type CapacitorStoreKitDiagnostic = {
+  readonly type: 'unmapped-sku';
+  readonly sku: string;
+  readonly transactionId: string;
+} | {
+  readonly type: 'account-mismatch';
+  readonly sku: string;
+  readonly transactionId: string;
+  readonly appAccountToken?: string;
+} | {
+  readonly type: 'kind-mismatch';
+  readonly sku: string;
+  readonly transactionId: string;
+  readonly expected: StoreKitOneTimeKind;
+  readonly reported: StoreKitOneTimeKind;
+};
+export interface CreateCapacitorStoreKitStoreSdkInput {
+  /** The SKUs the catalog sells through the App Store, with their declared kinds. */
+  readonly products: readonly CapacitorStoreKitStoreSdkProduct[];
+  /**
+  * The active player's app account token (a UUID). Transactions bound to any
+  * other token are never listed or emitted; the backend binds the same value.
+  */
+  readonly getAppAccountToken: () => string | Promise<string>;
+  readonly sdk?: CapacitorStoreKitStoreSdkPlugin;
+  readonly isIos?: () => boolean;
+  /** Observes transactions the SDK excludes; never a grant signal. */
+  readonly onDiagnostic?: (diagnostic: CapacitorStoreKitDiagnostic) => void;
+}
+/**
+* Capacitor StoreKit `StoreSdk`: the commerce v2 surface over the native
+* StoreKit 2 collector (RFC B3). The App Store profile is consumable plus
+* durable, no subscriptions, no quantity, `pending` (Ask to Buy), `restore`
+* (`AppStore.sync`), and `finish: 'client'` after the ledger grant. Every
+* purchase carries the StoreKit-verified `signedTransaction` JWS as its
+* `token`; the backend verifies that JWS itself and nothing here grants.
+*
+* The SDK answers only for the configured catalog and the active account: a
+* transaction for an unmapped SKU, for another app account token, or whose
+* StoreKit type disagrees with the catalog kind is reported through
+* `onDiagnostic` and never reaches `getAvailablePurchases` or an event, so
+* the reconciler never journals a purchase it cannot resolve or that belongs
+* to another player.
+*/
+export declare function createCapacitorStoreKitStoreSdk(input: CreateCapacitorStoreKitStoreSdkInput): StoreSdk;
+/** The App Store profile from the RFC "Capabilities" table. */
+export declare const storeKitStoreSdkCapabilities: StoreSdkCapabilities;
+/**
+* StoreKit plugin codes merged over `defaultStoreSdkErrorCodeMap`. Codes the
+* default table already carries (`STOREKIT_PURCHASE_UNCERTAIN`,
+* `STOREKIT_UNAVAILABLE`, `STOREKIT_PRODUCT_UNKNOWN`,
+* `STOREKIT_PRODUCT_UNAVAILABLE`, `STOREKIT_CONFIGURATION_ERROR`,
+* `STOREKIT_EVIDENCE_INVALID`) are repeated here so the table reads complete.
+*/
+export declare const storeKitStoreSdkErrorCodeMap: StoreSdkErrorCodeMap;
+/** The default table plus every StoreKit code; what the provider uses. */
+export declare const capacitorStoreKitErrorCodeMap: StoreSdkErrorCodeMap;
+/** Normalizes a required `app-account-token` binding to the lowercase UUID StoreKit expects. */
+export declare function readAppAccountToken(binding: StorePurchaseAccountBinding | undefined): string;
+/** Maps a verified StoreKit transaction to the SDK purchase: the JWS is the token. */
+export declare function toSdkPurchase(transaction: StoreKitTransaction): StoreSdkPurchase;
+/** Shape check of a transaction the native side reported; the backend verifies the JWS. */
+export declare function isValidStoreKitTransaction(value: unknown): value is StoreKitTransaction;

package/dist/store-sdk.js

@@ -0,0 +1,540 @@
+import { Capacitor } from '@capacitor/core';
+import { defaultStoreSdkErrorCodeMap, } from '@mpgd/adapter-capacitor';
+import { CapacitorStoreKit } from './plugin.js';
+/**
+ * Capacitor StoreKit `StoreSdk`: the commerce v2 surface over the native
+ * StoreKit 2 collector (RFC B3). The App Store profile is consumable plus
+ * durable, no subscriptions, no quantity, `pending` (Ask to Buy), `restore`
+ * (`AppStore.sync`), and `finish: 'client'` after the ledger grant. Every
+ * purchase carries the StoreKit-verified `signedTransaction` JWS as its
+ * `token`; the backend verifies that JWS itself and nothing here grants.
+ *
+ * The SDK answers only for the configured catalog and the active account: a
+ * transaction for an unmapped SKU, for another app account token, or whose
+ * StoreKit type disagrees with the catalog kind is reported through
+ * `onDiagnostic` and never reaches `getAvailablePurchases` or an event, so
+ * the reconciler never journals a purchase it cannot resolve or that belongs
+ * to another player.
+ */
+export function createCapacitorStoreKitStoreSdk(input) {
+    const sdk = input.sdk ?? CapacitorStoreKit;
+    const isIos = input.isIos ?? (() => Capacitor.getPlatform() === 'ios');
+    const onDiagnostic = input.onDiagnostic ?? (() => undefined);
+    if (typeof input.getAppAccountToken !== 'function') {
+        throw new TypeError('StoreKit requires getAppAccountToken.');
+    }
+    const kinds = new Map();
+    for (const product of input.products) {
+        if (!isRecord(product) || !productPattern.test(String(product.sku))) {
+            throw new TypeError(`StoreKit product id ${String(product?.sku)} is invalid.`);
+        }
+        if (product.kind !== 'consumable' && product.kind !== 'durable') {
+            throw new TypeError(`StoreKit product ${product.sku} must be consumable or durable.`);
+        }
+        if (kinds.has(product.sku)) {
+            throw new TypeError(`StoreKit product ${product.sku} is configured twice.`);
+        }
+        kinds.set(product.sku, product.kind);
+    }
+    const productIds = [...kinds.keys()];
+    // Store products seen by `fetchProducts` or the availability probe; the
+    // pre-purchase kind check reads them instead of a second lookup.
+    const knownProducts = new Map();
+    const unresolvedAccountToken = (error) => Object.assign(storeKitError('ACCOUNT_BINDING_REQUIRED', 'The StoreKit app account token could not be resolved.', false), { cause: error });
+    const normalizeAccountToken = (value) => readAppAccountToken({
+        kind: 'app-account-token',
+        ...(typeof value === 'string' ? { value } : {}),
+    });
+    /**
+     * The active account token; a synchronous resolver answers synchronously so
+     * native events are admitted in the same tick they arrive, an asynchronous
+     * one defers the admission.
+     */
+    const resolveAppAccountToken = () => {
+        let value;
+        try {
+            value = input.getAppAccountToken();
+        }
+        catch (error) {
+            throw unresolvedAccountToken(error);
+        }
+        if (isPromiseLike(value)) {
+            return Promise.resolve(value).then(normalizeAccountToken, (error) => {
+                throw unresolvedAccountToken(error);
+            });
+        }
+        return normalizeAccountToken(value);
+    };
+    /**
+     * Keeps a verified transaction only when it is sellable to the active
+     * player: configured SKU, declared kind, and the active account token.
+     */
+    const admit = (transaction, appAccountToken) => {
+        const expected = kinds.get(transaction.productId);
+        if (expected === undefined) {
+            onDiagnostic({
+                type: 'unmapped-sku',
+                sku: transaction.productId,
+                transactionId: transaction.transactionId,
+            });
+            return false;
+        }
+        if (transaction.appAccountToken?.toLowerCase() !== appAccountToken) {
+            onDiagnostic({
+                type: 'account-mismatch',
+                sku: transaction.productId,
+                transactionId: transaction.transactionId,
+                ...(transaction.appAccountToken === undefined
+                    ? {}
+                    : { appAccountToken: transaction.appAccountToken.toLowerCase() }),
+            });
+            return false;
+        }
+        const reported = kindOf(transaction.type);
+        if (reported !== expected) {
+            onDiagnostic({
+                type: 'kind-mismatch',
+                sku: transaction.productId,
+                transactionId: transaction.transactionId,
+                expected,
+                reported,
+            });
+            return false;
+        }
+        return true;
+    };
+    const listeners = new Map();
+    let nativeHandle;
+    const emit = (event) => {
+        for (const listener of [...(listeners.get(event.type) ?? [])]) {
+            listener(event);
+        }
+    };
+    const malformed = (transaction) => {
+        emit({
+            type: 'purchaseError',
+            ...(isRecord(transaction) && typeof transaction.productId === 'string'
+                ? { sku: transaction.productId }
+                : {}),
+            error: evidenceInvalid(),
+        });
+    };
+    // Native events are filtered against the active account token. A deferred
+    // admission (asynchronous resolver) queues later events behind it so the
+    // delivery order is kept.
+    let pendingAdmissions = Promise.resolve();
+    let pendingAdmissionCount = 0;
+    const admitEvent = (transaction, appAccountToken) => {
+        if (admit(transaction, appAccountToken)) {
+            emit({ type: 'purchaseUpdated', purchase: toSdkPurchase(transaction) });
+        }
+    };
+    const reportUnresolved = (transaction, error) => {
+        emit({ type: 'purchaseError', sku: transaction.productId, error: error });
+    };
+    const onTransactionUpdated = (transaction) => {
+        if (!isValidStoreKitTransaction(transaction)) {
+            malformed(transaction);
+            return;
+        }
+        if (kinds.get(transaction.productId) === undefined) {
+            // Unmapped before the token is read: no account lookup for a SKU the
+            // catalog does not sell.
+            admit(transaction, '');
+            return;
+        }
+        let token;
+        try {
+            token = resolveAppAccountToken();
+        }
+        catch (error) {
+            reportUnresolved(transaction, error);
+            return;
+        }
+        if (typeof token === 'string' && pendingAdmissionCount === 0) {
+            admitEvent(transaction, token);
+            return;
+        }
+        pendingAdmissionCount += 1;
+        pendingAdmissions = pendingAdmissions
+            .then(() => token)
+            .then((resolved) => {
+            admitEvent(transaction, resolved);
+        }, (error) => {
+            reportUnresolved(transaction, error);
+        })
+            .finally(() => {
+            pendingAdmissionCount -= 1;
+        });
+    };
+    const transactionSubscribers = () => (listeners.get('purchaseUpdated')?.size ?? 0) + (listeners.get('purchaseError')?.size ?? 0);
+    const attachNative = () => {
+        if (nativeHandle !== undefined || !isIos()) {
+            return;
+        }
+        // Registered synchronously so an event delivered right after the first
+        // subscriber attaches is not lost; a rejected attach is forgotten so the
+        // next subscriber retries it.
+        let handle;
+        try {
+            handle = sdk.addListener('transactionUpdated', onTransactionUpdated);
+        }
+        catch {
+            return;
+        }
+        nativeHandle = handle;
+        handle.catch(() => {
+            if (nativeHandle === handle) {
+                nativeHandle = undefined;
+            }
+        });
+    };
+    const detachNative = () => {
+        const handle = nativeHandle;
+        nativeHandle = undefined;
+        handle?.then((value) => value.remove()).catch(() => undefined);
+    };
+    const requireIos = () => {
+        if (!isIos()) {
+            throw storeKitError('STOREKIT_IOS_REQUIRED', 'StoreKit is only available on iOS.', false);
+        }
+    };
+    const lookupProducts = async (skus) => {
+        const products = [];
+        for (let index = 0; index < skus.length; index += maxProductIdsPerLookup) {
+            const response = await sdk.getProducts({
+                productIds: skus.slice(index, index + maxProductIdsPerLookup),
+            });
+            if (!isRecord(response) || !Array.isArray(response.products)) {
+                throw evidenceInvalid('StoreKit returned an invalid product list.');
+            }
+            for (const product of response.products) {
+                if (!isValidStoreKitProduct(product)) {
+                    throw evidenceInvalid('StoreKit returned an invalid product.');
+                }
+                knownProducts.set(product.productId, product);
+                products.push(product);
+            }
+        }
+        return products;
+    };
+    /**
+     * The store product for a configured SKU, checked against the declared
+     * kind before any purchase sheet opens: a catalog that declares the wrong
+     * one-time kind fails here instead of charging the player for a purchase
+     * the backend would reject with `APP_STORE_PRODUCT_TYPE_MISMATCH`.
+     */
+    const assertSellable = async (sku) => {
+        const expected = kinds.get(sku);
+        if (expected === undefined) {
+            throw storeKitError('STOREKIT_PRODUCT_UNKNOWN', `StoreKit product ${sku} is not in the configured catalog.`, false);
+        }
+        const product = knownProducts.get(sku)
+            ?? (await lookupProducts([sku])).find((candidate) => candidate.productId === sku);
+        if (product === undefined) {
+            throw storeKitError('STOREKIT_PRODUCT_UNAVAILABLE', `StoreKit product ${sku} is not available in the store.`, false);
+        }
+        const reported = kindOf(product.type);
+        if (reported !== expected) {
+            throw storeKitError('STOREKIT_CONFIGURATION_ERROR', `StoreKit product ${sku} is ${product.type}; the catalog declares ${expected}.`, false);
+        }
+        return expected;
+    };
+    // Overlapping finishes for the same transaction and ledger entry share one
+    // native call; the v2 reconciler is the gate that authorizes the call.
+    const inFlightFinishes = new Map();
+    return {
+        store: 'app-store',
+        capabilities: storeKitStoreSdkCapabilities,
+        async fetchProducts(request) {
+            requireIos();
+            if (request.type === 'subscription' || request.skus.length === 0) {
+                return [];
+            }
+            const products = [];
+            for (const product of await lookupProducts(request.skus)) {
+                products.push({
+                    sku: product.productId,
+                    kind: kindOf(product.type),
+                    title: product.title,
+                    description: product.description,
+                    price: { formatted: product.formattedPrice, currencyCode: product.currencyCode },
+                });
+            }
+            return products;
+        },
+        async requestPurchase(request) {
+            requireIos();
+            const appAccountToken = readAppAccountToken(request.accountBinding);
+            const expected = await assertSellable(request.sku);
+            const outcome = await sdk.purchase({ productId: request.sku, appAccountToken });
+            if (!isRecord(outcome)) {
+                throw evidenceInvalid('StoreKit returned an invalid purchase result.');
+            }
+            switch (outcome.status) {
+                case 'purchased': {
+                    const transaction = outcome.transaction;
+                    if (!isValidStoreKitTransaction(transaction)
+                        || transaction.productId !== request.sku
+                        || kindOf(transaction.type) !== expected
+                        || transaction.appAccountToken?.toLowerCase() !== appAccountToken) {
+                        throw evidenceInvalid('StoreKit purchase evidence is invalid.');
+                    }
+                    return { outcome: 'purchased', purchase: toSdkPurchase(transaction) };
+                }
+                case 'pending':
+                    // Ask to Buy: the transaction arrives through `transactionUpdated`.
+                    return { outcome: 'launched' };
+                case 'cancelled':
+                    return {
+                        outcome: 'cancelled',
+                        error: { code: 'USER_CANCELLED', retryable: false, storeCode: 'userCancelled' },
+                    };
+                default:
+                    throw evidenceInvalid('StoreKit returned an invalid purchase result.');
+            }
+        },
+        async getAvailablePurchases() {
+            // Pending (Ask to Buy) transactions never appear in `Transaction.unfinished`
+            // before approval, so `includePending` has nothing to filter here.
+            requireIos();
+            const appAccountToken = await resolveAppAccountToken();
+            const response = await sdk.getTransactions();
+            if (!isRecord(response) || !Array.isArray(response.transactions)) {
+                throw evidenceInvalid('StoreKit returned an invalid transaction list.');
+            }
+            const purchases = [];
+            const seen = new Set();
+            for (const transaction of response.transactions) {
+                if (!isValidStoreKitTransaction(transaction)) {
+                    // One malformed transaction is reported on its own and never blocks
+                    // a valid sibling.
+                    malformed(transaction);
+                    continue;
+                }
+                // Available means unfinished: a current entitlement the native side
+                // marks finished is not listed. A build without the flag lists every
+                // transaction, which the backend answers idempotently.
+                if (transaction.unfinished === false || seen.has(transaction.transactionId)) {
+                    continue;
+                }
+                seen.add(transaction.transactionId);
+                if (admit(transaction, appAccountToken)) {
+                    purchases.push(toSdkPurchase(transaction));
+                }
+            }
+            return purchases;
+        },
+        async finishTransaction(request) {
+            requireIos();
+            const { transactionId, ledgerEntryId } = request;
+            if (typeof transactionId !== 'string' || !transactionPattern.test(transactionId)
+                || typeof ledgerEntryId !== 'string' || ledgerEntryId.trim() === '') {
+                throw storeKitError('STOREKIT_FINISH_REQUIRES_GRANT', 'StoreKit finish requires a transaction id and the ledger entry that granted it.', false);
+            }
+            const active = inFlightFinishes.get(transactionId);
+            if (active !== undefined && active.ledgerEntryId === ledgerEntryId) {
+                return active.promise;
+            }
+            const promise = (async () => {
+                const reported = await sdk.finishTransaction({ transactionId, ledgerEntryId });
+                if (!isRecord(reported) || typeof reported.finished !== 'boolean') {
+                    throw evidenceInvalid('StoreKit returned an invalid finish result.');
+                }
+                return { finished: reported.finished };
+            })();
+            inFlightFinishes.set(transactionId, { ledgerEntryId, promise });
+            try {
+                return await promise;
+            }
+            finally {
+                if (inFlightFinishes.get(transactionId)?.promise === promise) {
+                    inFlightFinishes.delete(transactionId);
+                }
+            }
+        },
+        async restorePurchases() {
+            requireIos();
+            const reported = await sdk.sync();
+            if (!isRecord(reported) || reported.synced !== true) {
+                throw storeKitError('STOREKIT_SYNC_FAILED', 'StoreKit account synchronization did not complete.', true);
+            }
+        },
+        addListener(eventName, listener) {
+            const set = listeners.get(eventName) ?? new Set();
+            listeners.set(eventName, set);
+            set.add(listener);
+            // Both events derive from native transaction updates (a malformed update
+            // is a purchaseError), so either subscriber needs the native listener.
+            if (transactionSubscribers() > 0) {
+                attachNative();
+            }
+            return () => {
+                set.delete(listener);
+                if (transactionSubscribers() === 0) {
+                    detachNative();
+                }
+            };
+        },
+        async getAvailability() {
+            if (!isIos()) {
+                return 'unsupported';
+            }
+            if (productIds.length === 0) {
+                return 'configuration-required';
+            }
+            try {
+                // Probe batch by batch until one configured product is sold; only a
+                // catalog with no sellable product at all is a configuration problem.
+                for (let index = 0; index < productIds.length; index += maxProductIdsPerLookup) {
+                    const products = await lookupProducts(productIds.slice(index, index + maxProductIdsPerLookup));
+                    if (products.some((product) => kinds.has(product.productId))) {
+                        return 'available';
+                    }
+                }
+                return 'configuration-required';
+            }
+            catch (error) {
+                const code = isRecord(error) ? error.code : undefined;
+                return code === 'STOREKIT_INVALID_PRODUCTS' || code === 'STOREKIT_PRODUCT_UNAVAILABLE'
+                    ? 'configuration-required'
+                    : 'temporarily-unavailable';
+            }
+        },
+    };
+}
+/** The App Store profile from the RFC "Capabilities" table. */
+export const storeKitStoreSdkCapabilities = Object.freeze({
+    purchase: Object.freeze({
+        consumable: true,
+        durable: true,
+        subscription: false,
+        quantity: false,
+    }),
+    offers: false,
+    pending: true,
+    restore: true,
+    finish: 'client',
+});
+/**
+ * StoreKit plugin codes merged over `defaultStoreSdkErrorCodeMap`. Codes the
+ * default table already carries (`STOREKIT_PURCHASE_UNCERTAIN`,
+ * `STOREKIT_UNAVAILABLE`, `STOREKIT_PRODUCT_UNKNOWN`,
+ * `STOREKIT_PRODUCT_UNAVAILABLE`, `STOREKIT_CONFIGURATION_ERROR`,
+ * `STOREKIT_EVIDENCE_INVALID`) are repeated here so the table reads complete.
+ */
+export const storeKitStoreSdkErrorCodeMap = Object.freeze({
+    STOREKIT_PURCHASE_UNCERTAIN: 'OUTCOME_UNKNOWN',
+    STOREKIT_UNKNOWN_RESULT: 'OUTCOME_UNKNOWN',
+    STOREKIT_UNAVAILABLE: 'STORE_UNAVAILABLE',
+    STOREKIT_IOS_REQUIRED: 'STORE_UNAVAILABLE',
+    STOREKIT_PRODUCT_LOOKUP_FAILED: 'STORE_UNAVAILABLE',
+    STOREKIT_SYNC_FAILED: 'STORE_UNAVAILABLE',
+    STOREKIT_PRODUCT_UNKNOWN: 'ITEM_UNAVAILABLE',
+    STOREKIT_PRODUCT_UNAVAILABLE: 'ITEM_UNAVAILABLE',
+    STOREKIT_CONFIGURATION_ERROR: 'CONFIGURATION_REQUIRED',
+    STOREKIT_INVALID_PRODUCTS: 'CONFIGURATION_REQUIRED',
+    STOREKIT_INVALID_PURCHASE: 'CONFIGURATION_REQUIRED',
+    STOREKIT_FINISH_REQUIRES_GRANT: 'CONFIGURATION_REQUIRED',
+    STOREKIT_EVIDENCE_INVALID: 'INVALID_RESPONSE',
+    STOREKIT_TRANSACTION_UNVERIFIED: 'INVALID_RESPONSE',
+});
+/** The default table plus every StoreKit code; what the provider uses. */
+export const capacitorStoreKitErrorCodeMap = Object.freeze({
+    ...defaultStoreSdkErrorCodeMap,
+    ...storeKitStoreSdkErrorCodeMap,
+});
+const maxProductIdsPerLookup = 100;
+const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const nilUuid = '00000000-0000-0000-0000-000000000000';
+const productPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+// Shape only: the native side parses the UInt64 id and verified the JWS; the
+// backend verifies the JWS again. The patterns stay open so a fake plugin in
+// the conformance vectors can use the vector ids.
+const transactionPattern = /^[A-Za-z0-9._:-]{1,64}$/u;
+const maxSignedTransactionLength = 128 * 1024;
+/** Normalizes a required `app-account-token` binding to the lowercase UUID StoreKit expects. */
+export function readAppAccountToken(binding) {
+    if (binding === undefined) {
+        throw storeKitError('ACCOUNT_BINDING_REQUIRED', 'StoreKit requires an app account token before a purchase.', false);
+    }
+    if (binding.kind !== 'app-account-token') {
+        throw storeKitError('STOREKIT_CONFIGURATION_ERROR', `StoreKit requires an app-account-token binding, not ${binding.kind}.`, false);
+    }
+    const value = typeof binding.value === 'string' ? binding.value.toLowerCase() : '';
+    if (!uuidPattern.test(value) || value === nilUuid) {
+        throw storeKitError('STOREKIT_CONFIGURATION_ERROR', 'StoreKit requires a non-nil UUID app account token.', false);
+    }
+    return value;
+}
+/** Maps a verified StoreKit transaction to the SDK purchase: the JWS is the token. */
+export function toSdkPurchase(transaction) {
+    return {
+        sku: transaction.productId,
+        transactionId: transaction.transactionId,
+        originalTransactionId: transaction.originalTransactionId,
+        state: transaction.revokedAt === undefined ? 'purchased' : 'revoked',
+        purchasedAt: transaction.purchasedAt,
+        token: transaction.signedTransaction,
+        quantity: 1,
+        ...(transaction.appAccountToken === undefined
+            ? {}
+            : {
+                accountBinding: {
+                    kind: 'app-account-token',
+                    value: transaction.appAccountToken.toLowerCase(),
+                },
+            }),
+        raw: {
+            type: transaction.type,
+            ...(transaction.revokedAt === undefined ? {} : { revokedAt: transaction.revokedAt }),
+            ...(transaction.unfinished === undefined ? {} : { unfinished: transaction.unfinished }),
+        },
+    };
+}
+/** Shape check of a transaction the native side reported; the backend verifies the JWS. */
+export function isValidStoreKitTransaction(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return typeof value.transactionId === 'string' && transactionPattern.test(value.transactionId)
+        && typeof value.originalTransactionId === 'string'
+        && transactionPattern.test(value.originalTransactionId)
+        && typeof value.productId === 'string' && productPattern.test(value.productId)
+        && (value.type === 'consumable' || value.type === 'non_consumable')
+        && typeof value.purchasedAt === 'string' && Number.isFinite(Date.parse(value.purchasedAt))
+        && typeof value.signedTransaction === 'string'
+        && value.signedTransaction.length > 0
+        && value.signedTransaction.length <= maxSignedTransactionLength
+        && (value.revokedAt === undefined
+            || (typeof value.revokedAt === 'string' && Number.isFinite(Date.parse(value.revokedAt))))
+        && (value.appAccountToken === undefined
+            || (typeof value.appAccountToken === 'string' && uuidPattern.test(value.appAccountToken)))
+        && (value.unfinished === undefined || typeof value.unfinished === 'boolean');
+}
+function kindOf(type) {
+    return type === 'consumable' ? 'consumable' : 'durable';
+}
+function isValidStoreKitProduct(value) {
+    return isRecord(value)
+        && typeof value.productId === 'string' && productPattern.test(value.productId)
+        && (value.type === 'consumable' || value.type === 'non_consumable')
+        && typeof value.title === 'string'
+        && typeof value.description === 'string'
+        && typeof value.formattedPrice === 'string'
+        && typeof value.currencyCode === 'string' && value.currencyCode.length > 0;
+}
+function storeKitError(code, message, retryable) {
+    return Object.assign(new Error(message), { code, retryable });
+}
+function evidenceInvalid(message = 'StoreKit transaction evidence is invalid.') {
+    return storeKitError('STOREKIT_EVIDENCE_INVALID', message, false);
+}
+function isPromiseLike(value) {
+    return (typeof value === 'object' || typeof value === 'function')
+        && value !== null
+        && typeof value.then === 'function';
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/ios/Sources/CapacitorStoreKit/CapacitorStoreKitPlugin.swift

@@ -114,15 +114,20 @@ public class CapacitorStoreKitPlugin: CAPPlugin, CAPBridgedPlugin {
         Task {
             var byId: [String: [String: Any]] = [:]
             for await result in Transaction.unfinished {
-                if let payload = Self.verifiedPayload(result),
+                if var payload = Self.verifiedPayload(result),
                    let id = payload["transactionId"] as? String {
+                    payload["unfinished"] = true
                     byId[id] = payload
                 }
             }
+            // Current non-consumable entitlements are listed for the v1 restore
+            // flow; `unfinished: false` lets the commerce v2 SDK exclude them.
             for await result in Transaction.currentEntitlements {
-                if let payload = Self.verifiedPayload(result),
+                if var payload = Self.verifiedPayload(result),
                    payload["type"] as? String == "non_consumable",
-                   let id = payload["transactionId"] as? String {
+                   let id = payload["transactionId"] as? String,
+                   byId[id] == nil {
+                    payload["unfinished"] = false
                     byId[id] = payload
                 }
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mpgd/capacitor-storekit",
-  "version": "0.1.9",
-  "description": "Opt-in StoreKit 2 one-time purchase collector for mpgd Capacitor games.",
+  "version": "0.2.0",
+  "description": "Opt-in StoreKit 2 one-time purchase collector and commerce v2 provider for mpgd Capacitor games.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -38,17 +38,18 @@
   ],
   "peerDependencies": {
     "@capacitor/core": "^8.5.1",
-    "@mpgd/bridge": "^0.11.0",
-    "@mpgd/platform": "^0.18.0"
+    "@mpgd/adapter-capacitor": "^0.9.0",
+    "@mpgd/bridge": "^0.12.1",
+    "@mpgd/platform": "^0.20.0"
   },
   "devDependencies": {
     "@capacitor/core": "8.5.2",
     "ttsc": "0.30.4",
     "typescript": "7.0.2",
-    "@mpgd/adapter-capacitor": "0.7.5",
-    "@mpgd/bridge": "0.11.0",
-    "@mpgd/game-services": "0.19.1",
-    "@mpgd/platform": "0.18.0"
+    "@mpgd/bridge": "0.12.1",
+    "@mpgd/adapter-capacitor": "0.9.0",
+    "@mpgd/game-services": "0.21.0",
+    "@mpgd/platform": "0.20.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -58,6 +59,6 @@
   "scripts": {
     "check": "ttsc --noEmit",
     "lint": "ttsc --noEmit",
-    "test": "cd ../.. && node tools/run-ttsx.mjs native-plugins/capacitor-storekit/src/provider.test.ts"
+    "test": "cd ../.. && node tools/run-ttsx.mjs native-plugins/capacitor-storekit/src/provider.test.ts && node tools/run-ttsx.mjs native-plugins/capacitor-storekit/src/store-sdk.test.ts && node tools/run-ttsx.mjs native-plugins/capacitor-storekit/src/commerce-provider.test.ts && node tools/run-ttsx.mjs native-plugins/capacitor-storekit/src/commerce-provider.conformance.test.ts"
   }
 }