@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/containerStore.server.js

@@ -0,0 +1,688 @@
+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 { captureCurrencies as o } from "./currency.js";
+import { defaultPriceResolver as s, priceResolverContext as c, resolvePrice as l } from "./price.js";
+import { captureShopOrderReceipt as u, shopInteger as d, shopPayment as f } from "./shop.js";
+import { captureContainerIntent as p, defaultContainerEligibility as m, defaultContainerProbability as h, defaultContainerRoll as g, defineContainer as _, discloseContainer as v, resolveContainerDistribution as y, resolveContainerEligibility as b, resolveContainerRoll as x } from "./containers.js";
+import { cryptoContainerRandom as S } from "./containers.server.js";
+import { containerDefinitionsTable as C, containerOpeningsTable as w, containerSubjectsTable as T, containerTenantsTable as E } from "./containerTables.entity.js";
+import { Effect as D, Result as O } from "effect";
+import { systemSubject as k } from "@voltro/protocol";
+import { createHash as A } from "node:crypto";
+import { and as ee, eq as j, queryFor as M } from "@voltro/database";
+import { executeSqlMutations as te, prepareSqlMutation as ne, prepareSqlMutationGroup as re } from "@voltro/database/sql";
+import { InventoryError as N } from "@voltro/plugin-inventory/errors";
+//#region src/containerStore.server.ts
+var P = (e) => A("sha256").update(JSON.stringify(e)).digest("hex"), F = (e, ...t) => e + P(t).slice(0, 56), I = (e, t) => P([e, a(t)]), L = (n) => n instanceof e ? n : n instanceof N && [
+	"conflict",
+	"erased",
+	"limit_exceeded",
+	"forbidden",
+	"not_found",
+	"invalid_record"
+].includes(n.code) ? t(n.code) : t("unavailable"), R = (e) => D.tryPromise({
+	try: e,
+	catch: L
+}), z = (e) => {
+	try {
+		return e();
+	} catch (e) {
+		return D.fail(L(e));
+	}
+}, B = async (e) => {
+	let t = await D.runPromise(D.result(e));
+	if (O.isFailure(t)) throw t.failure;
+	return t.success;
+}, V = (e) => {
+	let t = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	return d(t, 0, 864e13);
+}, H = class extends Error {
+	constructor() {
+		super("Original container opening replay"), this.name = "OpeningReplay";
+	}
+}, ie = (e) => {
+	let c = i(e, [
+		"containers",
+		"currencies",
+		"realMoney",
+		"economy",
+		"inventory",
+		"accessSource",
+		"version",
+		"probability",
+		"roll",
+		"random",
+		"eligibility",
+		"priceResolver",
+		"systemAccount",
+		"maxHistoryRows",
+		"now"
+	]), l = o(c.currencies), u = c.realMoney ?? !1;
+	if (typeof u != "boolean") throw t("invalid_input");
+	let f = Object.freeze(r(c.containers, 256).map((e) => _(e, l, u)));
+	if (!f.length || new Set(f.map((e) => e.id)).size !== f.length) throw t("invalid_input");
+	for (let e of f) if (f.some((t) => t.group === e.group && JSON.stringify(t.pity) !== JSON.stringify(e.pity))) throw t("invalid_input");
+	let p = n(c.economy, ["prepareTransfer"]), v = c.inventory === void 0 ? void 0 : n(c.inventory, ["prepareGrant"]);
+	if (f.some((e) => e.drops.some((e) => e.items.length)) && !v) throw t("invalid_input");
+	let y = n(c.accessSource, ["read"]), b = n(c.random ?? S, ["draw"]), x = c.probability ?? h, C = c.roll ?? g, w = c.eligibility ?? m, T = c.priceResolver ?? s, E = c.now ?? Date.now;
+	if ([
+		x,
+		C,
+		w,
+		T,
+		E
+	].some((e) => typeof e != "function")) throw t("invalid_input");
+	let D = a(c.version);
+	if (D === "default.v1") throw t("invalid_input");
+	return Object.freeze({
+		containers: f,
+		currencies: l,
+		realMoney: u,
+		economy: p,
+		inventory: v,
+		accessSource: y,
+		random: b,
+		version: D,
+		probability: x,
+		roll: C,
+		eligibility: w,
+		priceResolver: T,
+		systemAccount: a(c.systemAccount ?? "containers"),
+		maxHistoryRows: d(c.maxHistoryRows ?? 1e4, 1, 1e5),
+		now: E
+	});
+}, U = (n, r) => {
+	let s = ie(r), m = k("economy.containers"), S = () => d(s.now(), 0, 864e13), O = (e, t) => F("eus_", e, t), A = (e, t, n) => F("euo_", e, t, n), N = (e, t, n, r, i, a) => P([
+		e,
+		t,
+		n,
+		r,
+		i,
+		a
+	]), L = (e) => {
+		let n = structuredClone(e);
+		if (n.type !== "user") throw t("forbidden");
+		return Object.freeze({
+			tenant: a(n.tenantId),
+			owner: a(n.id)
+		});
+	}, U = async (e, t) => {
+		await n.insertIgnore(E.tableName, {
+			id: F("eut_", e),
+			tenantId: e,
+			admission: 0
+		}, { conflictColumns: ["id"] }), await n.insertIgnore(T.tableName, {
+			id: O(e, t),
+			tenantId: e,
+			ownerId: t,
+			erased: !1,
+			admission: 0,
+			pendingId: null
+		}, { conflictColumns: ["id"] });
+	}, W = async (e, n, r, i = !1) => {
+		let a = F("eut_", n);
+		if (await e.updateMany(E.tableName, { admission: 0 }, { where: j("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(M(E).where(j("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.admission !== 0) throw t("invalid_record");
+		let s = O(n, r);
+		if (await e.updateMany(T.tableName, { admission: 0 }, { where: j("id", s) }) !== 1) throw t("unavailable");
+		let c = (await e.query(M(T).where(j("id", s)).limit(1).descriptor))[0];
+		if (!c || c.tenantId !== n || c.admission !== 0 || c.erased !== !0 && c.erased !== !1 || c.erased === !1 && c.ownerId !== r || c.erased === !0 && (c.ownerId !== null || c.pendingId !== null)) throw t("invalid_record");
+		if (c.erased === !0 && !i) throw t("erased");
+		if (c.pendingId !== null && !/^euo_[a-f0-9]{56}$/.test(String(c.pendingId))) throw t("invalid_record");
+		return c;
+	}, G = async (e, n, r, i) => {
+		let a = (await e.query(M(w).where(j("id", i)).limit(1).descriptor))[0];
+		if (a && (a.tenantId !== n || a.ownerKey !== O(n, r) || a.ownerId !== r)) throw t("invalid_record");
+		return a;
+	}, K = (e) => {
+		let n = i(e.intent, [
+			"request",
+			"container",
+			"currencies",
+			"realMoney",
+			"rulesVersion",
+			"basis",
+			"misses",
+			"distribution",
+			"at",
+			"probabilityDefault",
+			"rollDefault"
+		], "invalid_record"), r = i(n.request, [
+			"containerId",
+			"containerVersion",
+			"containerDigest",
+			"disclosureDigest",
+			"requestId",
+			"currency"
+		], "invalid_record"), s = p({
+			containerId: r.containerId,
+			containerVersion: r.containerVersion,
+			containerDigest: r.containerDigest,
+			disclosureDigest: r.disclosureDigest,
+			requestId: r.requestId,
+			currency: r.currency === null ? void 0 : r.currency
+		}), c = o(n.currencies);
+		if (typeof n.realMoney != "boolean" || typeof n.probabilityDefault != "boolean" || typeof n.rollDefault != "boolean") throw t("invalid_record");
+		let l = _(n.container, c, n.realMoney), u = a(n.rulesVersion), f = d(n.basis, 0, 1e5), m = d(n.misses, 0, l.pity ? l.pity.after - 1 : 0), h = d(n.at, 0, 864e13), g = i(n.distribution, [
+			"entries",
+			"total",
+			"guaranteed"
+		], "invalid_record"), v = {
+			container: l,
+			currencies: c,
+			realMoney: n.realMoney,
+			misses: m
+		}, b = y(v, () => g.entries);
+		if (g.total !== b.total || g.guaranteed !== b.guaranteed || n.probabilityDefault && JSON.stringify(b) !== JSON.stringify(y(v)) || e.id !== A(a(e.tenantId), a(e.ownerId), s.requestId) || e.ownerKey !== O(String(e.tenantId), String(e.ownerId)) || e.digest !== P([
+			e.tenantId,
+			e.ownerId,
+			s
+		]) || s.containerId !== l.id || s.containerVersion !== l.version || s.containerDigest !== I(l, u) || s.disclosureDigest !== N(String(e.tenantId), String(e.ownerId), s.containerDigest, f, m, b) || V(e.createdAt) !== h) throw t("invalid_record");
+		return Object.freeze({
+			request: s,
+			container: l,
+			currencies: c,
+			realMoney: n.realMoney,
+			rulesVersion: u,
+			basis: f,
+			misses: m,
+			distribution: b,
+			at: h,
+			probabilityDefault: n.probabilityDefault,
+			rollDefault: n.rollDefault
+		});
+	}, q = (e) => {
+		let n = K(e), r = i(e.selection, [
+			"draw",
+			"distribution",
+			"dropId",
+			"misses",
+			"price",
+			"adjustments",
+			"at"
+		], "invalid_record"), o = {
+			container: n.container,
+			currencies: n.currencies,
+			realMoney: n.realMoney,
+			misses: n.misses
+		}, s = i(r.distribution, [
+			"entries",
+			"total",
+			"guaranteed"
+		], "invalid_record"), u = y(o, () => s.entries);
+		if (u.total !== s.total || u.guaranteed !== s.guaranteed || JSON.stringify(u) !== JSON.stringify(n.distribution)) throw t("invalid_record");
+		let f = x(o, r.draw, () => u.entries, n.rollDefault ? g : () => a(r.dropId));
+		if (f.drop.id !== r.dropId || f.misses !== r.misses) throw t("invalid_record");
+		let p = c(n.container.price, n.currencies, n.realMoney, r.adjustments), m = l(p, () => r.price), h = d(r.at, n.at, 864e13);
+		return Object.freeze({
+			intent: n,
+			distribution: u,
+			drop: f.drop,
+			misses: f.misses,
+			price: m,
+			adjustments: p.adjustments,
+			at: h,
+			draw: r.draw
+		});
+	}, J = (e) => {
+		if (e.state !== "fulfilled" || e.sequence === null || e.ownerId === null) throw t("invalid_record");
+		let n = q(e), { intent: r, drop: o } = n, s = i(e.receipt, [
+			"operationId",
+			"containerId",
+			"containerVersion",
+			"containerDigest",
+			"dropId",
+			"rarity",
+			"previousMisses",
+			"misses",
+			"sequence",
+			"at",
+			"distribution",
+			"pricePaid",
+			"transfers",
+			"grants"
+		], "invalid_record"), c = d(s.at, n.at, 864e13), l = d(s.sequence, 1, 1e5), p = f(n.price, r.request.currency, 1);
+		if (s.operationId !== e.id || s.containerId !== r.container.id || s.containerVersion !== r.container.version || s.containerDigest !== r.request.containerDigest || s.dropId !== o.id || s.rarity !== o.rarity || s.previousMisses !== r.misses || s.misses !== n.misses || l !== e.sequence || l !== r.basis + 1 || V(e.fulfilledAt) !== c) throw t("invalid_record");
+		let m = u({
+			orderId: e.id,
+			offerId: r.container.id,
+			offerVersion: r.container.version,
+			offerDigest: r.request.containerDigest,
+			quantity: 1,
+			at: c,
+			pricePaid: s.pricePaid,
+			transfers: s.transfers,
+			grants: s.grants
+		}), h = i(s.distribution, [
+			"entries",
+			"total",
+			"guaranteed"
+		], "invalid_record"), g = y({
+			container: r.container,
+			currencies: r.currencies,
+			realMoney: r.realMoney,
+			misses: r.misses
+		}, () => h.entries);
+		if (JSON.stringify(m.pricePaid) !== JSON.stringify(p) || h.total !== g.total || h.guaranteed !== g.guaranteed || JSON.stringify(g) !== JSON.stringify(n.distribution)) throw t("invalid_record");
+		let _ = [...p.kind === "virtual" && BigInt(p.amount) > 0n ? [{
+			currency: p.currency,
+			amount: p.amount
+		}] : [], ...o.currencies];
+		if (m.transfers.length !== _.length || m.grants.length !== o.items.length || m.transfers.some((e, t) => e.currency !== _[t].currency || e.amount !== _[t].amount || e.at < r.at || e.at > c) || m.grants.some((e, t) => e.at < r.at || e.at > c || e.changes.reduce((e, t) => e + t.delta, 0) !== o.items[t].qty)) throw t("invalid_record");
+		return Object.freeze({
+			operationId: a(e.id),
+			containerId: r.container.id,
+			containerVersion: r.container.version,
+			containerDigest: r.request.containerDigest,
+			dropId: o.id,
+			rarity: o.rarity,
+			previousMisses: r.misses,
+			misses: n.misses,
+			sequence: l,
+			at: c,
+			distribution: n.distribution,
+			pricePaid: p,
+			transfers: m.transfers,
+			grants: m.grants
+		});
+	}, Y = async (e, n, r, i = !1) => {
+		let a = await e.query(M(w).where(ee(j("tenantId", n), j("ownerKey", O(n, r)))).limit(s.maxHistoryRows + 1).descriptor);
+		if (a.length > s.maxHistoryRows) throw t("limit_exceeded");
+		let o = [];
+		for (let e of a) {
+			if (!/^euo_[a-f0-9]{56}$/.test(String(e.id)) || e.ownerKey !== O(n, r) || e.tenantId !== n) throw t("invalid_record");
+			if (e.state === "erased") {
+				if (!i) throw t("erased");
+				if (e.ownerId !== null || e.digest !== null || e.intent !== null || e.selection !== null || e.receipt !== null) throw t("invalid_record");
+			} else {
+				if (e.ownerId !== r) throw t("invalid_record");
+				if (e.state === "fulfilled") o.push({
+					row: e,
+					receipt: J(e),
+					intent: K(e)
+				});
+				else if (e.state === "pending") {
+					if (K(e), e.selection !== null && q(e), e.receipt !== null || e.sequence !== null || e.fulfilledAt !== null) throw t("invalid_record");
+				} else throw t("invalid_record");
+			}
+		}
+		if (o.sort((e, t) => e.receipt.sequence - t.receipt.sequence), a.filter((e) => e.state === "pending").length > 1 || o.some((e, t) => e.receipt.sequence !== t + 1 || t > 0 && e.receipt.at < o[t - 1].receipt.at)) throw t("invalid_record");
+		return {
+			rows: a,
+			accepted: o
+		};
+	}, X = (e, n) => {
+		let r = 0;
+		for (let i of e) if (i.intent.container.group === n.group) {
+			if (JSON.stringify(i.intent.container.pity) !== JSON.stringify(n.pity) || i.receipt.previousMisses !== r) throw t("conflict");
+			r = i.receipt.misses;
+		}
+		return r;
+	}, Z = async (e, n, r, a) => {
+		let o = s.accessSource.read(Object.freeze({
+			tenantId: e,
+			ownerId: n,
+			container: r,
+			at: a
+		}));
+		if (!D.isEffect(o)) throw t("invalid_input");
+		let u = i(await B(o), [
+			"isMinor",
+			"country",
+			"eligible",
+			"adjustments"
+		]);
+		if (typeof u.isMinor != "boolean" || typeof u.eligible != "boolean" || typeof u.country != "string" || !/^[A-Z]{2}$/.test(u.country)) throw t("invalid_input");
+		let d = Object.freeze({
+			container: r,
+			at: a,
+			isMinor: u.isMinor,
+			country: u.country,
+			eligible: u.eligible
+		});
+		if (!b(d, s.currencies, s.realMoney, s.eligibility)) throw t("forbidden");
+		let f = c(r.price, s.currencies, s.realMoney, u.adjustments);
+		return {
+			price: l(f, s.priceResolver),
+			adjustments: f.adjustments
+		};
+	}, Q = async (e, r, i, a) => n.transactional(async (n) => {
+		let o = await W(n, e, r), s = await G(n, e, r, i);
+		if (s && s.digest !== a) throw t("conflict");
+		if (s?.state === "fulfilled") return {
+			row: s,
+			receipt: J(s)
+		};
+		if (s && (s.state !== "pending" || o.pendingId !== i)) throw t("invalid_record");
+		return {
+			row: s,
+			receipt: void 0
+		};
+	}), ae = (e, r) => z(() => {
+		let { tenant: i, owner: a } = L(e), o = p(r), c = A(i, a, o.requestId), l = P([
+			i,
+			a,
+			o
+		]);
+		return R(async () => {
+			await U(i, a);
+			let e = await Q(i, a, c, l);
+			if (e.receipt) return e.receipt;
+			if (!e.row) {
+				let r = s.containers.find((e) => e.id === o.containerId);
+				if (!r) throw t("not_found");
+				if (r.version !== o.containerVersion || I(r, s.version) !== o.containerDigest) throw t("conflict");
+				f(r.price, o.currency, 1);
+				let u = S();
+				await Z(i, a, r, u);
+				let d = await n.transactional(async (e) => {
+					await W(e, i, a);
+					let t = await Y(e, i, a);
+					return {
+						basis: t.accepted.length,
+						misses: X(t.accepted, r)
+					};
+				}), p = y({
+					container: r,
+					currencies: s.currencies,
+					realMoney: s.realMoney,
+					misses: d.misses
+				}, s.probability);
+				if (o.disclosureDigest !== N(i, a, o.containerDigest, d.basis, d.misses, p)) throw t("conflict");
+				if (await n.transactional(async (e) => {
+					let n = await W(e, i, a), f = await G(e, i, a, c);
+					if (f) {
+						if (f.digest !== l) throw t("conflict");
+						return;
+					}
+					if (n.pendingId !== null) throw t("conflict");
+					let m = await Y(e, i, a);
+					if (m.rows.length >= s.maxHistoryRows) throw t("limit_exceeded");
+					if (m.rows.some((e) => e.state === "pending") || (m.accepted.at(-1)?.receipt.at ?? 0) > u) throw t("invalid_record");
+					let v = X(m.accepted, r), y = F("eud_", i, r.id, r.version, s.version);
+					if (m.accepted.length !== d.basis || v !== d.misses) throw t("conflict");
+					let b = (await e.query(M(C).where(j("id", y)).limit(1).descriptor))[0];
+					if (b) {
+						if (b.tenantId !== i || b.rulesVersion !== s.version || typeof b.realMoney != "boolean" || I(_(b.definition, b.currencies, b.realMoney), s.version) !== o.containerDigest) throw t("conflict");
+					} else await e.insert(C.tableName, {
+						id: y,
+						tenantId: i,
+						definition: r,
+						currencies: s.currencies,
+						realMoney: s.realMoney,
+						rulesVersion: s.version,
+						createdAt: new Date(u)
+					});
+					await e.insert(w.tableName, {
+						id: c,
+						tenantId: i,
+						ownerId: a,
+						ownerKey: O(i, a),
+						state: "pending",
+						digest: l,
+						intent: {
+							request: o,
+							container: r,
+							currencies: s.currencies,
+							realMoney: s.realMoney,
+							rulesVersion: s.version,
+							basis: m.accepted.length,
+							misses: v,
+							distribution: p,
+							at: u,
+							probabilityDefault: s.probability === h,
+							rollDefault: s.roll === g
+						},
+						selection: null,
+						receipt: null,
+						sequence: null,
+						createdAt: new Date(u),
+						fulfilledAt: null
+					}), await e.update(T.tableName, O(i, a), { pendingId: c });
+				}), e = await Q(i, a, c, l), e.receipt) return e.receipt;
+			}
+			if (!e.row) throw t("invalid_record");
+			let r = K(e.row);
+			if (r.rulesVersion !== s.version || !s.containers.some((e) => I(e, s.version) === r.request.containerDigest)) throw t("conflict");
+			let u = S();
+			if (u < r.at) throw t("invalid_record");
+			let d = await Z(i, a, r.container, u);
+			if (e.row.selection === null) {
+				let o = {
+					container: r.container,
+					currencies: r.currencies,
+					realMoney: r.realMoney,
+					misses: r.misses
+				}, f = r.distribution, p = await B(s.random.draw(f.total)), m = x(o, p, () => f.entries, s.roll), h = {
+					draw: p,
+					distribution: f,
+					dropId: m.drop.id,
+					misses: m.misses,
+					price: d.price,
+					adjustments: d.adjustments,
+					at: u
+				};
+				if (await n.transactional(async (e) => {
+					let n = await W(e, i, a), r = await G(e, i, a, c);
+					if (!r || r.digest !== l) throw t("invalid_record");
+					if (r.state !== "fulfilled") {
+						if (r.state !== "pending" || n.pendingId !== c) throw t("conflict");
+						r.selection === null && await e.update(w.tableName, c, { selection: h });
+					}
+				}), e = await Q(i, a, c, l), e.receipt) return e.receipt;
+			}
+			if (!e.row) throw t("invalid_record");
+			let p = q(e.row), v = f(p.price, o.currency, 1), b = [];
+			b.push(ne(n, async (e) => {
+				let n = await W(e, i, a), o = await G(e, i, a, c);
+				if (!o || o.digest !== l) throw t("invalid_record");
+				if (o.state === "fulfilled") throw J(o), new H();
+				if (o.state !== "pending" || n.pendingId !== c || JSON.stringify(q(o)) !== JSON.stringify(p)) throw t("conflict");
+				let s = await Y(e, i, a);
+				if (s.accepted.length !== r.basis || X(s.accepted, r.container) !== r.misses) throw t("conflict");
+				return null;
+			})), v.kind === "virtual" && BigInt(v.amount) > 0n && b.push(await B(s.economy.prepareTransfer(m, {
+				tenantId: i,
+				requestId: F("euk_", c, "debit"),
+				currency: v.currency,
+				amount: v.amount,
+				from: {
+					kind: "wallet",
+					ownerKind: "player",
+					ownerId: a
+				},
+				to: {
+					kind: "system",
+					id: s.systemAccount
+				},
+				reason: "container.open",
+				ref: {
+					kind: "container-opening",
+					id: c
+				}
+			})));
+			for (let [e, t] of p.drop.currencies.entries()) b.push(await B(s.economy.prepareTransfer(m, {
+				tenantId: i,
+				requestId: F("euk_", c, "gift", String(e)),
+				currency: t.currency,
+				amount: t.amount,
+				from: {
+					kind: "system",
+					id: s.systemAccount
+				},
+				to: {
+					kind: "wallet",
+					ownerKind: "player",
+					ownerId: a
+				},
+				reason: "container.reward",
+				ref: {
+					kind: "container-opening",
+					id: c
+				}
+			})));
+			for (let [e, n] of p.drop.items.entries()) {
+				if (!s.inventory) throw t("unavailable");
+				b.push(await B(s.inventory.prepareGrant(m, {
+					tenantId: i,
+					owner: {
+						ownerKind: "player",
+						ownerId: a
+					},
+					itemId: n.itemId,
+					qty: n.qty,
+					requestId: F("euk_", c, "item", String(e)),
+					reason: "container.reward",
+					ref: {
+						kind: "container-opening",
+						id: c
+					}
+				})));
+			}
+			let E = S();
+			if (E < u) throw t("invalid_record");
+			let D = p.drop.currencies.length + +(v.kind === "virtual" && BigInt(v.amount) > 0n), k = re(n, b, async (e, n) => {
+				let s = {
+					operationId: c,
+					containerId: r.container.id,
+					containerVersion: r.container.version,
+					containerDigest: o.containerDigest,
+					dropId: p.drop.id,
+					rarity: p.drop.rarity,
+					previousMisses: r.misses,
+					misses: p.misses,
+					sequence: r.basis + 1,
+					at: E,
+					distribution: p.distribution,
+					pricePaid: v,
+					transfers: n.slice(1, 1 + D),
+					grants: n.slice(1 + D)
+				};
+				await e.update(w.tableName, c, {
+					state: "fulfilled",
+					sequence: s.sequence,
+					receipt: s,
+					fulfilledAt: new Date(E)
+				}), await e.update(T.tableName, O(i, a), { pendingId: null });
+				let l = await G(e, i, a, c);
+				if (!l) throw t("invalid_record");
+				return J(l);
+			});
+			try {
+				return (await te(n, [k]))[0];
+			} catch (e) {
+				if (e instanceof H) {
+					let e = await Q(i, a, c, l);
+					if (e.receipt) return e.receipt;
+				}
+				throw e;
+			}
+		});
+	}), $ = async (e, n, r) => {
+		let i = (await e.query(M(T).where(j("id", O(n, r))).limit(1).descriptor))[0];
+		if (i && (i.tenantId !== n || i.erased !== !0 && i.erased !== !1 || i.erased === !1 && i.ownerId !== r || i.erased === !0 && i.ownerId !== null)) throw t("invalid_record");
+		if (i?.erased === !0) throw t("erased");
+		if (!i && (await e.query(M(w).where(ee(j("tenantId", n), j("ownerKey", O(n, r)))).limit(1).descriptor)).length) throw t("invalid_record");
+	}, oe = (e, r) => z(() => {
+		let { tenant: i, owner: a } = L(e), o = p(r), s = A(i, a, o.requestId), c = P([
+			i,
+			a,
+			o
+		]);
+		return R(async () => n.transactional(async (e) => {
+			await $(e, i, a);
+			let n = await G(e, i, a, s);
+			if (!n) return Object.freeze({
+				requestId: o.requestId,
+				state: "not-observed"
+			});
+			if (n.digest !== c) throw t("conflict");
+			if (n.state === "fulfilled") return Object.freeze({
+				requestId: o.requestId,
+				state: "fulfilled",
+				receipt: J(n)
+			});
+			if (n.state !== "pending") throw t("invalid_record");
+			return K(n), n.selection !== null && q(n), Object.freeze({
+				requestId: o.requestId,
+				state: "pending"
+			});
+		}));
+	}), se = (t) => z(() => {
+		let { tenant: r, owner: i } = L(t);
+		return R(async () => {
+			let t = await n.transactional(async (e) => (await $(e, r, i), Y(e, r, i))), a = S(), o = [];
+			for (let n of s.containers) try {
+				let e = await Z(r, i, n, a), c = X(t.accepted, n), l = {
+					container: n,
+					misses: c,
+					currencies: s.currencies,
+					realMoney: s.realMoney
+				}, u = I(n, s.version), d = y(l, s.probability);
+				o.push(Object.freeze({
+					container: n,
+					containerDigest: u,
+					disclosureDigest: N(r, i, u, t.accepted.length, c, d),
+					misses: c,
+					price: e.price,
+					disclosure: v(l, () => d.entries)
+				}));
+			} catch (t) {
+				if (!(t instanceof e) || t.code !== "forbidden") throw t;
+			}
+			return Object.freeze(o);
+		});
+	}), ce = (e) => {
+		let n = i(e, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (n.kind !== "guest" && n.kind !== "user") throw t("invalid_input");
+		return {
+			tenant: a(n.tenantId),
+			owner: a(n.subjectId)
+		};
+	};
+	return Object.freeze({
+		list: se,
+		open: ae,
+		receipt: oe,
+		exportSubject: (e) => z(() => {
+			let { tenant: r, owner: i } = ce(e);
+			return R(async () => n.transactional(async (e) => {
+				let n = (await e.query(M(T).where(j("id", O(r, i))).limit(1).descriptor))[0];
+				if (n?.erased === !0) {
+					if (n.tenantId !== r || n.ownerId !== null) throw t("invalid_record");
+					return { openings: [] };
+				}
+				return await $(e, r, i), { openings: (await Y(e, r, i)).rows };
+			}));
+		}),
+		eraseSubject: (e) => z(() => {
+			let { tenant: t, owner: r } = ce(e);
+			return R(async () => {
+				await U(t, r), await n.transactional(async (e) => {
+					await W(e, t, r, !0);
+					let n = await Y(e, t, r, !0);
+					for (let t of n.rows) await e.update(w.tableName, String(t.id), {
+						ownerId: null,
+						state: "erased",
+						digest: null,
+						intent: null,
+						selection: null,
+						receipt: null
+					});
+					await e.update(T.tableName, O(t, r), {
+						ownerId: null,
+						erased: !0,
+						pendingId: null
+					});
+				});
+			});
+		})
+	});
+};
+//#endregion
+export { I as containerDefinitionDigest, U as dataStoreContainers, ie as resolveContainersStoreOptions };