@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/walletStore.js

@@ -0,0 +1,571 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { dataList as n, dataObject as r, identifier as i } from "./capture.js";
+import { economyAmount as a, economyAmountString as o, nonNegativeAmount as s, positiveAmount as c } from "./amount.js";
+import { captureCurrencies as l, defineCurrency as u } from "./currency.js";
+import { readVerifiedIapCurrentState as d } from "./iapCurrentState.server.js";
+import { walletHash as f, walletKey as p } from "./walletKeys.server.js";
+import { applyWalletPosting as m, applyWalletRefundPosting as h, captureAccount as g, economyAccountKey as _, planEscrowLedgerTransfer as v, planLedgerTransfer as y } from "./ledger.js";
+import { economyCurrenciesTable as b, economyLedgerTable as x, economySubjectsTable as S, economyTransactionsTable as C, economyWalletsTable as w } from "./tables.entity.js";
+import { walletEscrowParticipant as T } from "./walletEscrow.server.js";
+import { assertSpendBudget as ee, captureSpendLimitsOptions as E, projectSpend as te, resolveSpendBudget as ne } from "./spendLimits.js";
+import { Effect as D, Result as re, Schema as O } from "effect";
+import { and as k, eq as A, inSet as j, queryFor as M } from "@voltro/database";
+import { executeSqlMutations as ie, prepareSqlMutation as ae } from "@voltro/database/sql";
+//#region src/walletStore.ts
+var N = (n) => n instanceof e ? n : t("unavailable"), P = (e) => D.tryPromise({
+	try: e,
+	catch: N
+}), F = (e) => {
+	let n = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	if (!Number.isSafeInteger(n) || n < 0 || n > 864e13) throw t("invalid_record");
+	return n;
+}, I = O.Struct({
+	txId: O.String,
+	currency: O.String,
+	amount: O.String,
+	at: O.Number
+}), L = (e) => {
+	let n = O.decodeUnknownSync(I)(e.receipt);
+	if (n.txId !== e.id || F(e.createdAt) > n.at || !Number.isSafeInteger(n.at) || n.at < 0 || n.at > 864e13) throw t("invalid_record");
+	return Object.freeze({
+		txId: i(n.txId),
+		currency: i(n.currency),
+		amount: o(c(n.amount)),
+		at: n.at
+	});
+}, R = (e, t, n) => p("ecw_", e, _(t), n), z = async (e, n, r, a) => {
+	let o = /* @__PURE__ */ new Map();
+	for (let c = 0; c < r.length; c += 128) {
+		let l = r.slice(c, c + 128), u = await e.query(M(x).where(k(A("tenantId", n), j("txId", l))).limit(l.length * 2 + 1).descriptor), d = await e.query(M(C).where(k(A("tenantId", n), j("id", l))).limit(l.length + 1).descriptor);
+		if (u.length !== l.length * 2 || d.length !== l.length) throw t("invalid_record");
+		for (let e of l) {
+			let r = u.filter((t) => t.txId === e), c = d.find((t) => t.id === e);
+			if (r.length !== 2 || !c || c.tenantId !== n || c.state !== "committed" && c.state !== "erased") throw t("invalid_record");
+			let l = c.state === "committed" ? L(c) : null;
+			if (l && (l.currency !== a || typeof c.digest != "string" || !/^[0-9a-f]{64}$/.test(c.digest)) || !l && (c.receipt !== null || c.digest !== null || c.escrow !== null)) throw t("invalid_record");
+			let f = 0n, m = [];
+			for (let o of r) {
+				let r = s(o.debit), c = s(o.credit);
+				if (o.tenantId !== n || o.currency !== a || r === 0n == (c === 0n) || o.id !== p("ecl_", e, r > 0n ? "0" : "1") || l && ((r > 0n ? r : c).toString() !== l.amount || F(o.at) !== l.at)) throw t("invalid_record");
+				if (o.accountKind === "system") {
+					if (o.ownerId !== null || o.ownerKind !== null || o.walletKey !== null) throw t("invalid_record");
+					m.push(_({
+						kind: "system",
+						id: i(o.systemAccount)
+					}));
+				} else if (o.accountKind === "wallet") {
+					if (o.systemAccount !== null) throw t("invalid_record");
+					if (o.ownerId === null && o.ownerKind === null && o.walletKey === null && !l) m.push("erased:" + String(o.id));
+					else {
+						if (o.ownerKind !== "player" && o.ownerKind !== "guild") throw t("invalid_record");
+						let e = {
+							kind: "wallet",
+							ownerKind: o.ownerKind,
+							ownerId: i(o.ownerId)
+						};
+						if (o.walletKey !== R(n, e, a)) throw t("invalid_record");
+						m.push(_(e));
+					}
+				} else throw t("invalid_record");
+				f += c - r;
+			}
+			let h = r.find((e) => BigInt(String(e.debit)) > 0n), g = r.find((e) => BigInt(String(e.credit)) > 0n), v = h?.reason === "escrow.tax" && typeof h.systemAccount == "string" && h.systemAccount.startsWith("escrow.") && !h.systemAccount.startsWith("escrow.tax.") && typeof g?.systemAccount == "string" && g.systemAccount.startsWith("escrow.tax.");
+			if (r[0].reason !== r[1].reason || r[0].refKind !== r[1].refKind || r[0].refId !== r[1].refId || r[0].actor !== r[1].actor || f !== 0n || m[0] === m[1] || r.every((e) => e.accountKind === "system") && !v || F(r[0].at) !== F(r[1].at)) throw t("invalid_record");
+			o.set(e, {
+				pair: r,
+				receipt: c
+			});
+		}
+	}
+	return o;
+}, oe = (e) => {
+	let a = r(e, [
+		"currencies",
+		"allowedServices",
+		"maxLedgerRows",
+		"maxExportRows",
+		"now",
+		"spendLimits"
+	]), o = l(a.currencies), s = n(a.allowedServices ?? [], 256).map((e) => i(e));
+	if (new Set(s).size !== s.length) throw t("invalid_input");
+	let c = a.maxLedgerRows ?? 1e4, u = a.maxExportRows ?? 1e4, d = a.now ?? Date.now;
+	if (typeof c != "number" || !Number.isSafeInteger(c) || c < 2 || c > 1e5 || typeof u != "number" || !Number.isSafeInteger(u) || u < 1 || u > 1e5 || typeof d != "function") throw t("invalid_input");
+	return Object.freeze({
+		currencies: o,
+		allowedServices: Object.freeze(s),
+		maxLedgerRows: c,
+		maxExportRows: u,
+		now: d,
+		spendLimits: a.spendLimits === void 0 ? void 0 : E(a.spendLimits, o)
+	});
+}, B = (e, n) => {
+	let l = oe(n), E = new Set(l.allowedServices), O = new Map(l.currencies.map((e) => [e.id, e])), I = () => {
+		let e = l.now();
+		if (!Number.isSafeInteger(e) || e < 0 || e > 864e13) throw t("unavailable");
+		return e;
+	}, B = (e) => e.type === "system" || e.type === "service" && E.has(e.service), V = (e) => {
+		let n = O.get(e);
+		if (!n) throw t("invalid_currency");
+		return n;
+	}, H = (e, t) => p("ecs_", e, _(t)), U = async (t, n) => {
+		if (n.kind !== "wallet") return;
+		let r = H(t, n);
+		try {
+			await e.insertIgnore(S.tableName, {
+				id: r,
+				tenantId: t,
+				ownerKind: n.ownerKind,
+				ownerId: n.ownerId,
+				erased: !1,
+				admission: 0,
+				entriesCount: 0
+			}, { conflictColumns: ["id"] });
+		} catch (t) {
+			if (!(await e.query(M(S).where(A("id", r)).limit(1).descriptor))[0]) throw t;
+		}
+	}, W = async (e, n, r, i = !1) => {
+		if (r.kind !== "wallet") throw t("invalid_input");
+		let a = H(n, r);
+		if (await e.updateMany(S.tableName, { admission: 0 }, { where: A("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(M(S).where(A("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.ownerKind !== r.ownerKind || o.admission !== 0 || typeof o.entriesCount != "number" || !Number.isSafeInteger(o.entriesCount) || o.entriesCount < 0 || o.entriesCount > 1e5) throw t("invalid_record");
+		if (o.erased === !0) {
+			if (i && o.ownerId === null) return o;
+			throw t("erased");
+		}
+		if (o.ownerId !== r.ownerId || o.erased !== !1) throw t("invalid_record");
+		return o;
+	}, G = async (t, n) => {
+		let r = p("ecc_", t, n.id);
+		try {
+			await e.insertIgnore(b.tableName, {
+				id: r,
+				tenantId: t,
+				currency: n.id,
+				config: n,
+				admission: 0
+			}, { conflictColumns: ["id"] });
+		} catch (t) {
+			if (!(await e.query(M(b).where(A("id", r)).limit(1).descriptor))[0]) throw t;
+		}
+	}, K = async (e, n, r, i) => {
+		let a = p("ecc_", n, r);
+		if (await e.updateMany(b.tableName, { admission: 0 }, { where: A("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(M(b).where(A("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.currency !== r) throw t("invalid_record");
+		if (i && f(u(o.config)) !== f(i)) throw t("conflict");
+	}, q = async (e, n, r, i, a = l.maxExportRows) => {
+		let o = await e.query(M(n).where(k(A("tenantId", r), A("ownerKind", i.ownerKind), A("ownerId", i.ownerId))).orderBy("id", "asc").limit(a + 1).descriptor);
+		if (o.length > a) throw t("limit_exceeded");
+		if (o.some((e) => e.tenantId !== r || e.ownerKind !== i.ownerKind || e.ownerId !== i.ownerId)) throw t("invalid_record");
+		return o;
+	}, J = async (e, n, r, i) => {
+		let a = R(n, r, i), o = (await e.query(M(w).where(A("id", a)).limit(1).descriptor))[0];
+		if (!o) return null;
+		if (o.tenantId !== n || o.ownerId !== r.ownerId || o.ownerKind !== r.ownerKind || o.currency !== i) throw t("invalid_record");
+		return o;
+	}, Y = async (e, n, r) => {
+		let i = await W(e, n, r), a = await q(e, x, n, r, l.maxLedgerRows);
+		if (a.length !== i.entriesCount) throw t("invalid_record");
+		return a;
+	}, se = /* @__PURE__ */ new WeakMap(), X = Object.freeze(Object.create(null)), Z = (n, c, u) => {
+		try {
+			let d = structuredClone(n), g = u === X ? v(c) : y(c);
+			if (!B(d) || g.postings.some((e) => e.account.kind === "system" && e.account.id.startsWith("escrow.")) && u !== X) throw t("forbidden");
+			let b = u === void 0 ? void 0 : se.get(u), T = V(g.currency), E = f(b ? [
+				g,
+				b.originalTxId,
+				b.debtPolicy
+			] : g), O = p("ect_", g.tenantId, g.requestId), j = g.postings.map((e) => e.account).filter((e) => e.kind === "wallet").sort((e, t) => H(g.tenantId, e).localeCompare(H(g.tenantId, t)));
+			return P(async () => {
+				for (let e of j) await U(g.tenantId, e);
+				await G(g.tenantId, T);
+				let n = await e.transactional(async (e) => {
+					for (let t of j) await W(e, g.tenantId, t);
+					await K(e, g.tenantId, T.id, T);
+					let n = (await e.query(M(C).where(A("id", O)).limit(1).descriptor))[0];
+					if (n?.state === "committed") {
+						if (n.tenantId !== g.tenantId || n.digest !== E) throw t("conflict");
+						return L(n);
+					}
+					if (n?.state === "erased") throw t("erased");
+				}), c = n?.at ?? I(), u, f = g.postings.find((e) => e.account.kind === "wallet" && BigInt(e.debit) > 0n)?.account, v = l.spendLimits, y = v?.limits.find((e) => e.currency === T.id);
+				if (!n && !b && v && y && f?.kind === "wallet") {
+					let e = Object.freeze({
+						tenantId: g.tenantId,
+						ownerId: f.ownerId,
+						ownerKind: f.ownerKind,
+						currency: T.id,
+						at: c
+					}), n = v.source.read(e);
+					if (!D.isEffect(n)) throw t("invalid_record");
+					let i = await D.runPromise(D.result(n));
+					if (re.isFailure(i)) throw i.failure;
+					let a = r(i.success, [
+						"tenantId",
+						"ownerId",
+						"ownerKind",
+						"currency",
+						"at",
+						"allowed",
+						"minor",
+						"observedAt",
+						"daily",
+						"monthly",
+						"blockedUntil"
+					], "invalid_record");
+					if (a.tenantId !== e.tenantId || a.ownerId !== e.ownerId || a.ownerKind !== e.ownerKind || a.currency !== e.currency || a.at !== c) throw t("invalid_record");
+					u = ne({
+						limit: y,
+						facts: i.success,
+						version: v.version
+					}, v.policy);
+				}
+				try {
+					await e.insertIgnore(C.tableName, {
+						id: O,
+						tenantId: g.tenantId,
+						state: "pending",
+						digest: null,
+						receipt: null,
+						escrow: null,
+						admission: 0,
+						createdAt: new Date(c)
+					}, { conflictColumns: ["id"] });
+				} catch (t) {
+					if (!(await e.query(M(C).where(A("id", O)).limit(1).descriptor))[0]) throw t;
+				}
+				return ae(e, async (e) => {
+					for (let t of j) await W(e, g.tenantId, t);
+					if (await K(e, g.tenantId, T.id, T), await e.updateMany(C.tableName, { admission: 0 }, { where: A("id", O) }) !== 1) throw t("unavailable");
+					let n = (await e.query(M(C).where(A("id", O)).limit(1).descriptor))[0];
+					if (!n || n.tenantId !== g.tenantId) throw t("invalid_record");
+					if (n.state === "erased") throw t("erased");
+					if (n.state === "committed") {
+						if (n.digest !== E) throw t("conflict");
+						return L(n);
+					}
+					if (n.state !== "pending" || n.digest !== null || n.receipt !== null || n.escrow !== null || F(n.createdAt) > c || (await e.query(M(x).where(k(A("tenantId", g.tenantId), A("txId", O))).limit(1).descriptor)).length !== 0) throw t("invalid_record");
+					if (b) {
+						b.assertFresh();
+						let n = (await z(e, g.tenantId, [b.originalTxId], T.id)).get(b.originalTxId), r = n.pair.find((e) => BigInt(String(e.credit)) > 0n), i = n.pair.find((e) => BigInt(String(e.debit)) > 0n), a = g.postings[0].account, o = g.postings[1].account;
+						if (a.kind !== "wallet" || o.kind !== "system" || !r || !i || r.ownerId !== a.ownerId || r.ownerKind !== a.ownerKind || i.systemAccount !== o.id || i.reason !== "iap.fulfill" || BigInt(g.amount) > BigInt(String(r.credit))) throw t("invalid_record");
+					}
+					let r = [];
+					for (let n of g.postings) {
+						if (n.account.kind !== "wallet") continue;
+						let d = await Y(e, g.tenantId, n.account);
+						if (d.length >= l.maxLedgerRows) throw t("limit_exceeded");
+						let f = d.filter((e) => e.currency === T.id), p = await J(e, g.tenantId, n.account, T.id);
+						if (p && F(p.updatedAt) > c) throw t("invalid_record");
+						if (!b && BigInt(n.debit) > 0n && (await q(e, w, g.tenantId, n.account)).some((e) => a(e.balance) < 0n && e.debtPolicy === "blockSpend")) throw t("forbidden");
+						if (u && BigInt(n.debit) > 0n) {
+							await z(e, g.tenantId, [...new Set(f.map((e) => i(e.txId)))], T.id);
+							let r = te(f.map((e) => ({
+								id: i(e.id),
+								debit: String(e.debit),
+								credit: String(e.credit),
+								at: F(e.at)
+							})), c);
+							if (r.balance !== o(s(p?.balance ?? "0"))) throw t("invalid_record");
+							ee(r, n.debit, u);
+						}
+						let _ = (b ? h : m)(p?.balance ?? "0", n, T), v = p?.debtPolicy ?? null;
+						if (v !== null && v !== "allowNegative" && v !== "blockSpend" || BigInt(p?.balance ?? "0") < 0n && v === null) throw t("invalid_record");
+						r.push({
+							account: n.account,
+							row: p,
+							next: _,
+							debtPolicy: BigInt(_) < 0n ? v === "blockSpend" || b?.debtPolicy === "blockSpend" ? "blockSpend" : "allowNegative" : null
+						});
+					}
+					for (let t of r) {
+						let n = R(g.tenantId, t.account, T.id);
+						t.row ? await e.update(w.tableName, n, {
+							balance: t.next,
+							debtPolicy: t.debtPolicy,
+							updatedAt: new Date(c)
+						}) : await e.insert(w.tableName, {
+							id: n,
+							tenantId: g.tenantId,
+							ownerId: t.account.ownerId,
+							ownerKind: t.account.ownerKind,
+							currency: T.id,
+							balance: t.next,
+							debtPolicy: t.debtPolicy,
+							updatedAt: new Date(c)
+						});
+					}
+					for (let [t, n] of g.postings.entries()) {
+						let a = n.account, o = a.kind === "wallet" ? r.find((e) => _(e.account) === _(a)) : null, s = a.kind === "wallet" ? Number((await W(e, g.tenantId, a)).entriesCount) + 1 : null;
+						await e.insert(x.tableName, {
+							id: p("ecl_", O, String(t)),
+							tenantId: g.tenantId,
+							txId: O,
+							currency: T.id,
+							accountKind: a.kind,
+							ownerId: a.kind === "wallet" ? a.ownerId : null,
+							ownerKind: a.kind === "wallet" ? a.ownerKind : null,
+							walletKey: a.kind === "wallet" ? R(g.tenantId, a, T.id) : null,
+							systemAccount: a.kind === "system" ? a.id : null,
+							ownerSequence: s,
+							debtPolicy: o?.debtPolicy ?? null,
+							debit: n.debit,
+							credit: n.credit,
+							reason: g.reason,
+							refKind: g.ref.kind,
+							refId: g.ref.id,
+							actor: i(d.id),
+							at: new Date(c)
+						});
+					}
+					for (let t of j) {
+						let n = await W(e, g.tenantId, t);
+						await e.update(S.tableName, H(g.tenantId, t), { entriesCount: Number(n.entriesCount) + 1 });
+					}
+					let f = Object.freeze({
+						txId: O,
+						currency: T.id,
+						amount: g.amount,
+						at: c
+					});
+					return await e.update(C.tableName, O, {
+						state: "committed",
+						digest: E,
+						receipt: f
+					}), f;
+				});
+			});
+		} catch (e) {
+			return D.fail(N(e));
+		}
+	}, ce = (e, t) => Z(e, t), le = (n, a, o) => {
+		try {
+			let s = structuredClone(n), l = r(o, [
+				"requestId",
+				"currency",
+				"amount",
+				"debtPolicy"
+			]), u = i(l.requestId), f = i(l.currency), p = c(l.amount).toString();
+			if (!B(s)) throw t("forbidden");
+			if (l.debtPolicy !== "allowNegative" && l.debtPolicy !== "blockSpend") throw t("invalid_input");
+			let m = l.debtPolicy;
+			return d(a).pipe(D.flatMap(({ original: n, state: r, assertFresh: a }) => P(async () => {
+				let o = n.receipt.transfers.find((e) => e.currency === f);
+				if (!o || BigInt(p) > BigInt(o.amount) * BigInt(r.refundNumerator) / BigInt(r.refundDenominator)) throw t("forbidden");
+				let c = (await e.transactional(async (e) => (await z(e, n.scope.tenantId, [o.txId], f)).get(o.txId))).pair.find((e) => BigInt(String(e.debit)) > 0n);
+				if (!c || c.accountKind !== "system" || c.reason !== "iap.fulfill") throw t("invalid_record");
+				let l = Object.freeze(Object.create(null));
+				se.set(l, {
+					originalTxId: o.txId,
+					debtPolicy: m,
+					assertFresh: a
+				});
+				let d = Z(s, {
+					tenantId: n.scope.tenantId,
+					requestId: u,
+					currency: f,
+					amount: p,
+					from: {
+						kind: "wallet",
+						ownerKind: "player",
+						ownerId: n.scope.ownerId
+					},
+					to: {
+						kind: "system",
+						id: i(c.systemAccount)
+					},
+					reason: "iap.refund",
+					ref: {
+						kind: "iap-order",
+						id: n.orderId
+					}
+				}, l), h = await D.runPromise(D.result(d));
+				if (re.isFailure(h)) throw h.failure;
+				return h.success;
+			})), D.catchDefect(() => D.fail(t("unavailable"))));
+		} catch (e) {
+			return D.fail(N(e));
+		}
+	}, ue = (t, n) => D.flatMap(ce(t, n), (t) => P(async () => (await ie(e, [t]))[0])), de = (n) => {
+		try {
+			let r = structuredClone(n);
+			if (r.type !== "user") throw t("forbidden");
+			let a = i(r.tenantId), s = i(r.id), c = {
+				kind: "wallet",
+				ownerKind: "player",
+				ownerId: s
+			};
+			return P(async () => {
+				let n = (await e.query(M(S).where(A("id", H(a, c))).limit(1).descriptor))[0];
+				if (n?.erased === !0) throw t("erased");
+				if (n && (n.tenantId !== a || n.ownerKind !== "player" || n.ownerId !== s || n.erased !== !1)) throw t("invalid_record");
+				let r = await q(e, w, a, c);
+				return Object.freeze(l.currencies.map((e) => {
+					let n = r.find((t) => t.currency === e.id), i = o(n?.balance ?? "0");
+					if (BigInt(i) < 0n && (e.kind !== "hard" || n?.debtPolicy !== "allowNegative" && n?.debtPolicy !== "blockSpend")) throw t("invalid_record");
+					if (BigInt(i) > BigInt(e.cap)) throw t("conflict");
+					return Object.freeze({
+						currency: e.id,
+						balance: i,
+						updatedAt: n ? F(n.updatedAt) : null
+					});
+				}));
+			});
+		} catch (e) {
+			return D.fail(N(e));
+		}
+	}, Q = (n) => (r, a, c, l) => {
+		try {
+			let u = structuredClone(r), d = i(a), f = g(c), p = V(i(l));
+			if (!B(u)) throw t("forbidden");
+			if (f.kind !== "wallet") throw t("invalid_input");
+			return P(async () => (await U(d, f), await G(d, p), e.transactional(async (e) => {
+				await W(e, d, f), await K(e, d, p.id, p);
+				let r = R(d, f, p.id), a = (await Y(e, d, f)).filter((e) => e.currency === p.id);
+				if (a.some((e) => e.walletKey !== r)) throw t("invalid_record");
+				await z(e, d, [...new Set(a.map((e) => i(e.txId)))], p.id);
+				let c = 0n;
+				for (let e of a) {
+					if (e.accountKind !== "wallet" || e.tenantId !== d || e.ownerId !== f.ownerId || e.ownerKind !== f.ownerKind || e.currency !== p.id) throw t("invalid_record");
+					let n = s(e.debit), r = s(e.credit);
+					if (n === 0n == (r === 0n)) throw t("invalid_record");
+					c += r - n;
+				}
+				let l = a.filter((e) => e.ownerSequence != null).sort((e, t) => Number(e.ownerSequence) - Number(t.ownerSequence));
+				if (l.some((e, t) => !Number.isSafeInteger(e.ownerSequence) || Number(e.ownerSequence) < 1 || t > 0 && Number(e.ownerSequence) <= Number(l[t - 1].ownerSequence) || e.debtPolicy != null && e.debtPolicy !== "allowNegative" && e.debtPolicy !== "blockSpend")) throw t("invalid_record");
+				let u = c < 0n ? l[l.length - 1]?.debtPolicy : null;
+				if (c < 0n && u !== "allowNegative" && u !== "blockSpend") throw t("invalid_record");
+				let m = o(c);
+				if (c < 0n && (p.kind !== "hard" || !a.some((e) => e.reason === "iap.refund" && BigInt(String(e.debit)) > 0n))) throw t("invalid_record");
+				if (c > BigInt(p.cap)) throw t("currency_cap_reached");
+				let h = await J(e, d, f, p.id), g = o(h?.balance ?? "0"), _ = g === m && (h?.debtPolicy ?? null) === (u ?? null);
+				if (n && !_) {
+					let n = I();
+					if (h && F(h.updatedAt) > n) throw t("invalid_record");
+					h ? await e.update(w.tableName, r, {
+						balance: m,
+						debtPolicy: c < 0n ? u : null,
+						updatedAt: new Date(n)
+					}) : await e.insert(w.tableName, {
+						id: r,
+						tenantId: d,
+						ownerId: f.ownerId,
+						ownerKind: f.ownerKind,
+						currency: p.id,
+						balance: m,
+						debtPolicy: u ?? null,
+						updatedAt: new Date(n)
+					});
+				}
+				return Object.freeze({
+					currency: p.id,
+					balance: n ? m : g,
+					ledgerBalance: m,
+					ledgerRows: a.length,
+					matches: n || _
+				});
+			})));
+		} catch (e) {
+			return D.fail(N(e));
+		}
+	}, fe = (n, a) => {
+		try {
+			let o = r(n, [
+				"subjectId",
+				"tenantId",
+				"kind"
+			]);
+			if (o.kind !== "user" && o.kind !== "guest") throw t("invalid_input");
+			let s = i(o.tenantId), c = Object.freeze({
+				kind: "wallet",
+				ownerKind: "player",
+				ownerId: i(o.subjectId)
+			});
+			return P(async () => (await U(s, c), e.transactional(async (e) => {
+				await W(e, s, c, !0);
+				let n = await e.query(M(b).where(A("tenantId", s)).orderBy("id", "asc").limit(l.maxExportRows + 1).descriptor);
+				if (n.length > l.maxExportRows) throw t("limit_exceeded");
+				for (let t of n) await K(e, s, i(t.currency));
+				return (await W(e, s, c, !0)).erased || await Y(e, s, c), a(e, s, c);
+			})));
+		} catch (e) {
+			return D.fail(N(e));
+		}
+	}, pe = (e) => fe(e, async (e, n, r) => {
+		let a = await q(e, w, n, r), s = await q(e, x, n, r), c = [...new Set(s.map((e) => i(e.txId)))], l = [];
+		for (let r = 0; r < c.length; r += 128) {
+			let i = await e.query(M(C).where(k(A("tenantId", n), j("id", c.slice(r, r + 128)))).limit(129).descriptor);
+			if (i.length > 128) throw t("invalid_record");
+			for (let e of i) e.escrow !== null && l.push(e.escrow);
+		}
+		return {
+			...l.length ? { escrows: l } : {},
+			wallets: a.map((e) => ({
+				currency: i(e.currency),
+				balance: o(e.balance),
+				updatedAt: F(e.updatedAt)
+			})),
+			ledger: s.map((e) => ({
+				txId: i(e.txId),
+				currency: i(e.currency),
+				debit: o(e.debit),
+				credit: o(e.credit),
+				reason: i(e.reason),
+				refKind: e.refKind,
+				refId: e.refId,
+				actor: e.actor,
+				at: F(e.at)
+			}))
+		};
+	}), me = (e) => fe(e, async (e, t, n) => {
+		let r = await q(e, x, t, n), a = await q(e, w, t, n), o = [...new Set(r.map((e) => i(e.txId)))], s = await $.taxTransactionIds(e, t, n, o);
+		for (let n of [.../* @__PURE__ */ new Set([...o, ...s])].sort()) await e.updateMany(x.tableName, {
+			refKind: null,
+			refId: null,
+			actor: null
+		}, { where: k(A("tenantId", t), A("txId", n)) }), await e.update(C.tableName, n, {
+			state: "erased",
+			digest: null,
+			receipt: null,
+			escrow: null
+		});
+		for (let t of r) await e.update(x.tableName, String(t.id), {
+			ownerId: null,
+			ownerKind: null,
+			walletKey: null
+		});
+		for (let t of a) await e.delete(w.tableName, String(t.id));
+		await e.update(S.tableName, H(t, n), {
+			ownerId: null,
+			erased: !0
+		});
+	}), $ = T(e, {
+		allowedServices: l.allowedServices,
+		prepareTransfer: (e, t) => Z(e, t, X),
+		readEvidence: z,
+		decodeReceipt: L,
+		ledgerAt: F,
+		seedWallet: U,
+		fenceWallet: W,
+		fenceCurrency: K
+	});
+	return Object.freeze({
+		prepareEscrowReserve: $.prepareEscrowReserve,
+		prepareEscrowRelease: $.prepareEscrowRelease,
+		prepareEscrowSettle: $.prepareEscrowSettle,
+		prepareEscrowTaxSettle: $.prepareEscrowTaxSettle,
+		prepareEscrowReserveTaxSettle: $.prepareEscrowReserveTaxSettle,
+		escrow: $.escrow,
+		transfer: ue,
+		prepareTransfer: ce,
+		prepareIapRefund: le,
+		mine: de,
+		auditWallet: Q(!1),
+		rebuildWallet: Q(!0),
+		exportSubject: pe,
+		eraseSubject: me
+	});
+};
+//#endregion
+export { B as dataStoreEconomy, F as economyLedgerAt, R as economyWalletKey, z as readEconomyTransferEvidence, oe as resolveEconomyStoreOptions };