@chipmobilesdk/rn-payment 0.4.1 → 0.6.0

package/src/persistence/snapshot.ts

@@ -9,12 +9,16 @@
  * identity, raw receipts, verification payloads, and backend tokens.
  */
 
-import type { EntitlementKey, ProductKey, ProductType } from '../config/types';
+import type { ProductKey, ProductType } from '../config/types';
 
-export const SNAPSHOT_SCHEMA_VERSION = 1;
+/**
+ * 2 since 0.6.0: the never-written `entitlements` map and `finalized` state are
+ * gone (PAY-12). Entitlements are always derived from purchases, never stored.
+ */
+export const SNAPSHOT_SCHEMA_VERSION = 2;
 
 /** Where a transaction stands with the store. */
-export type PersistedPurchaseState = 'pending' | 'purchased' | 'finalized' | 'consumed' | 'revoked';
+export type PersistedPurchaseState = 'pending' | 'purchased' | 'consumed' | 'revoked';
 
 /**
  * Where a transaction stands in the finalization queue.
@@ -44,18 +48,10 @@ export interface PersistedPurchase {
 	willAutoRenew?: boolean;
 }
 
-export interface PersistedEntitlement {
-	sources: ProductKey[];
-	expiresAt?: number;
-	willAutoRenew?: boolean;
-	isCancelledButValid?: boolean;
-}
-
 export interface PersistedSnapshot {
 	schemaVersion: number;
 	/** Opaque partition key. Stored only to scope this record (FR-057a). */
 	scopeToken?: string;
-	entitlements: Record<EntitlementKey, PersistedEntitlement>;
 	purchases: PersistedPurchase[];
 	lastSyncedAt?: number;
 }
