@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/iap.js

@@ -0,0 +1,304 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataList as n, dataObject as r, identifier as i } from "./capture.js";
+import { nonNegativeAmount as a, positiveAmount as o } from "./amount.js";
+import { defineShopOffer as s, shopInteger as c } from "./shop.js";
+import { Context as l } from "effect";
+//#region src/iap.ts
+var u = (t, a, o = !1) => {
+	if (typeof o != "boolean") throw e("invalid_input");
+	let c = n(t, 4096);
+	if (!o && c.length !== 0) throw e("real_money_disabled");
+	let l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set();
+	return Object.freeze(c.map((t) => {
+		let n = r(t, [
+			"offer",
+			"channel",
+			"kind"
+		]), c = d(n.channel), p = f(n.kind), m = s(n.offer, a, o, { grantless: p === "subscription" }), h = (m.price.kind === "real" ? m.price : m.price.kind === "mixed" ? m.price.real : null)?.storeProductIds[c];
+		if (h === void 0) throw e("invalid_price");
+		let g = i(h), _ = `${c}:${g}`, v = `${c}:${m.id}`;
+		if (l.has(_) || u.has(v)) throw e("conflict");
+		if (p !== "consumable" && m.maxQuantity !== 1 || p === "non-consumable" && m.limits.perPlayer !== 1) throw e("invalid_input");
+		return l.add(_), u.add(v), Object.freeze({
+			offer: m,
+			channel: c,
+			kind: p,
+			storeProductId: g
+		});
+	}));
+}, d = (t) => {
+	if (t !== "ios" && t !== "android" && t !== "steam" && t !== "web") throw e("invalid_input");
+	return t;
+}, f = (t) => {
+	if (t !== "consumable" && t !== "non-consumable" && t !== "subscription") throw e("invalid_input");
+	return t;
+}, p = (t) => {
+	if (t !== "sandbox" && t !== "production") throw e("invalid_input");
+	return t;
+}, m = (t) => {
+	let n = r(t, [
+		"channel",
+		"offerId",
+		"offerVersion",
+		"requestId",
+		"receipt"
+	]);
+	if (typeof n.receipt != "string" || n.receipt.length === 0 || n.receipt.length > 65536 || /[\u0000-\u0020\u007f]/.test(n.receipt)) throw e("invalid_input");
+	return Object.freeze({
+		channel: d(n.channel),
+		offerId: i(n.offerId),
+		offerVersion: i(n.offerVersion),
+		requestId: i(n.requestId),
+		receipt: n.receipt
+	});
+}, h = (t) => {
+	let n = r(t, [
+		"channel",
+		"offerId",
+		"offerVersion",
+		"requestId",
+		"receiptDigest"
+	]);
+	if (typeof n.receiptDigest != "string" || !/^[a-f0-9]{64}$/.test(n.receiptDigest)) throw e("invalid_input");
+	return Object.freeze({
+		channel: d(n.channel),
+		offerId: i(n.offerId),
+		offerVersion: i(n.offerVersion),
+		requestId: i(n.requestId),
+		receiptDigest: n.receiptDigest
+	});
+}, g = async (e) => {
+	let t = m(e), n = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(t.receipt))), r = Array.from(new Uint8Array(n), (e) => e.toString(16).padStart(2, "0")).join("");
+	return h({
+		channel: t.channel,
+		offerId: t.offerId,
+		offerVersion: t.offerVersion,
+		requestId: t.requestId,
+		receiptDigest: r
+	});
+}, _ = (e) => {
+	let t = r(e, ["tenantId", "ownerId"]);
+	return Object.freeze({
+		tenantId: i(t.tenantId),
+		ownerId: i(t.ownerId)
+	});
+}, v = (t) => {
+	try {
+		if (t === null) return null;
+		let n = r(t, [
+			"currency",
+			"units",
+			"scale"
+		], "invalid_record");
+		if (typeof n.currency != "string" || !/^[A-Z]{3}$/.test(n.currency) || typeof n.units != "string" || a(n.units).toString() !== n.units) throw e("invalid_record");
+		return Object.freeze({
+			currency: n.currency,
+			units: n.units,
+			scale: c(n.scale, 0, 9)
+		});
+	} catch {
+		throw e("invalid_record");
+	}
+}, y = (t) => {
+	try {
+		let a = r(t, [
+			"orderId",
+			"offerId",
+			"offerVersion",
+			"quantity",
+			"at",
+			"pricePaid",
+			"transfers",
+			"grants"
+		], "invalid_record"), s = E(a.at), l = Object.freeze(n(a.transfers, 16, "invalid_record").map((t) => {
+			let n = r(t, [
+				"txId",
+				"currency",
+				"amount",
+				"at"
+			], "invalid_record");
+			if (typeof n.amount != "string" || o(n.amount).toString() !== n.amount) throw e("invalid_record");
+			return Object.freeze({
+				txId: i(n.txId, "invalid_record"),
+				currency: i(n.currency, "invalid_record"),
+				amount: n.amount,
+				at: c(n.at, 0, s)
+			});
+		})), u = Object.freeze(n(a.grants, 16, "invalid_record").map((t) => {
+			let a = r(t, [
+				"operationId",
+				"kind",
+				"changes",
+				"at"
+			], "invalid_record");
+			if (a.kind !== "grant") throw e("invalid_record");
+			let o = Object.freeze(n(a.changes, 1e5, "invalid_record").map((e) => {
+				let t = r(e, ["instanceId", "delta"], "invalid_record");
+				return Object.freeze({
+					instanceId: i(t.instanceId, "invalid_record"),
+					delta: c(t.delta, 1, 1e6)
+				});
+			}));
+			if (o.length === 0 || new Set(o.map((e) => e.instanceId)).size !== o.length) throw e("invalid_record");
+			return Object.freeze({
+				operationId: i(a.operationId, "invalid_record"),
+				kind: "grant",
+				changes: o,
+				at: c(a.at, 0, s)
+			});
+		}));
+		if (new Set(l.map((e) => e.txId)).size !== l.length || new Set(u.map((e) => e.operationId)).size !== u.length) throw e("invalid_record");
+		return Object.freeze({
+			orderId: i(a.orderId, "invalid_record"),
+			offerId: i(a.offerId, "invalid_record"),
+			offerVersion: i(a.offerVersion, "invalid_record"),
+			quantity: c(a.quantity, 1, 1e3),
+			at: s,
+			pricePaid: v(a.pricePaid),
+			transfers: l,
+			grants: u
+		});
+	} catch {
+		throw e("invalid_record");
+	}
+}, b = (t) => {
+	try {
+		let n = r(t, [
+			"orderId",
+			"channel",
+			"operation",
+			"observedAt"
+		], "invalid_record");
+		if (n.operation !== "acknowledge" && n.operation !== "consume" && n.operation !== "finalize" && n.operation !== "finish") throw e("invalid_record");
+		return Object.freeze({
+			orderId: i(n.orderId, "invalid_record"),
+			channel: d(n.channel),
+			operation: n.operation,
+			observedAt: E(n.observedAt)
+		});
+	} catch {
+		throw e("invalid_record");
+	}
+}, x = (t) => {
+	try {
+		let n = r(t, [
+			"sequence",
+			"state",
+			"refundNumerator",
+			"refundDenominator",
+			"observedAt"
+		], "invalid_record"), i = c(n.refundDenominator, 1, 1e5), a = c(n.refundNumerator, 0, i), o = a === 0 ? "active" : a === i ? "revoked" : "partially-refunded";
+		if (n.state !== o) throw e("invalid_record");
+		return Object.freeze({
+			sequence: c(n.sequence, 1, 1e5),
+			state: o,
+			refundNumerator: a,
+			refundDenominator: i,
+			observedAt: E(n.observedAt)
+		});
+	} catch {
+		throw e("invalid_record");
+	}
+}, S = (t) => {
+	try {
+		let n = r(t, [
+			"requestId",
+			"state",
+			"receipt",
+			"refund"
+		], "invalid_record"), a = i(n.requestId, "invalid_record");
+		if (n.state === "not-observed" || n.state === "pending") {
+			if (Object.hasOwn(n, "receipt") || Object.hasOwn(n, "refund")) throw e("invalid_record");
+			return Object.freeze({
+				requestId: a,
+				state: n.state
+			});
+		}
+		if (n.state !== "fulfilled" && n.state !== "partially-refunded" && n.state !== "refunded") throw e("invalid_record");
+		let o = y(n.receipt), s = Object.hasOwn(n, "refund") ? x(n.refund) : void 0;
+		if (s && s.observedAt < o.at || (n.state === "fulfilled" ? s !== void 0 && s.state !== "active" : !s || s.state !== (n.state === "refunded" ? "revoked" : "partially-refunded"))) throw e("invalid_record");
+		if (n.state === "fulfilled") return Object.freeze({
+			requestId: a,
+			state: "fulfilled",
+			receipt: o,
+			...s ? { refund: s } : {}
+		});
+		if (!s) throw e("invalid_record");
+		return Object.freeze({
+			requestId: a,
+			state: n.state,
+			receipt: o,
+			refund: s
+		});
+	} catch {
+		throw e("invalid_record");
+	}
+}, C = (t) => {
+	try {
+		let n = r(t, [
+			"orderId",
+			"offerId",
+			"offerVersion",
+			"channel",
+			"startsAt",
+			"expiresAt",
+			"refund"
+		], "invalid_record"), a = E(n.startsAt), o = E(n.expiresAt), s = n.refund === null ? null : x(n.refund);
+		if (o <= a || s && s.observedAt < a) throw e("invalid_record");
+		return Object.freeze({
+			orderId: i(n.orderId, "invalid_record"),
+			offerId: i(n.offerId, "invalid_record"),
+			offerVersion: i(n.offerVersion, "invalid_record"),
+			channel: d(n.channel),
+			startsAt: a,
+			expiresAt: o,
+			refund: s
+		});
+	} catch {
+		throw e("invalid_record");
+	}
+}, w = class extends l.Service()("@voltro/IapPort") {}, T = (e) => t(e, [
+	"redeem",
+	"receipt",
+	"exportSubject",
+	"eraseSubject"
+]), E = (e) => c(e, 0, 864e13), D = (e) => [[
+	"channel",
+	"storeProductId",
+	"offerId",
+	"offerVersion",
+	"kind",
+	"titleKey"
+], ...n(e, 4096).map((e) => {
+	let t = r(e, [
+		"offer",
+		"channel",
+		"kind",
+		"storeProductId"
+	]), n = r(t.offer, [
+		"id",
+		"version",
+		"titleKey",
+		"price",
+		"items",
+		"currencies",
+		"from",
+		"until",
+		"segment",
+		"flag",
+		"countries",
+		"limits",
+		"oneTime",
+		"maxQuantity"
+	]);
+	return [
+		d(t.channel),
+		i(t.storeProductId),
+		i(n.id),
+		i(n.version),
+		f(t.kind),
+		i(n.titleKey)
+	];
+}).sort((e, t) => e.join("\0") < t.join("\0") ? -1 : +(e.join("\0") > t.join("\0")))].map((e) => e.map((e) => `"${e.replaceAll("\"", "\"\"")}"`).join(",")).join("\r\n") + "\r\n";
+//#endregion
+export { w as IapPort, b as captureIapCompletionReceipt, S as captureIapObservation, y as captureIapOrderReceipt, v as captureIapPaidAmount, x as captureIapRefundDisposition, _ as captureIapScope, T as captureIapService, C as captureIapSubscriptionPeriod, g as createIapReceiptReference, u as defineIapCatalog, d as iapChannel, p as iapEnvironment, f as iapProductKind, D as iapProductsCsv, m as iapReceiptIntent, h as iapReceiptReference, E as iapTimestamp };

