@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/iapStore.server.js

@@ -0,0 +1,740 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { captureBoundMethods as n, dataList as r, dataObject as i, identifier as a } from "./capture.js";
+import { positiveAmount as o } from "./amount.js";
+import { captureCurrencies as s } from "./currency.js";
+import { defineShopOffer as c, shopInteger as l } from "./shop.js";
+import { captureIapObservation as u, captureIapOrderReceipt as d, captureIapSubscriptionPeriod as f, iapChannel as p, iapReceiptIntent as m, iapReceiptReference as h, iapTimestamp as g } from "./iap.js";
+import { canonicalDataJson as _ } from "./canonicalDataJson.js";
+import { prepareVerifiedIapNotification as v, readVerifiedIapNotification as y, validateVerifiedIapNotification as b } from "./iapNotifications.server.js";
+import { captureIapNotificationTargetOptions as x, issueAcceptedIapNotificationTarget as S } from "./iapNotificationTarget.server.js";
+import { readVerifiedIapCurrentState as C } from "./iapCurrentState.server.js";
+import { captureIapTransactionFacts as w, readVerifiedIapPurchase as T } from "./iapVerification.server.js";
+import { iapNamespacesTable as E, iapOrdersTable as D, iapReceiptsTable as O, iapSubjectsTable as k } from "./iapTables.entity.js";
+import { issueAcceptedIapCompletion as ee } from "./iapCompletion.server.js";
+import { Effect as A, Result as j } from "effect";
+import { systemSubject as te } from "@voltro/protocol";
+import { createHash as M } from "node:crypto";
+import { and as ne, eq as N, queryFor as P } from "@voltro/database";
+import { executeSqlMutations as re, prepareSqlMutation as ie, prepareSqlMutationGroup as ae } from "@voltro/database/sql";
+import { InventoryError as F } from "@voltro/plugin-inventory/errors";
+// src/iapStore.server.ts
+var I = (e) => {
+	let t = n(e, ["prepare"]), r = typeof e == "object" && e && "checkout" in e && e.checkout !== void 0 ? n(e, ["checkout"]).checkout : void 0;
+	return Object.freeze({
+		prepare: t.prepare,
+		...r ? { checkout: r } : {}
+	});
+}, L = (e) => M("sha256").update(_(e)).digest("hex"), R = (e, ...t) => e + L(t).slice(0, 56), z = (n) => n instanceof e ? n : n instanceof F && [
+	"invalid_input",
+	"invalid_record",
+	"not_found",
+	"erased",
+	"forbidden",
+	"conflict",
+	"limit_exceeded"
+].includes(n.code) ? t(n.code) : t("unavailable"), B = (e) => A.tryPromise({
+	try: e,
+	catch: z
+}), V = (e) => {
+	try {
+		return e();
+	} catch (e) {
+		return A.fail(z(e));
+	}
+}, H = async (e) => {
+	let t = await A.runPromise(e.pipe(A.result));
+	if (j.isFailure(t)) throw t.failure;
+	return t.success;
+}, U = (e) => g(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN), W = (e) => l(e, 0, 2147483647), oe = class extends Error {
+	constructor() {
+		super("Accepted IAP original"), this.name = "IapOriginal";
+	}
+}, se = (e) => {
+	let r = i(e, [
+		"realMoney",
+		"namespace",
+		"currencies",
+		"verification",
+		"admission",
+		"economy",
+		"inventory",
+		"refundDisposition",
+		"systemAccount",
+		"maxHistoryRows",
+		"now"
+	]);
+	if (r.realMoney !== !0) throw t(r.realMoney === !1 ? "real_money_disabled" : "invalid_input");
+	let o = r.now ?? Date.now;
+	if (typeof o != "function") throw t("invalid_input");
+	return Object.freeze({
+		namespace: a(r.namespace),
+		currencies: s(r.currencies),
+		verification: n(r.verification, ["verify"]),
+		admission: I(r.admission),
+		economy: n(r.economy, ["prepareTransfer"]),
+		inventory: r.inventory === void 0 ? void 0 : n(r.inventory, ["prepareGrant"]),
+		refundDisposition: r.refundDisposition === void 0 ? void 0 : n(r.refundDisposition, ["read"]),
+		systemAccount: a(r.systemAccount),
+		maxHistoryRows: l(r.maxHistoryRows ?? 1e4, 1, 1e5),
+		now: o
+	});
+}, G = (e, n) => {
+	let j = se(n), M = j.namespace, F = j.maxHistoryRows, I = R("ein_", M), z = (e, t) => R("eis_", M, e, t), G = (e, t, n) => R("eio_", M, e, t, n), K = (e) => "eir_" + e.slice(0, 56), q = () => g(j.now()), ce = te("economy.iap"), J = (e) => {
+		if (e.type !== "user") throw t("forbidden");
+		return Object.freeze({
+			tenantId: a(e.tenantId),
+			ownerId: a(e.id)
+		});
+	}, le = async (t) => {
+		await e.insertIgnore(E.tableName, {
+			id: I,
+			namespace: M,
+			admission: 0,
+			ordersCount: 0,
+			receiptsCount: 0
+		}, { conflictColumns: ["id"] }), await e.insertIgnore(k.tableName, {
+			id: z(t.tenantId, t.ownerId),
+			namespace: M,
+			tenantId: t.tenantId,
+			ownerId: t.ownerId,
+			erased: !1,
+			admission: 0,
+			ordersCount: 0
+		}, { conflictColumns: ["id"] });
+	}, Y = async (e) => {
+		if (await e.updateMany(E.tableName, { admission: 0 }, { where: N("id", I) }) !== 1) throw t("unavailable");
+		let n = (await e.query(P(E).where(N("id", I)).limit(1).descriptor))[0];
+		if (!n || n.namespace !== M || n.admission !== 0) throw t("invalid_record");
+		return W(n.ordersCount), W(n.receiptsCount), n;
+	}, X = async (e, n, r = !1) => {
+		let i = (await e.query(P(k).where(N("id", z(n.tenantId, n.ownerId))).limit(1).descriptor))[0];
+		if (i) {
+			if (i.namespace !== M || i.tenantId !== n.tenantId || i.admission !== 0 || i.erased !== !0 && i.erased !== !1 || (i.erased ? i.ownerId !== null : i.ownerId !== n.ownerId)) throw t("invalid_record");
+			if (W(i.ordersCount), i.erased === !0 && !r) throw t("erased");
+			return i;
+		}
+	}, Z = async (e, n, r = !1) => {
+		if (await e.updateMany(k.tableName, { admission: 0 }, { where: N("id", z(n.tenantId, n.ownerId)) }) !== 1) throw t("unavailable");
+		let i = await X(e, n, r);
+		if (!i) throw t("invalid_record");
+		return i;
+	}, ue = async (e, n, r) => {
+		let i = await e.query(P(n).where(r).limit(F + 1).descriptor);
+		if (i.length > F) throw t("limit_exceeded");
+		return i;
+	}, de = async (e, n) => {
+		let r = await ue(e, D, N("namespace", M)), i = await ue(e, O, N("namespace", M));
+		if (r.length !== W(n.ordersCount) || i.length !== W(n.receiptsCount)) throw t("invalid_record");
+		for (let e of r) {
+			if (a(e.offerId), a(e.offerVersion), p(e.channel), typeof e.configurationDigest != "string" || !/^[a-f0-9]{64}$/.test(e.configurationDigest) || e.namespace !== M || typeof e.accepted != "boolean" || ![
+				"pending",
+				"fulfilled",
+				"erased"
+			].includes(String(e.state)) || typeof e.ownerKey != "string" || !/^eis_[a-f0-9]{56}$/.test(e.ownerKey) || (e.state === "erased" ? e.ownerId !== null || e.intentDigest !== null || e.snapshot !== null || e.receipt !== null : e.ownerKey !== z(a(e.tenantId), a(e.ownerId)))) throw t("invalid_record");
+			if (e.accepted) {
+				if (l(e.acceptedQuantity, 1, 1e3), l(e.acceptedDay, 0, 1e8), e.state === "pending" || e.fulfilledAt === null || e.acceptedDay !== Math.floor(U(e.fulfilledAt) / 864e5)) throw t("invalid_record");
+			} else if (e.acceptedQuantity !== null || e.acceptedDay !== null || e.fulfilledAt !== null || e.state === "fulfilled") throw t("invalid_record");
+			let n = i.find((t) => t.id === e.receiptKey);
+			if (!n || n.orderKey !== e.id || n.tenantId !== e.tenantId || n.ownerKey !== e.ownerKey || n.accepted !== e.accepted || n.state !== e.state || (e.fulfilledAt === null ? n.fulfilledAt !== null : U(e.fulfilledAt) !== U(n.fulfilledAt))) throw t("invalid_record");
+		}
+		for (let e of i) if (e.namespace !== M || typeof e.identity != "string" || !/^[a-f0-9]{64}$/.test(e.identity) || e.id !== K(e.identity) || typeof e.factsDigest != "string" || !/^[a-f0-9]{64}$/.test(e.factsDigest) || !r.some((t) => t.id === e.orderKey && t.receiptKey === e.id)) throw t("invalid_record");
+		return {
+			orders: r,
+			receipts: i
+		};
+	}, Q = async (e, n, r) => {
+		let i = (await e.query(P(D).where(N("id", r)).limit(1).descriptor))[0];
+		if (i && (i.namespace !== M || i.tenantId !== n.tenantId || i.ownerKey !== z(n.tenantId, n.ownerId))) throw t("invalid_record");
+		return i;
+	}, $ = async (e, n) => {
+		if (n.state !== "fulfilled" || n.accepted !== !0 || typeof n.ownerId != "string") throw t("invalid_record");
+		let u = i(n.snapshot, [
+			"scope",
+			"requestId",
+			"intentDigest",
+			"identity",
+			"product",
+			"currencies",
+			"facts",
+			"verifiedAt",
+			"at"
+		], "invalid_record"), f = i(u.scope, ["tenantId", "ownerId"], "invalid_record"), p = i(u.product, [
+			"offer",
+			"channel",
+			"kind",
+			"storeProductId"
+		], "invalid_record"), m = s(u.currencies), h = c(p.offer, m, !0, { grantless: p.kind === "subscription" }), v = w(u.facts), y = g(u.at), b = g(u.verifiedAt), x = L([
+			v.channel,
+			v.environment,
+			v.applicationId,
+			v.transactionId
+		]);
+		if (f.tenantId !== n.tenantId || f.ownerId !== n.ownerId || n.id !== G(a(f.tenantId), a(f.ownerId), a(u.requestId)) || n.ownerKey !== z(a(f.tenantId), a(f.ownerId)) || u.intentDigest !== n.intentDigest || typeof n.intentDigest != "string" || !/^[a-f0-9]{64}$/.test(n.intentDigest) || u.identity !== x || n.receiptKey !== K(x) || p.channel !== v.channel || p.kind !== v.kind || p.storeProductId !== v.storeProductId || v.quantity > h.maxQuantity || n.offerId !== h.id || n.offerVersion !== h.version || n.channel !== v.channel || n.configurationDigest !== L([p, m]) || n.acceptedQuantity !== v.quantity || n.acceptedDay !== Math.floor(y / 864e5) || y < b || b < v.purchasedAt || y < U(n.createdAt) || y !== U(n.fulfilledAt) || (h.price.kind === "real" ? h.price : h.price.kind === "mixed" ? h.price.real : null)?.storeProductIds[v.channel] !== v.storeProductId) throw t("invalid_record");
+		let S = (await e.query(P(O).where(N("id", K(x))).limit(1).descriptor))[0];
+		if (!S || S.identity !== x || S.factsDigest !== L(v) || S.namespace !== M || S.tenantId !== n.tenantId || S.ownerKey !== n.ownerKey || S.orderKey !== n.id || S.state !== "fulfilled" || S.accepted !== !0 || U(S.fulfilledAt) !== y) throw t("invalid_record");
+		let C = i(n.receipt, [
+			"orderId",
+			"offerId",
+			"offerVersion",
+			"quantity",
+			"at",
+			"pricePaid",
+			"transfers",
+			"grants"
+		], "invalid_record");
+		if (C.orderId !== n.id || C.offerId !== h.id || C.offerVersion !== h.version || C.quantity !== v.quantity || C.at !== y || _(C.pricePaid) !== _(v.paid)) throw t("invalid_record");
+		let T = r(C.transfers, 16, "invalid_record").map((e, n) => {
+			let r = i(e, [
+				"txId",
+				"currency",
+				"amount",
+				"at"
+			], "invalid_record"), s = h.currencies[n];
+			if (!s || r.currency !== s.currency || r.amount !== (BigInt(s.amount) * BigInt(v.quantity)).toString()) throw t("invalid_record");
+			return Object.freeze({
+				txId: a(r.txId),
+				currency: s.currency,
+				amount: o(r.amount).toString(),
+				at: l(r.at, b, y)
+			});
+		}), E = r(C.grants, 16, "invalid_record").map((e, n) => {
+			let o = i(e, [
+				"operationId",
+				"kind",
+				"changes",
+				"at"
+			], "invalid_record"), s = h.items[n];
+			if (!s || o.kind !== "grant") throw t("invalid_record");
+			let c = r(o.changes, F, "invalid_record").map((e) => {
+				let t = i(e, ["instanceId", "delta"], "invalid_record");
+				return Object.freeze({
+					instanceId: a(t.instanceId),
+					delta: l(t.delta, 1, 1e6)
+				});
+			});
+			if (c.reduce((e, t) => e + t.delta, 0) !== s.qty * v.quantity || new Set(c.map((e) => e.instanceId)).size !== c.length) throw t("invalid_record");
+			return Object.freeze({
+				operationId: a(o.operationId),
+				kind: "grant",
+				changes: Object.freeze(c),
+				at: l(o.at, 0, y)
+			});
+		});
+		if (T.length !== h.currencies.length || E.length !== h.items.length || new Set(T.map((e) => e.txId)).size !== T.length || new Set(E.map((e) => e.operationId)).size !== E.length) throw t("invalid_record");
+		return d({
+			orderId: a(n.id),
+			offerId: h.id,
+			offerVersion: h.version,
+			quantity: v.quantity,
+			at: y,
+			pricePaid: v.paid,
+			transfers: T,
+			grants: E
+		});
+	}, fe = async (e, n, r) => {
+		let o = await $(e, n), l = i(n.snapshot, [
+			"scope",
+			"requestId",
+			"intentDigest",
+			"identity",
+			"product",
+			"currencies",
+			"facts",
+			"verifiedAt",
+			"at"
+		], "invalid_record"), u = i(l.product, [
+			"offer",
+			"channel",
+			"kind",
+			"storeProductId"
+		], "invalid_record"), d = s(l.currencies);
+		if (n.tenantId !== r.tenantId || n.ownerId !== r.ownerId) throw t("invalid_record");
+		return Object.freeze({
+			orderId: o.orderId,
+			scope: r,
+			receipt: o,
+			currencies: d,
+			facts: w(l.facts),
+			product: Object.freeze({
+				offer: c(u.offer, d, !0, { grantless: u.kind === "subscription" }),
+				channel: p(u.channel),
+				kind: u.kind,
+				storeProductId: a(u.storeProductId)
+			})
+		});
+	}, pe = async (n, r, i) => e.transactional(async (e) => {
+		await Y(e), await Z(e, n);
+		let a = await Q(e, n, r);
+		if (a) {
+			if (a.intentDigest !== i) throw t("conflict");
+			if (a.state === "fulfilled") return $(e, a);
+			if (a.state !== "pending" || a.accepted !== !1 || a.snapshot !== null || a.receipt !== null || a.fulfilledAt !== null) throw t("invalid_record");
+		}
+	}), me = (n, r) => V(() => {
+		let i = J(n), a = m(r), o = G(i.tenantId, i.ownerId, a.requestId), s = L([
+			M,
+			i,
+			a.channel,
+			a.offerId,
+			a.offerVersion,
+			a.requestId,
+			L(a.receipt)
+		]);
+		return B(async () => {
+			await le(i);
+			let n = await pe(i, o, s);
+			if (n) return n;
+			try {
+				let n = T(await H(j.verification.verify(i, a)));
+				if (_(n.scope) !== _(i) || n.requestId !== a.requestId || n.offerId !== a.offerId || n.offerVersion !== a.offerVersion || n.facts.channel !== a.channel || _(n.currencies) !== _(j.currencies)) throw t("forbidden");
+				let { product: r, facts: c, identity: u, verifiedAt: d } = n, f = r.offer, p = q(), m = K(u), h = L([r, j.currencies]), g = L(c);
+				if (p < d || c.expiresAt !== null && c.expiresAt <= p || f.from !== null && p < f.from || f.until !== null && p >= f.until) throw t("forbidden");
+				if (f.items.length && !j.inventory) throw t("unavailable");
+				let v = await H(n.accounts.prepareBinding(i, c.channel, c.environment, n.accountToken)), y = await H(j.admission.prepare(Object.freeze({
+					scope: i,
+					product: r,
+					facts: c,
+					at: p
+				})));
+				await e.transactional(async (e) => {
+					let n = await Y(e), r = await Z(e, i), a = await de(e, n), l = a.orders.filter((e) => e.ownerKey === z(i.tenantId, i.ownerId));
+					if (l.length !== W(r.ordersCount)) throw t("invalid_record");
+					if (a.orders.some((e) => e.offerId === f.id && e.offerVersion === f.version && e.channel === c.channel && e.configurationDigest !== h)) throw t("conflict");
+					let d = await Q(e, i, o);
+					if (d?.state === "fulfilled") throw await $(e, d), new oe();
+					if (!d) {
+						if (a.orders.length >= F) throw t("limit_exceeded");
+						await e.insert(D.tableName, {
+							id: o,
+							namespace: M,
+							tenantId: i.tenantId,
+							ownerId: i.ownerId,
+							ownerKey: z(i.tenantId, i.ownerId),
+							offerId: f.id,
+							offerVersion: f.version,
+							channel: c.channel,
+							configurationDigest: h,
+							acceptedQuantity: null,
+							acceptedDay: null,
+							state: "pending",
+							accepted: !1,
+							intentDigest: s,
+							receiptKey: m,
+							snapshot: null,
+							receipt: null,
+							createdAt: new Date(p),
+							fulfilledAt: null
+						}), await e.update(E.tableName, I, { ordersCount: a.orders.length + 1 }), await e.update(k.tableName, z(i.tenantId, i.ownerId), { ordersCount: l.length + 1 });
+					} else if (d.intentDigest !== s || d.receiptKey !== m || d.state !== "pending") throw t("conflict");
+					let _ = (await e.query(P(O).where(N("id", m)).limit(1).descriptor))[0];
+					if (_) {
+						if (_.identity !== u) throw t("invalid_record");
+						if (_.namespace !== M || _.tenantId !== i.tenantId || _.ownerKey !== z(i.tenantId, i.ownerId) || _.orderKey !== o || _.accepted === !0 || _.state === "erased") throw t("already_redeemed");
+						if (_.state !== "pending" || _.accepted !== !1 || _.fulfilledAt !== null) throw t("invalid_record");
+						if (_.factsDigest !== g) throw t("conflict");
+					} else {
+						if (a.receipts.length >= F) throw t("limit_exceeded");
+						await e.insert(O.tableName, {
+							id: m,
+							namespace: M,
+							tenantId: i.tenantId,
+							ownerKey: z(i.tenantId, i.ownerId),
+							orderKey: o,
+							identity: u,
+							factsDigest: g,
+							state: "pending",
+							accepted: !1,
+							createdAt: new Date(p),
+							fulfilledAt: null
+						}), await e.update(E.tableName, I, { receiptsCount: a.receipts.length + 1 });
+					}
+				});
+				let b = [
+					v,
+					y,
+					ie(e, async (e) => {
+						let n = await Y(e);
+						await Z(e, i);
+						let r = await de(e, n), a = await Q(e, i, o);
+						if (!a || a.intentDigest !== s || a.receiptKey !== m || a.ownerId !== i.ownerId) throw t("invalid_record");
+						if (a.state === "fulfilled") throw await $(e, a), new oe();
+						if (a.state !== "pending" || a.accepted !== !1 || c.consumption === "consumed" || c.kind !== "subscription" && c.acknowledgement === "acknowledged") throw t("forbidden");
+						if (await e.updateMany(O.tableName, { accepted: !1 }, { where: ne(N("id", m), N("state", "pending")) }) !== 1) throw t("already_redeemed");
+						let d = (await e.query(P(O).where(N("id", m)).limit(1).descriptor))[0];
+						if (!d || d.identity !== u || d.orderKey !== o || d.namespace !== M || d.tenantId !== i.tenantId || d.ownerKey !== a.ownerKey) throw t("already_redeemed");
+						if (d.factsDigest !== g || a.configurationDigest !== h) throw t("conflict");
+						let p = r.orders.filter((e) => e.accepted === !0 && e.offerId === f.id), _ = 0, v = 0, y = 0;
+						for (let t of p) {
+							t.state === "fulfilled" && await $(e, t);
+							let n = l(t.acceptedQuantity, 1, 1e3);
+							_ += n, t.ownerKey === a.ownerKey && (v += n, t.acceptedDay === Math.floor(x / 864e5) && (y += n));
+						}
+						if (f.limits.global !== null && _ + c.quantity > f.limits.global || f.limits.perPlayer !== null && v + c.quantity > f.limits.perPlayer || f.limits.perDay !== null && y + c.quantity > f.limits.perDay) throw t("limit_exceeded");
+						return null;
+					})
+				];
+				for (let [e, t] of f.currencies.entries()) b.push(await H(j.economy.prepareTransfer(ce, {
+					tenantId: i.tenantId,
+					requestId: R("eik_", o, "transfer", String(e)),
+					currency: t.currency,
+					amount: (BigInt(t.amount) * BigInt(c.quantity)).toString(),
+					from: {
+						kind: "system",
+						id: j.systemAccount
+					},
+					to: {
+						kind: "wallet",
+						ownerKind: "player",
+						ownerId: i.ownerId
+					},
+					reason: "iap.fulfill",
+					ref: {
+						kind: "iap-order",
+						id: o
+					}
+				})));
+				for (let [e, t] of f.items.entries()) b.push(await H(j.inventory.prepareGrant(ce, {
+					tenantId: i.tenantId,
+					owner: {
+						ownerKind: "player",
+						ownerId: i.ownerId
+					},
+					itemId: t.itemId,
+					qty: t.qty * c.quantity,
+					requestId: R("eik_", o, "grant", String(e)),
+					reason: "iap.fulfill",
+					ref: {
+						kind: "iap-order",
+						id: o
+					}
+				})));
+				let x = q();
+				if (x < p || c.expiresAt !== null && c.expiresAt <= x || f.until !== null && x >= f.until) throw t("forbidden");
+				let S = ae(e, b, async (e, n) => {
+					let l = {
+						orderId: o,
+						offerId: f.id,
+						offerVersion: f.version,
+						quantity: c.quantity,
+						at: x,
+						pricePaid: c.paid,
+						transfers: n.slice(3, 3 + f.currencies.length),
+						grants: n.slice(3 + f.currencies.length)
+					};
+					await e.update(O.tableName, m, {
+						state: "fulfilled",
+						accepted: !0,
+						fulfilledAt: new Date(x)
+					}), await e.update(D.tableName, o, {
+						state: "fulfilled",
+						accepted: !0,
+						acceptedQuantity: c.quantity,
+						acceptedDay: Math.floor(x / 864e5),
+						snapshot: {
+							scope: i,
+							requestId: a.requestId,
+							intentDigest: s,
+							identity: u,
+							product: r,
+							currencies: j.currencies,
+							facts: c,
+							verifiedAt: d,
+							at: x
+						},
+						receipt: l,
+						fulfilledAt: new Date(x)
+					});
+					let p = await Q(e, i, o);
+					if (!p) throw t("invalid_record");
+					return $(e, p);
+				});
+				return (await re(e, [S]))[0];
+			} catch (e) {
+				let t = await pe(i, o, s);
+				if (t) return t;
+				throw e;
+			}
+		});
+	}), he = (n, r) => V(() => {
+		let i = J(n), a = h(r), o = G(i.tenantId, i.ownerId, a.requestId), s = L([
+			M,
+			i,
+			a.channel,
+			a.offerId,
+			a.offerVersion,
+			a.requestId,
+			a.receiptDigest
+		]);
+		return B(() => e.transactional(async (e) => {
+			let n = await X(e, i), r = await Q(e, i, o);
+			if (r && !n) throw t("invalid_record");
+			if (!r) return Object.freeze({
+				requestId: a.requestId,
+				state: "not-observed"
+			});
+			if (r.intentDigest !== s) throw t("conflict");
+			if (r.state === "fulfilled") {
+				let t = await $(e, r);
+				if (!j.refundDisposition) return Object.freeze({
+					requestId: a.requestId,
+					state: "fulfilled",
+					receipt: t
+				});
+				let n = await fe(e, r, i), o = await j.refundDisposition.read(e, n);
+				return u({
+					requestId: a.requestId,
+					state: o?.state === "revoked" ? "refunded" : o?.state === "partially-refunded" ? "partially-refunded" : "fulfilled",
+					receipt: t,
+					...o === null ? {} : { refund: o }
+				});
+			}
+			if (r.state !== "pending" || r.ownerId !== i.ownerId || r.accepted !== !1 || r.receipt !== null || r.snapshot !== null || r.fulfilledAt !== null) throw t("invalid_record");
+			return Object.freeze({
+				requestId: a.requestId,
+				state: "pending"
+			});
+		}));
+	}), ge = (e) => {
+		let n = i(e, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (n.kind !== "user" && n.kind !== "guest") throw t("invalid_input");
+		return Object.freeze({
+			tenantId: a(n.tenantId),
+			ownerId: a(n.subjectId)
+		});
+	}, _e = async (e, n, r, i = !1) => {
+		let a = await ue(e, D, ne(N("namespace", M), N("tenantId", n.tenantId), N("ownerKey", z(n.tenantId, n.ownerId))));
+		if (a.length !== (r ? W(r.ordersCount) : 0)) throw t("invalid_record");
+		for (let n of a) if (n.state === "fulfilled") i || await $(e, n);
+		else if (n.state === "pending" ? n.accepted !== !1 || n.receipt !== null || n.snapshot !== null || n.fulfilledAt !== null : n.state !== "erased" || n.ownerId !== null || n.intentDigest !== null || n.receipt !== null || n.snapshot !== null || typeof n.accepted != "boolean" || n.accepted === !0 && n.fulfilledAt === null || n.accepted === !1 && n.fulfilledAt !== null) throw t("invalid_record");
+		return a;
+	};
+	return Object.freeze({
+		redeem: me,
+		receipt: he,
+		subscriptionPeriods: (n) => V(() => {
+			let r = J(n);
+			return B(() => e.transactional(async (e) => {
+				let n = await X(e, r), i = await _e(e, r, n), a = [];
+				for (let n of i) {
+					if (n.state !== "fulfilled") continue;
+					let i = await fe(e, n, r);
+					if (i.facts.kind !== "subscription") continue;
+					if (!j.refundDisposition) throw t("unavailable");
+					let o = await j.refundDisposition.read(e, i);
+					a.push(f({
+						orderId: i.orderId,
+						offerId: i.receipt.offerId,
+						offerVersion: i.receipt.offerVersion,
+						channel: i.facts.channel,
+						startsAt: i.facts.purchasedAt,
+						expiresAt: i.facts.expiresAt,
+						refund: o
+					}));
+				}
+				return Object.freeze(a.sort((e, t) => e.startsAt - t.startsAt || e.orderId.localeCompare(t.orderId)));
+			}));
+		}),
+		subscriptionOriginals: (t, n) => V(() => {
+			let r = J(t), i = p(n);
+			return B(() => e.transactional(async (e) => {
+				let t = await X(e, r), n = await _e(e, r, t), a = [];
+				for (let t of n) {
+					if (t.state !== "fulfilled") continue;
+					let n = await fe(e, t, r);
+					n.facts.kind === "subscription" && n.facts.channel === i && n.facts.originalTransactionId !== null && a.push({
+						id: n.facts.originalTransactionId,
+						at: n.facts.purchasedAt
+					});
+				}
+				return Object.freeze([...new Set(a.sort((e, t) => t.at - e.at).map((e) => e.id))]);
+			}));
+		}),
+		exportSubject: (t) => V(() => {
+			let n = ge(t);
+			return B(() => e.transactional(async (e) => {
+				let t = await X(e, n, !0), r = await _e(e, n, t);
+				return t?.erased === !0 ? { orders: [] } : { orders: r.filter((e) => e.state !== "erased").map((e) => ({
+					orderId: e.id,
+					state: e.state,
+					receipt: e.receipt
+				})) };
+			}));
+		}),
+		eraseSubject: (n) => V(() => {
+			let r = ge(n);
+			return B(async () => {
+				await le(r), await e.transactional(async (e) => {
+					let n = await Y(e), i = await Z(e, r, !0);
+					await de(e, n);
+					let a = await _e(e, r, i, !0);
+					for (let n of a) {
+						if (n.receiptKey !== null) {
+							let i = (await e.query(P(O).where(N("id", String(n.receiptKey))).limit(1).descriptor))[0];
+							if (!i || i.namespace !== M || i.tenantId !== r.tenantId || i.ownerKey !== n.ownerKey || i.orderKey !== n.id || i.accepted !== n.accepted) throw t("invalid_record");
+							await e.update(O.tableName, String(i.id), { state: "erased" });
+						}
+						await e.update(D.tableName, String(n.id), {
+							ownerId: null,
+							state: "erased",
+							intentDigest: null,
+							snapshot: null,
+							receipt: null
+						});
+					}
+					await e.update(k.tableName, z(r.tenantId, r.ownerId), {
+						ownerId: null,
+						erased: !0
+					});
+				});
+			});
+		}),
+		prepareCompletion: (n, r) => V(() => {
+			let o = J(n), l = m(r), u = G(o.tenantId, o.ownerId, l.requestId), d = L([
+				M,
+				o,
+				l.channel,
+				l.offerId,
+				l.offerVersion,
+				l.requestId,
+				L(l.receipt)
+			]), f = () => B(() => e.transactional(async (e) => {
+				let n = await X(e, o), r = await Q(e, o, u);
+				if (!r) throw t("not_found");
+				if (!n) throw t("invalid_record");
+				if (r.intentDigest !== d) throw t("conflict");
+				if (r.state !== "fulfilled" || r.accepted !== !0) throw t("forbidden");
+				await $(e, r);
+				let f = i(r.snapshot, [
+					"scope",
+					"requestId",
+					"intentDigest",
+					"identity",
+					"product",
+					"currencies",
+					"facts",
+					"verifiedAt",
+					"at"
+				], "invalid_record"), m = i(f.product, [
+					"offer",
+					"channel",
+					"kind",
+					"storeProductId"
+				], "invalid_record"), h = s(f.currencies), g = Object.freeze({
+					offer: c(m.offer, h, !0, { grantless: m.kind === "subscription" }),
+					channel: p(m.channel),
+					kind: m.kind,
+					storeProductId: a(m.storeProductId)
+				});
+				return Object.freeze({
+					orderId: u,
+					scope: o,
+					intent: l,
+					product: g,
+					currencies: h,
+					facts: w(f.facts)
+				});
+			}));
+			return f().pipe(A.map(() => ee(u, f)));
+		}),
+		prepareNotification: (n, r) => V(() => {
+			let o = x(n), l = y(r), u = l.notice;
+			if (u.channel !== o.channel || u.applicationId !== o.applicationId || u.environment !== null && u.environment !== o.environment) throw t("forbidden");
+			if (u.kind === "test" || u.transactionId === null) throw t("unavailable");
+			let d = L([
+				o.channel,
+				o.environment,
+				o.applicationId,
+				u.transactionId
+			]), f = K(d), m, h = () => b(r).pipe(A.flatMap(() => B(() => e.transactional(async (e) => {
+				let n = (await e.query(P(O).where(N("id", f)).limit(1).descriptor))[0];
+				if (!n) throw t("not_found");
+				if (n.identity !== d) throw t("invalid_record");
+				if (n.namespace !== M) throw t("forbidden");
+				if (n.state === "erased") throw t("erased");
+				if (n.state !== "fulfilled" || n.accepted !== !0) throw t("forbidden");
+				let h = (await e.query(P(D).where(N("id", String(n.orderKey))).limit(1).descriptor))[0];
+				if (!h) throw t("invalid_record");
+				if (h.state === "erased") throw t("erased");
+				let g = Object.freeze({
+					tenantId: a(h.tenantId),
+					ownerId: a(h.ownerId)
+				});
+				if (h.namespace !== M || n.tenantId !== g.tenantId || n.ownerKey !== z(g.tenantId, g.ownerId) || h.ownerKey !== n.ownerKey || h.receiptKey !== f || !await X(e, g)) throw t("invalid_record");
+				if (m && (h.id !== m.orderId || g.tenantId !== m.tenantId || g.ownerId !== m.ownerId)) throw t("conflict");
+				let _ = await $(e, h), v = i(h.snapshot, [
+					"scope",
+					"requestId",
+					"intentDigest",
+					"identity",
+					"product",
+					"currencies",
+					"facts",
+					"verifiedAt",
+					"at"
+				], "invalid_record"), b = i(v.product, [
+					"offer",
+					"channel",
+					"kind",
+					"storeProductId"
+				], "invalid_record"), x = s(v.currencies), S = w(v.facts);
+				if (S.channel !== o.channel || S.environment !== o.environment || S.applicationId !== o.applicationId || S.transactionId !== u.transactionId || u.originalTransactionId !== null && u.originalTransactionId !== S.originalTransactionId || u.storeProductId !== null && u.storeProductId !== S.storeProductId || u.kind === "subscription" && S.kind !== "subscription" || u.kind === "one-time" && S.kind === "subscription") throw t("forbidden");
+				let C = Object.freeze({
+					offer: c(b.offer, x, !0, { grantless: b.kind === "subscription" }),
+					channel: p(b.channel),
+					kind: b.kind,
+					storeProductId: a(b.storeProductId)
+				});
+				return Object.freeze({
+					orderId: _.orderId,
+					notice: u,
+					notification: r,
+					receipt: _,
+					scope: g,
+					product: C,
+					currencies: x,
+					facts: S,
+					fingerprint: l.fingerprint,
+					material: y(r).material
+				});
+			}))));
+			return h().pipe(A.map((e) => (m = Object.freeze({
+				orderId: e.orderId,
+				tenantId: e.scope.tenantId,
+				ownerId: e.scope.ownerId
+			}), S(e.orderId, u.noticeId, h))));
+		}),
+		prepareCurrentState: (n) => C(n).pipe(A.flatMap((n) => {
+			let { original: r, state: a } = n;
+			return A.gen(function* () {
+				let o = yield* n.prepareBinding(), s = yield* v(r.notification), c = ie(e, async (e) => {
+					q(), n.assertFresh(), await Y(e), await Z(e, r.scope);
+					let a = await Q(e, r.scope, r.orderId);
+					if (!a) throw t("not_found");
+					let o = await $(e, a), s = i(a.snapshot, [
+						"scope",
+						"requestId",
+						"intentDigest",
+						"identity",
+						"product",
+						"currencies",
+						"facts",
+						"verifiedAt",
+						"at"
+					], "invalid_record");
+					if (_(o) !== _(r.receipt) || _(s.facts) !== _(r.facts) || _(s.product) !== _(r.product) || _(s.currencies) !== _(r.currencies)) throw t("conflict");
+					return null;
+				});
+				return ae(e, [
+					c,
+					o,
+					...s
+				], async () => (q(), n.assertFresh(), a));
+			});
+		}), A.catchDefect(() => A.fail(t("unavailable"))))
+	});
+};
+export { G as dataStoreIap, se as resolveIapStoreOptions };