@@ -64,7 +60,6 @@ export function emptySnapshot(scopeToken?: string): PersistedSnapshot {
 	return {
 		schemaVersion: SNAPSHOT_SCHEMA_VERSION,
 		scopeToken,
-		entitlements: {},
 		purchases: [],
 		lastSyncedAt: undefined,
 	};
@@ -83,14 +78,30 @@ export interface SnapshotMigration {
 	migrate(input: Record<string, unknown>): Record<string, unknown>;
 }
 
-/**
- * Registered migrations.
- *
- * Empty at v1 by definition — there is no earlier shipped version to migrate
- * from. The chain exists now so the first real migration is a one-entry change
- * rather than a refactor under time pressure.
- */
-export const SNAPSHOT_MIGRATIONS: readonly SnapshotMigration[] = [];
+/** Registered migrations, one hop each. */
+export const SNAPSHOT_MIGRATIONS: readonly SnapshotMigration[] = [
+	{
+		// v1 stored an `entitlements` map nothing ever wrote to, and a `finalized`
+		// purchase state nothing ever set (PAY-12). Both go; a `finalized` record,
+		// should one exist, is a purchased one whose finalize progress is kept.
+		from: 1,
+		to: 2,
+		migrate(input) {
+			const rest = { ...input };
+			delete rest.entitlements;
+			const purchases = Array.isArray(rest.purchases)
+				? rest.purchases.map(record =>
+						typeof record === 'object' &&
+						record !== null &&
+						(record as { state?: unknown }).state === 'finalized'
+							? { ...(record as object), state: 'purchased' }
+							: record,
+					)
+				: rest.purchases;
+			return { ...rest, schemaVersion: 2, purchases };
+		},
+	},
+];
 
 export type MigrationOutcome =
 	| { ok: true; snapshot: PersistedSnapshot; migrated: boolean }
@@ -146,12 +157,7 @@ export function migrateSnapshot(raw: unknown): MigrationOutcome {
  * truncated file.
  */
 function coerceSnapshot(input: Record<string, unknown>): PersistedSnapshot | null {
-	const entitlements = input.entitlements;
 	const purchases = input.purchases;
-
-	if (typeof entitlements !== 'object' || entitlements === null) {
-		return null;
-	}
 	if (!Array.isArray(purchases)) {
 		return null;
 	}
@@ -162,12 +168,81 @@ function coerceSnapshot(input: Record<string, unknown>): PersistedSnapshot | nul
 	return {
 		schemaVersion: SNAPSHOT_SCHEMA_VERSION,
 		scopeToken,
-		entitlements: entitlements as Record<EntitlementKey, PersistedEntitlement>,
-		purchases: purchases as PersistedPurchase[],
+		// Record by record: one damaged entry is dropped, not trusted and not
+		// allowed to discard the rest (PAY-13). A dropped record comes back with the
+		// next sync, if the store still reports it.
+		purchases: purchases.flatMap(record => {
+			const valid = coercePurchase(record);
+			return valid ? [valid] : [];
+		}),
 		lastSyncedAt,
 	};
 }
 
+const PURCHASE_STATES: ReadonlySet<string> = new Set([
+	'pending',
+	'purchased',
+	'consumed',
+	'revoked',
+]);
+const FINALIZE_STATES: ReadonlySet<string> = new Set([
+	'not_required',
+	'queued',
+	'in_flight',
+	'done',
+	'failed',
+]);
+const VALIDATION_STATES: ReadonlySet<string> = new Set([
+	'not_required',
+	'approved',
+	'rejected',
+	'queued_for_revalidation',
+]);
+const PRODUCT_TYPES: ReadonlySet<string> = new Set([
+	'one_time_permanent',
+	'one_time_consumable',
+	'subscription',
+]);
+
+/** A persisted purchase with every field checked, or null when any is wrong. */
+function coercePurchase(input: unknown): PersistedPurchase | null {
+	if (typeof input !== 'object' || input === null) {
+		return null;
+	}
+	const record = input as Record<string, unknown>;
+	const text = (value: unknown): value is string => typeof value === 'string' && value !== '';
+	const count = (value: unknown): value is number =>
+		typeof value === 'number' && Number.isFinite(value) && value >= 0;
+	if (
+		!text(record.transactionId) ||
+		!text(record.productKey) ||
+		!text(record.token) ||
+		!PRODUCT_TYPES.has(record.productType as string) ||
+		!PURCHASE_STATES.has(record.state as string) ||
+		!FINALIZE_STATES.has(record.finalizeState as string) ||
+		!VALIDATION_STATES.has(record.validationState as string) ||
+		!count(record.purchasedAt) ||
+		!count(record.attempts) ||
+		(record.expiresAt !== undefined && !count(record.expiresAt)) ||
+		(record.willAutoRenew !== undefined && typeof record.willAutoRenew !== 'boolean')
+	) {
+		return null;
+	}
+	return {
+		transactionId: record.transactionId,
+		productKey: record.productKey,
+		productType: record.productType as PersistedPurchase['productType'],
+		token: record.token,
+		state: record.state as PersistedPurchaseState,
+		purchasedAt: record.purchasedAt,
+		finalizeState: record.finalizeState as PersistedFinalizeState,
+		attempts: record.attempts,
+		validationState: record.validationState as PersistedValidationState,
+		expiresAt: record.expiresAt as number | undefined,
+		willAutoRenew: record.willAutoRenew as boolean | undefined,
+	};
+}
+
 /**
  * Decides a purchase's finalization state from the store's view plus what we
  * already knew.

package/src/react/PaymentProvider.tsx

@@ -10,50 +10,112 @@ import React, {
 	createContext,
 	useContext,
 	useEffect,
-	useMemo,
 	useRef,
+	useState,
 	type PropsWithChildren,
 } from 'react';
 import { createEngine, type EngineDeps, type PaymentEngine } from '../engine/engine';
+import { syncOnForeground as watchForeground } from '../engine/foreground';
 import type { PaymentConfig } from '../config/types';
 
 const PaymentContext = createContext<PaymentEngine | null>(null);
 
-export interface PaymentProviderProps {
+interface OwnedEngineProps {
 	config: PaymentConfig;
 	/**
-	 * Provider injection.
-	 *
-	 * Required until the real adapter ships; also how a test or the demo app
-	 * supplies the fake store. Keeping it explicit rather than defaulting to a
-	 * lazily-required binding means a missing native module is a clear
-	 * configuration error instead of a mysterious runtime failure.
+	 * The store provider and storage. Usually `{ provider: createStoreProvider() }`;
+	 * a test or the demo app supplies the fake store here.
 	 */
 	deps: EngineDeps;
+	/**
+	 * When this changes, the provider builds a new engine. Defaults to
+	 * `config.scopeToken`, so switching accounts gets a fresh one. `config` and
+	 * `deps` themselves are read when an engine is built and may be inline objects:
+	 * a new object on every render no longer reconnects to the store (PAY-07).
+	 */
+	engineKey?: string;
+	engine?: undefined;
+}
+
+interface ExternalEngineProps {
+	/**
+	 * An engine the app created and owns. The provider shares it with the tree and
+	 * neither initializes nor cleans it up.
+	 */
+	engine: PaymentEngine;
+	config?: undefined;
+	deps?: undefined;
+	engineKey?: undefined;
+}
+
+export type PaymentProviderProps = (OwnedEngineProps | ExternalEngineProps) & {
 	/** Skip automatic initialization when the app wants to control the moment. */
 	autoInitialize?: boolean;
-}
+	/**
+	 * Call `handleForeground()` each time the app returns from the background, through
+	 * rn-core's shared lifecycle port. Off by default: what counts as a foreground
+	 * return is the app's decision (FR-059).
+	 */
+	syncOnForeground?: boolean;
+};
+
+export function PaymentProvider(
+	props: PropsWithChildren<PaymentProviderProps>,
+): React.ReactElement {
+	const { autoInitialize = true, syncOnForeground = false, children } = props;
+	const external = props.engine;
+	const key = props.engine ? undefined : (props.engineKey ?? props.config.scopeToken);
+
+	// The latest config and deps, read only when an engine is built.
+	const latest = useRef(props);
+	latest.current = props;
+	const build = (): PaymentEngine => {
+		const current = latest.current;
+		if (current.engine) {
+			return current.engine;
+		}
+		return createEngine(current.config, current.deps);
+	};
 
-export function PaymentProvider({
-	config,
-	deps,
-	autoInitialize = true,
-	children,
-}: PropsWithChildren<PaymentProviderProps>): React.ReactElement {
-	// Built once per config identity. Rebuilding on every render would reconnect
-	// to the billing service repeatedly, which FR-018 exists to prevent.
-	const engine = useMemo(() => createEngine(config, deps), [config, deps]);
-	const engineRef = useRef<PaymentEngine>(engine);
-	engineRef.current = engine;
+	// Built once, not once per render: validating the catalog and opening storage
+	// are not render work, and a new engine per render reconnected to the billing
+	// service every time the app's root re-rendered (FR-018, PAY-07).
+	const [owned, setOwned] = useState<PaymentEngine | null>(() => (external ? null : build()));
+	const builtFor = useRef(key);
+	const cleanedUp = useRef(new WeakSet<PaymentEngine>());
+	const engine = external ?? owned ?? build();
 
 	useEffect(() => {
+		if (external) {
+			// The app's engine, so the app's lifecycle.
+			return undefined;
+		}
+		const cleaned = cleanedUp.current;
+		// An engine cleaned up by an earlier run of this effect — StrictMode's
+		// mount-unmount-mount in development, or a changed `engineKey` — is never
+		// reused: it would answer every call with "cleaned up". A fresh one replaces
+		// it and this effect runs again for that one.
+		if (!owned || cleaned.has(owned) || builtFor.current !== key) {
+			builtFor.current = key;
+			setOwned(build());
+			return undefined;
+		}
 		if (autoInitialize) {
-			engine.initialize().catch(() => undefined);
+			owned.initialize().catch(() => undefined);
 		}
 		// Cleanup on unmount is the whole reason the provider owns the engine:
 		// after it, no event fires and no timer survives (FR-082).
-		return () => engine.cleanup();
-	}, [engine, autoInitialize]);
+		return () => {
+			cleaned.add(owned);
+			owned.cleanup();
+		};
+		// `build` reads the latest props through a ref, so it is not a dependency.
+	}, [external, owned, key, autoInitialize]);
+
+	useEffect(
+		() => (syncOnForeground ? watchForeground(engine) : undefined),
+		[engine, syncOnForeground],
+	);
 
 	return <PaymentContext.Provider value={engine}>{children}</PaymentContext.Provider>;
 }