package/dist/iap.testFixtures.js

@@ -0,0 +1,145 @@
+import { economyError as e } from "./errors.js";
+import { defineCurrency as t } from "./currency.js";
+import { defineIapCatalog as n } from "./iap.js";
+import { Effect as r } from "effect";
+import { randomBytes as i, randomUUID as a } from "node:crypto";
+//#region src/iap.testFixtures.ts
+var o = () => {
+	let o = Date.UTC(2026, 0, 1), s = a(), c = i(32).toString("base64url"), l = [t({
+		id: "test.gems",
+		kind: "hard",
+		cap: "10000",
+		premium: !0
+	})], u = {
+		channel: "ios",
+		kind: "consumable",
+		offer: {
+			id: "test.pack",
+			version: "1",
+			titleKey: "test.pack.title",
+			price: {
+				kind: "real",
+				prices: { EUR: 999 },
+				storeProductIds: {
+					ios: "test.pack.ios",
+					android: "test.pack.android"
+				}
+			},
+			currencies: [{
+				currency: "test.gems",
+				amount: "10"
+			}],
+			maxQuantity: 3
+		}
+	}, d = {
+		tenantId: "test.tenant",
+		ownerId: "test.player"
+	}, f = {
+		channel: "ios",
+		offerId: "test.pack",
+		offerVersion: "1",
+		requestId: "test.request",
+		receipt: c
+	}, p = {
+		realMoney: !0,
+		channel: "ios",
+		environment: "sandbox",
+		applicationId: "test.application",
+		products: [u],
+		currencies: l,
+		accounts: {
+			read: () => r.succeed(s),
+			prepareBinding: () => r.fail(e("unavailable"))
+		},
+		now: () => o
+	}, m = {
+		realMoney: p.realMoney,
+		environment: p.environment,
+		applicationId: p.applicationId,
+		products: p.products,
+		currencies: p.currencies,
+		accounts: p.accounts,
+		now: () => o
+	}, h = {
+		scope: d,
+		intent: f,
+		product: n([u], l, !0)[0],
+		accountToken: s,
+		at: o
+	}, g = {
+		bundleId: "test.application",
+		environment: "Sandbox",
+		appAccountToken: s,
+		inAppOwnershipType: "PURCHASED",
+		type: "Consumable",
+		transactionId: "100001",
+		originalTransactionId: "100001",
+		productId: "test.pack.ios",
+		quantity: 2,
+		purchaseDate: o - 1e3,
+		signedDate: o,
+		currency: "EUR",
+		price: 9990
+	}, _ = {
+		channel: "ios",
+		environment: "sandbox",
+		applicationId: "test.application",
+		transactionId: "100001",
+		originalTransactionId: "100001",
+		storeProductId: "test.pack.ios",
+		kind: "consumable",
+		quantity: 2,
+		purchasedAt: o - 1e3,
+		expiresAt: null,
+		paid: {
+			currency: "EUR",
+			units: "9990",
+			scale: 3
+		},
+		acknowledgement: "none",
+		consumption: "none"
+	}, v = {
+		...u,
+		channel: "android"
+	};
+	return {
+		at: o,
+		accountToken: s,
+		receipt: c,
+		currencies: l,
+		definition: u,
+		scope: d,
+		intent: f,
+		options: p,
+		providerOptions: m,
+		context: h,
+		apple: g,
+		facts: _,
+		androidDefinition: v,
+		googleContext: {
+			...h,
+			intent: {
+				...f,
+				channel: "android"
+			},
+			product: n([v], l, !0)[0]
+		},
+		google: {
+			purchaseStateContext: { purchaseState: "PURCHASED" },
+			testPurchaseContext: { fopType: "TEST" },
+			obfuscatedExternalAccountId: s,
+			purchaseCompletionTime: (/* @__PURE__ */ new Date(o - 1e3)).toISOString(),
+			acknowledgementState: "ACKNOWLEDGEMENT_STATE_PENDING",
+			productLineItem: [{
+				productId: "test.pack.android",
+				productOfferDetails: {
+					quantity: 2,
+					refundableQuantity: 2,
+					consumptionState: "CONSUMPTION_STATE_YET_TO_BE_CONSUMED"
+				}
+			}]
+		}
+	};
+};
+//#endregion
+export { o as iapTestFixture };

package/dist/iapAccountTables.entity.js

@@ -0,0 +1,40 @@
+import { boolean as e, id as t, integer as n, table as r, text as i } from "@voltro/database";
+//#region src/iapAccountTables.entity.ts
+var a = () => i().maxLength(120).serverOnly(), o = () => i().maxLength(16).oneOf([
+	"ios",
+	"android",
+	"steam",
+	"web"
+]).serverOnly(), s = () => i().maxLength(16).oneOf(["sandbox", "production"]).serverOnly(), c = r("_voltro_eco_iap_accounts", {
+	id: t({ prefix: "eia" }),
+	applicationId: a(),
+	channel: o(),
+	environment: s(),
+	tenantId: i().maxLength(120).externalId().sensitive("pii"),
+	ownerId: i().maxLength(120).nullable().externalId().sensitive("pii"),
+	token: i().maxLength(128).nullable().serverOnly().sensitive("pii"),
+	tokenKey: i().maxLength(64).nullable().serverOnly(),
+	erased: e().serverOnly(),
+	admission: n().serverOnly()
+}).index("voltro_eco_iap_accounts_owner_idx", [
+	"applicationId",
+	"channel",
+	"environment",
+	"tenantId",
+	"ownerId"
+]), l = r("_voltro_eco_iap_account_tokens", {
+	id: t({ prefix: "eit" }),
+	applicationId: a(),
+	channel: o(),
+	environment: s(),
+	tenantId: i().maxLength(120).externalId().sensitive("pii"),
+	accountKey: i().maxLength(64).serverOnly(),
+	erased: e().serverOnly()
+}).index("voltro_eco_iap_account_tokens_scope_idx", [
+	"applicationId",
+	"channel",
+	"environment",
+	"tenantId"
+]), u = [c, l];
+//#endregion
+export { u as iapAccountTables, l as iapAccountTokensTable, c as iapAccountsTable };