package/src/react/hooks.ts

@@ -8,13 +8,15 @@
  * returns a loading placeholder for an entitlement it already knows (PERF-001).
  */
 
-import { useCallback, useEffect, useState } from 'react';
+import { useExternalStore } from '@chipmobilesdk/rn-core/react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 import { usePaymentEngine } from './PaymentProvider';
 import type {
 	EntitlementKey,
 	FinalizeResult,
 	PaymentStatus,
 	PendingPurchasesState,
+	ProductKey,
 	PurchaseOptions,
 	PurchaseResult,
 	TransactionRef,
@@ -33,34 +35,19 @@ import type { RestoreOutcome, SyncOutcome } from '../engine/engine';
  */
 export function useEntitlement(key: EntitlementKey): EntitlementState {
 	const engine = usePaymentEngine();
-	const [state, setState] = useState<EntitlementState>(() => engine.getEntitlement(key));
-
-	useEffect(() => {
-		// Re-read on subscribe: the entitlement may have changed between the initial
-		// render and this effect.
-		setState(engine.getEntitlement(key));
-		return engine.subscribeEntitlements(map => {
-			const next = map[key];
-			if (next) {
-				setState(next);
-			}
-		});
-	}, [engine, key]);
-
-	return state;
+	// The engine keeps an unchanged entitlement's object across recomputes, so this
+	// selection only changes, and the component only re-renders, when it changes.
+	const select = useCallback(
+		(map: EntitlementMap) => map[key] ?? engine.getEntitlement(key),
+		[engine, key],
+	);
+	return useExternalStore(engine.subscribeEntitlements, engine.getAllEntitlements, select);
 }
 
 /** Every entitlement at once, for a screen that shows overall plan state. */
 export function useEntitlements(): EntitlementMap {
 	const engine = usePaymentEngine();
-	const [map, setMap] = useState<EntitlementMap>(() => engine.getAllEntitlements());
-
-	useEffect(() => {
-		setMap(engine.getAllEntitlements());
-		return engine.subscribeEntitlements(setMap);
-	}, [engine]);
-
-	return map;
+	return useExternalStore(engine.subscribeEntitlements, engine.getAllEntitlements);
 }
 
 function narrowPending(
@@ -99,18 +86,11 @@ export function usePendingPurchases(productKeys?: readonly string[]): PendingPur
 /** Package status, so an app can tell "cannot sell here" from "not paid" (FR-022). */
 export function usePaymentStatus(): PaymentStatus {
 	const engine = usePaymentEngine();
-	const [status, setStatus] = useState<PaymentStatus>(() => engine.getStatus());
-
-	useEffect(() => {
-		setStatus(engine.getStatus());
-		return engine.subscribeStatus(setStatus);
-	}, [engine]);
-
-	return status;
+	return useExternalStore(engine.subscribeStatus, engine.getStatus);
 }
 
 export interface UsePurchaseResult {
-	purchase: (productKey: EntitlementKey, options?: PurchaseOptions) => Promise<PurchaseResult>;
+	purchase: (productKey: ProductKey, options?: PurchaseOptions) => Promise<PurchaseResult>;
 	consume: (ref: TransactionRef) => Promise<FinalizeResult>;
 	isPurchasing: boolean;
 	/** The last outcome, so a screen can render cancellation differently from failure. */
@@ -178,9 +158,13 @@ export function useProducts(productKeys: readonly string[]): UseProductsResult {
 	// Joined so the effect depends on the contents rather than the array identity:
 	// a caller passing a literal would otherwise re-query on every render.
 	const keyToken = productKeys.join('|');
+	// Each load's number. Only the latest may write: when the keys change while a
+	// query is out, the older answer must not overwrite the newer one (PAY-20).
+	const latestRequest = useRef(0);
 
 	const load = useCallback(
 		async (fresh: boolean): Promise<void> => {
+			const request = ++latestRequest.current;
 			const keys = keyToken === '' ? [] : keyToken.split('|');
 			if (keys.length === 0) {
 				setProducts([]);
@@ -190,6 +174,9 @@ export function useProducts(productKeys: readonly string[]): UseProductsResult {
 			setIsLoading(true);
 			try {
 				const result = fresh ? await engine.refreshProducts(keys) : await engine.getProducts(keys);
+				if (request !== latestRequest.current) {
+					return;
+				}
 				if (result.ok) {
 					setProducts(result.products);
 					setMissing(result.missing);
@@ -198,7 +185,9 @@ export function useProducts(productKeys: readonly string[]): UseProductsResult {
 					setError(result.error);
 				}
 			} finally {
-				setIsLoading(false);
+				if (request === latestRequest.current) {
+					setIsLoading(false);
+				}
 			}
 		},
 		[engine, keyToken],

package/src/testing/conformance.ts

@@ -0,0 +1,169 @@
+/**
+ * What any `ProviderPort` must do (IOS-12, PAY-13).
+ *
+ * The same checks run against the fake store and against the Play adapter over a
+ * simulated binding (or the real one, from a demo screen on a device), so a test
+ * that drives the fake proves something about the device path. Each check builds
+ * its own port over the same small store, through a harness.
+ */
+import {
+	ensure,
+	runChecks,
+	type Check,
+	type ConformanceReport,
+} from '@chipmobilesdk/rn-core/testing';
+
+import type { ProviderPort } from '../adapter/port';
+import type { ProductType } from '../config/types';
+
+export interface StoreProductSpec {
+	readonly storeProductId: string;
+	readonly productType: ProductType;
+	/** As the store formats it; the port must pass it through untouched. */
+	readonly formattedPrice: string;
+}
+
+export interface OwnedPurchaseSpec {
+	readonly storeProductId: string;
+	readonly token: string;
+	readonly state: 'purchased' | 'pending';
+}
+
+export interface StoreScenario {
+	readonly products: readonly StoreProductSpec[];
+	readonly owned: readonly OwnedPurchaseSpec[];
+}
+
+export interface ProviderSubject {
+	readonly port: ProviderPort;
+	/** How the next purchase flow the user starts ends. */
+	nextPurchaseEnds(outcome: 'bought' | 'cancelled'): void;
+	/** The billing service goes away underneath the app. */
+	dropService(): void;
+}
+
+export interface ProviderHarness {
+	create(scenario: StoreScenario): ProviderSubject;
+}
+
+/** The store every check runs against. */
+export const CONFORMANCE_STORE: StoreScenario = {
+	products: [
+		{
+			storeProductId: 'conformance.remove_ads',
+			productType: 'one_time_permanent',
+			formattedPrice: '€1.99',
+		},
+		{
+			storeProductId: 'conformance.coins',
+			productType: 'one_time_consumable',
+			formattedPrice: '€0.99',
+		},
+	],
+	owned: [
+		{ storeProductId: 'conformance.remove_ads', token: 'token-owned', state: 'purchased' },
+		{ storeProductId: 'conformance.coins', token: 'token-pending', state: 'pending' },
+	],
+};
+
+export const providerPortChecks: readonly Check<ProviderHarness>[] = [
+	{
+		name: 'connects, and disconnects safely before a connect and twice',
+		async run(harness) {
+			const { port } = harness.create(CONFORMANCE_STORE);
+			await port.disconnect();
+			const outcome = await port.connect();
+			ensure(outcome.ok, `connect failed: ${JSON.stringify(outcome)}`);
+			await port.disconnect();
+			await port.disconnect();
+		},
+	},
+	{
+		name: 'reports a dropped service to observers, and nothing after unsubscribing',
+		async run(harness) {
+			const subject = harness.create(CONFORMANCE_STORE);
+			const seen: boolean[] = [];
+			const stop = subject.port.observeConnection(connected => seen.push(connected));
+			await subject.port.connect();
+			ensure(seen.at(-1) === true, `after connect observers saw ${JSON.stringify(seen)}`);
+			subject.dropService();
+			ensure(seen.at(-1) === false, `after the drop observers saw ${JSON.stringify(seen)}`);
+			stop();
+			const before = seen.length;
+			await subject.port.connect();
+			ensure(seen.length === before, 'notified after unsubscribing');
+		},
+	},
+	{
+		name: 'returns the requested products with the store-formatted price',
+		async run(harness) {
+			const { port } = harness.create(CONFORMANCE_STORE);
+			await port.connect();
+			const products = await port.queryProducts(['conformance.remove_ads'], 'one_time_permanent');
+			ensure(products.length === 1, `expected one product, got ${products.length}`);
+			const [product] = products;
+			ensure(product?.storeProductId === 'conformance.remove_ads', 'wrong product returned');
+			ensure(product.productType === 'one_time_permanent', `product type ${product.productType}`);
+			ensure(product.formattedPrice === '€1.99', `price ${product.formattedPrice}`);
+		},
+	},
+	{
+		name: 'flags a pending purchase rather than filtering it out',
+		async run(harness) {
+			const { port } = harness.create(CONFORMANCE_STORE);
+			await port.connect();
+			const owned = await port.queryOwned();
+			const pending = owned.find(purchase => purchase.token === 'token-pending');
+			const bought = owned.find(purchase => purchase.token === 'token-owned');
+			ensure(pending?.state === 'pending', `pending purchase reported as ${pending?.state}`);
+			ensure(bought?.state === 'purchased', `bought purchase reported as ${bought?.state}`);
+		},
+	},
+	{
+		name: 'reports a bought purchase for the product that was requested',
+		async run(harness) {
+			const subject = harness.create(CONFORMANCE_STORE);
+			await subject.port.connect();
+			subject.nextPurchaseEnds('bought');
+			const outcome = await subject.port.launchPurchase({
+				storeProductId: 'conformance.coins',
+				productType: 'one_time_consumable',
+			});
+			ensure(outcome.ok, `purchase failed: ${JSON.stringify(outcome)}`);
+			ensure(
+				outcome.purchase.storeProductId === 'conformance.coins',
+				'purchase for another product',
+			);
+			ensure(outcome.purchase.token !== '', 'purchase has no token to finalize');
+		},
+	},
+	{
+		name: 'reports a cancelled flow as user_cancelled',
+		async run(harness) {
+			const subject = harness.create(CONFORMANCE_STORE);
+			await subject.port.connect();
+			subject.nextPurchaseEnds('cancelled');
+			const outcome = await subject.port.launchPurchase({
+				storeProductId: 'conformance.remove_ads',
+				productType: 'one_time_permanent',
+			});
+			ensure(!outcome.ok, 'a cancelled flow reported a purchase');
+			ensure(outcome.reason === 'user_cancelled', `reason ${outcome.reason}`);
+		},
+	},
+	{
+		name: 'acknowledges and consumes safely twice',
+		async run(harness) {
+			const { port } = harness.create(CONFORMANCE_STORE);
+			await port.connect();
+			await port.acknowledge('token-owned');
+			await port.acknowledge('token-owned');
+			await port.consume('token-pending');
+			await port.consume('token-pending');
+		},
+	},
+];
+
+export function runProviderPortConformance(harness: ProviderHarness): Promise<ConformanceReport> {
+	return runChecks(() => harness, providerPortChecks);
+}

package/src/testing/fakeStore.ts

@@ -11,6 +11,8 @@
  * testable at all (NFR-007, SC-008).
  */
 
+import { createListenerSet } from '@chipmobilesdk/rn-core';
+
 import type {
 	ProviderCapabilities,
 	ProviderConnectOutcome,
@@ -154,8 +156,10 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 	const acknowledgedTokens: ProviderToken[] = [];
 	const consumedTokens: ProviderToken[] = [];
 	const managementOpenedFor: (StoreProductId | undefined)[] = [];
-	const connectionListeners = new Set<(connected: boolean, reason?: string) => void>();
-	const purchaseListeners = new Set<(purchase: ProviderPurchase) => void>();
+	// The same listener sets as the real adapter, so a throwing observer behaves
+	// identically here and on a device (PAY-17).
+	const connectionListeners = createListenerSet<[boolean, string | undefined]>();
+	const purchaseListeners = createListenerSet<[ProviderPurchase]>();
 
 	let connectCalls = 0;
 	let launchCalls = 0;
@@ -164,9 +168,7 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 
 	const notifyConnection = (next: boolean, reason?: string): void => {
 		connected = next;
-		for (const listener of [...connectionListeners]) {
-			listener(next, reason);
-		}
+		connectionListeners.notify(next, reason);
 	};
 
 	return {
@@ -187,15 +189,7 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 		},
 
 		observeConnection(listener): Unsubscribe {
-			connectionListeners.add(listener);
-			let removed = false;
-			return () => {
-				if (removed) {
-					return;
-				}
-				removed = true;
-				connectionListeners.delete(listener);
-			};
+			return connectionListeners.add(listener);
 		},
 
 		async queryProducts(
@@ -235,23 +229,13 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 			if (androidBinding) {
 				// The binding's update listener fires for every observer, the session-long
 				// one included, before the launch settles.
-				for (const listener of [...purchaseListeners]) {
-					listener(purchase);
-				}
+				purchaseListeners.notify(purchase);
 			}
 			return { ok: true, purchase };
 		},
 
 		observePurchases(listener): Unsubscribe {
-			purchaseListeners.add(listener);
-			let removed = false;
-			return () => {
-				if (removed) {
-					return;
-				}
-				removed = true;
-				purchaseListeners.delete(listener);
-			};
+			return purchaseListeners.add(listener);
 		},
 
 		async acknowledge(token: ProviderToken): Promise<void> {
@@ -306,9 +290,7 @@ export function createFakeStore(options: FakeStoreOptions = {}): FakeStore {
 		},
 		pushPurchaseUpdate(purchase) {
 			owned = [...owned.filter(p => p.transactionId !== purchase.transactionId), purchase];
-			for (const listener of [...purchaseListeners]) {
-				listener(purchase);
-			}
+			purchaseListeners.notify(purchase);
 		},
 		revoke(transactionId) {
 			owned = owned.filter(p => p.transactionId !== transactionId);