package/dist/iapAccounts.server.js

@@ -0,0 +1,201 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { captureBoundMethods as n, dataObject as r, identifier as i } from "./capture.js";
+import { captureIapScope as a, iapChannel as o, iapEnvironment as s } from "./iap.js";
+import { iapAccountTokensTable as c, iapAccountsTable as l } from "./iapAccountTables.entity.js";
+import { Context as u, Effect as d } from "effect";
+import { createHash as f, randomUUID as p } from "node:crypto";
+import { eq as m, queryFor as h } from "@voltro/database";
+import { prepareSqlMutation as g } from "@voltro/database/sql";
+//#region src/iapAccounts.server.ts
+var _ = class extends u.Service()("@voltro/IapAccountsPort") {}, v = (e) => n(e, [
+	"read",
+	"observe",
+	"prepareBinding",
+	"exportSubject",
+	"eraseSubject"
+]), y = (e, t) => e + f("sha256").update(JSON.stringify(t)).digest("hex").slice(0, 56), b = (e) => {
+	if (typeof e != "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(e)) throw t("invalid_input");
+	return e.toLowerCase();
+}, x = (n) => n instanceof e ? n : t("unavailable"), S = (e) => {
+	try {
+		return e();
+	} catch (e) {
+		return d.fail(x(e));
+	}
+}, C = (e, n) => {
+	let u = r(n, [
+		"realMoney",
+		"applicationId",
+		"channel",
+		"environment"
+	]);
+	if (u.realMoney !== !0) throw t(u.realMoney === !1 ? "real_money_disabled" : "invalid_input");
+	let f = i(u.applicationId), _ = o(u.channel), v = s(u.environment), C = (e) => y("eia_", [
+		f,
+		_,
+		v,
+		e.tenantId,
+		e.ownerId
+	]), w = (e) => y("eit_", [
+		f,
+		_,
+		v,
+		e
+	]), T = (e, n, r) => {
+		let i = a(e);
+		if (o(n) !== _ || s(r) !== v) throw t("forbidden");
+		return i;
+	}, E = (t) => e.insertIgnore(l.tableName, {
+		id: C(t),
+		applicationId: f,
+		channel: _,
+		environment: v,
+		tenantId: t.tenantId,
+		ownerId: t.ownerId,
+		token: null,
+		tokenKey: null,
+		erased: !1,
+		admission: 0
+	}, { conflictColumns: ["id"] }), D = async (e, n, r = !1) => {
+		let i = (await e.query(h(l).where(m("id", C(n))).limit(1).descriptor))[0];
+		if (!i) return;
+		if (i.applicationId !== f || i.channel !== _ || i.environment !== v || i.tenantId !== n.tenantId || i.admission !== 0 || i.erased !== !0 && i.erased !== !1 || (i.erased ? i.ownerId !== null || i.token !== null : i.ownerId !== n.ownerId)) throw t("invalid_record");
+		if (i.erased && !r) throw t("erased");
+		if (i.tokenKey === null) {
+			if (i.token !== null) throw t("invalid_record");
+			return i;
+		}
+		if (typeof i.tokenKey != "string" || !/^eit_[a-f0-9]{56}$/.test(i.tokenKey) || !i.erased && w(b(i.token)) !== i.tokenKey) throw t("invalid_record");
+		let a = (await e.query(h(c).where(m("id", i.tokenKey)).limit(1).descriptor))[0];
+		if (!a || a.applicationId !== f || a.channel !== _ || a.environment !== v || a.tenantId !== n.tenantId || a.accountKey !== i.id || a.erased !== i.erased) throw t("invalid_record");
+		return i;
+	}, O = async (e, n, r = !1) => {
+		if (await e.updateMany(l.tableName, { admission: 0 }, { where: m("id", C(n)) }) !== 1) throw t("unavailable");
+		let i = await D(e, n, r);
+		if (!i) throw t("invalid_record");
+		return i;
+	}, k = (n, r, i) => S(() => {
+		let a = T(n, r, i);
+		return d.tryPromise({
+			try: async () => {
+				await E(a);
+				let n = p(), r = w(n);
+				return e.transactional(async (e) => {
+					let i = await O(e, a);
+					if (i.token !== null) return b(i.token);
+					if (i.tokenKey !== null) throw t("invalid_record");
+					if ((await e.query(h(c).where(m("id", r)).limit(1).descriptor))[0]) throw t("conflict");
+					return await e.insert(c.tableName, {
+						id: r,
+						applicationId: f,
+						channel: _,
+						environment: v,
+						tenantId: a.tenantId,
+						accountKey: i.id,
+						erased: !1
+					}), await e.update(l.tableName, String(i.id), {
+						token: n,
+						tokenKey: r
+					}), n;
+				});
+			},
+			catch: x
+		});
+	}), A = (n, r, i) => S(() => {
+		let a = T(n, r, i);
+		return d.tryPromise({
+			try: () => e.transactional(async (e) => {
+				let n = await D(e, a);
+				if (!n) throw t("not_found");
+				if (n.token === null || n.tokenKey === null) throw t("forbidden");
+				return b(n.token);
+			}),
+			catch: x
+		});
+	}), j = (n, r, i, a) => S(() => {
+		let o = T(n, r, i), s = b(a);
+		return d.succeed(g(e, async (e) => {
+			let n = await O(e, o);
+			if (n.token !== s || n.tokenKey !== w(s)) throw t("forbidden");
+			return null;
+		}));
+	}), M = (e) => {
+		let n = r(e, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (n.kind !== "user" && n.kind !== "guest") throw t("invalid_input");
+		return Object.freeze({
+			tenantId: i(n.tenantId),
+			ownerId: i(n.subjectId)
+		});
+	};
+	return Object.freeze({
+		read: k,
+		observe: A,
+		prepareBinding: j,
+		exportSubject: (t) => S(() => {
+			let n = M(t);
+			return d.tryPromise({
+				try: () => e.transactional(async (e) => {
+					let t = await D(e, n, !0);
+					return { bindings: !t || t.erased ? [] : [{
+						applicationId: f,
+						channel: _,
+						environment: v,
+						token: t.token
+					}] };
+				}),
+				catch: x
+			});
+		}),
+		eraseSubject: (t) => S(() => {
+			let n = M(t);
+			return d.tryPromise({
+				try: async () => {
+					await E(n), await e.transactional(async (e) => {
+						let t = await O(e, n, !0);
+						t.tokenKey !== null && await e.update(c.tableName, String(t.tokenKey), { erased: !0 }), await e.update(l.tableName, String(t.id), {
+							ownerId: null,
+							token: null,
+							erased: !0
+						});
+					});
+				},
+				catch: x
+			});
+		})
+	});
+}, w = (e, n) => {
+	let a = r(n, [
+		"realMoney",
+		"applicationId",
+		"channel",
+		"environment"
+	]);
+	if (a.realMoney !== !0) throw t(a.realMoney === !1 ? "real_money_disabled" : "invalid_input");
+	let u = i(a.applicationId), f = o(a.channel), p = s(a.environment);
+	return Object.freeze({ owner: (t) => S(() => {
+		let n = b(t), r = y("eit_", [
+			u,
+			f,
+			p,
+			n
+		]);
+		return d.tryPromise({
+			try: () => e.transactional(async (e) => {
+				let t = (await e.query(h(c).where(m("id", r)).limit(1).descriptor))[0];
+				if (!t || t.erased !== !1 || t.applicationId !== u || t.channel !== f || t.environment !== p) return null;
+				let a = (await e.query(h(l).where(m("id", String(t.accountKey))).limit(1).descriptor))[0];
+				return !a || a.erased !== !1 || a.token !== n || a.tokenKey !== r || a.tenantId !== t.tenantId || typeof a.ownerId != "string" ? null : Object.freeze({
+					tenantId: i(a.tenantId),
+					ownerId: i(a.ownerId)
+				});
+			}),
+			catch: x
+		});
+	}) });
+};
+//#endregion
+export { _ as IapAccountsPort, v as captureIapAccountBindingService, w as dataStoreIapAccountOwners, C as dataStoreIapAccounts };