@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/piggyStore.server.js

@@ -0,0 +1,610 @@
+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 { nonNegativeAmount as o } from "./amount.js";
+import { captureCurrencies as s } from "./currency.js";
+import { defaultPriceResolver as c, priceResolverContext as l, resolvePrice as u } from "./price.js";
+import { captureShopOrderReceipt as d, shopInteger as f, shopPayment as p } from "./shop.js";
+import { defaultPiggyFill as m, defaultPiggyReset as h, definePiggyBank as g, piggyFillIntent as _, piggyUnlockIntent as v, projectPiggyBank as y, resolvePiggyFill as b, resolvePiggyReset as x } from "./piggyBanks.js";
+import { piggyDefinitionsTable as S, piggyEventsTable as C, piggySubjectsTable as w, piggyTenantsTable as T } from "./piggyTables.entity.js";
+import { Effect as E, Result as D } from "effect";
+import { systemSubject as O } from "@voltro/protocol";
+import { createHash as k } from "node:crypto";
+import { and as A, eq as j, queryFor as M } from "@voltro/database";
+import { executeSqlMutations as N, prepareSqlMutation as P, prepareSqlMutationGroup as F } from "@voltro/database/sql";
+// src/piggyStore.server.ts
+var I = (e) => Array.isArray(e) ? "[" + e.map(I).join(",") + "]" : typeof e == "object" && e ? "{" + Object.keys(e).sort().map((t) => JSON.stringify(t) + ":" + I(e[t])).join(",") + "}" : JSON.stringify(e), L = (e) => k("sha256").update(I(e)).digest("hex"), R = (e, ...t) => e + L(t).slice(0, 56), z = (e, t) => L([e, a(t)]), B = (n) => n instanceof e ? n : t("unavailable"), V = (e) => E.tryPromise({
+	try: e,
+	catch: B
+}), H = (n) => {
+	try {
+		return n();
+	} catch (n) {
+		return E.fail(n instanceof e ? n : t("invalid_input"));
+	}
+}, U = async (e) => {
+	let t = await E.runPromise(E.result(e));
+	if (D.isFailure(t)) throw t.failure;
+	return t.success;
+}, W = (e) => f(e, 0, 864e13), G = (e) => W(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN), K = (e) => {
+	if (typeof e != "string" || o(e).toString() !== e) throw t("invalid_record");
+	return e;
+}, ee = (e) => {
+	let t = i(e, [
+		"tenantId",
+		"ownerId",
+		"authorityId",
+		"eventId",
+		"sourceId",
+		"amount",
+		"acceptedAt"
+	], "invalid_record");
+	return Object.freeze({
+		tenantId: a(t.tenantId),
+		ownerId: a(t.ownerId),
+		authorityId: a(t.authorityId),
+		eventId: a(t.eventId),
+		sourceId: a(t.sourceId),
+		amount: K(t.amount),
+		acceptedAt: W(t.acceptedAt)
+	});
+}, q = (e) => {
+	let o = i(e, [
+		"banks",
+		"currencies",
+		"realMoney",
+		"economy",
+		"fillSource",
+		"unlockSource",
+		"version",
+		"fill",
+		"reset",
+		"priceResolver",
+		"systemAccount",
+		"allowedServices",
+		"maxHistoryRows",
+		"now"
+	]), l = s(o.currencies), u = o.realMoney ?? !1;
+	if (typeof u != "boolean") throw t("invalid_input");
+	let d = Object.freeze(r(o.banks, 32).map((e) => g(e, l, u)));
+	if (!d.length || new Set(d.map((e) => e.id)).size !== d.length) throw t("invalid_input");
+	let p = n(o.economy, ["prepareTransfer"]), _ = n(o.fillSource, ["read"]), v = n(o.unlockSource, ["read"]), y = a(o.version), b = o.fill ?? m, x = o.reset ?? h, S = o.priceResolver ?? c, C = o.now ?? Date.now;
+	if (y === "default.v1" || [
+		b,
+		x,
+		S,
+		C
+	].some((e) => typeof e != "function")) throw t("invalid_input");
+	let w = Object.freeze(r(o.allowedServices ?? [], 256).map((e) => a(e)));
+	if (new Set(w).size !== w.length) throw t("invalid_input");
+	return Object.freeze({
+		banks: d,
+		currencies: l,
+		realMoney: u,
+		economy: p,
+		fillSource: _,
+		unlockSource: v,
+		version: y,
+		fill: b,
+		reset: x,
+		priceResolver: S,
+		now: C,
+		allowedServices: w,
+		systemAccount: a(o.systemAccount ?? "piggy"),
+		maxHistoryRows: f(o.maxHistoryRows ?? 1e4, 1, 1e5)
+	});
+}, te = class extends Error {
+	constructor() {
+		super("Original piggy-bank operation replay"), this.name = "PiggyReplay";
+	}
+}, ne = (e, n) => {
+	let r = q(n), o = O("economy.piggy"), c = new Set(r.allowedServices), m = () => W(r.now()), h = (e, t) => R("eps_", e, t), E = (e, t, n) => R("epe_", e, t, n), D = (e) => {
+		let n = structuredClone(e);
+		if (n.type !== "user") throw t("forbidden");
+		return Object.freeze({
+			tenantId: a(n.tenantId),
+			ownerId: a(n.id),
+			subject: n
+		});
+	}, k = (e) => {
+		let n = structuredClone(e);
+		if (n.type !== "system" && (n.type !== "service" || !c.has(n.service))) throw t("forbidden");
+	}, I = async (t, n) => {
+		await e.insertIgnore(T.tableName, {
+			id: R("ept_", t),
+			tenantId: t,
+			admission: 0
+		}, { conflictColumns: ["id"] }), await e.insertIgnore(w.tableName, {
+			id: h(t, n),
+			tenantId: t,
+			ownerId: n,
+			erased: !1,
+			admission: 0,
+			entriesCount: 0
+		}, { conflictColumns: ["id"] });
+	}, B = async (e, n, r, i = !1) => {
+		let a = (await e.query(M(w).where(j("id", h(n, r))).limit(1).descriptor))[0];
+		if (a) {
+			if (a.tenantId !== n || a.admission !== 0 || typeof a.erased != "boolean" || a.ownerId !== (a.erased ? null : r)) throw t("invalid_record");
+			if (f(a.entriesCount, 0, 1e5), a.erased && !i) throw t("erased");
+			return a;
+		}
+	}, ne = async (e, n, r, i = !1) => {
+		let a = R("ept_", n);
+		if (await e.updateMany(T.tableName, { admission: 0 }, { where: j("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(M(T).where(j("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.admission !== 0) throw t("invalid_record");
+		if (await e.updateMany(w.tableName, { admission: 0 }, { where: j("id", h(n, r)) }) !== 1 || !await B(e, n, r, i)) throw t("unavailable");
+	}, J = (e, t) => ({
+		id: R("epd_", e, t.bank.id),
+		tenantId: e,
+		bankId: t.bank.id,
+		definition: t.bank,
+		currencies: t.currencies,
+		realMoney: t.realMoney,
+		rulesVersion: t.rulesVersion
+	}), re = async (e, n, r, i) => {
+		let a = J(n, r), o = (await e.query(M(S).where(j("id", a.id)).limit(1).descriptor))[0];
+		if (o) {
+			if (L(o) !== L(a)) throw t("conflict");
+		} else i && await e.insert(S.tableName, a);
+	}, Y = async (e, n, r, o) => {
+		if (o.tenantId !== n || o.ownerId !== r || o.ownerKey !== h(n, r) || o.state !== "fulfilled") throw t("invalid_record");
+		let c = i(o.body, [
+			"kind",
+			"request",
+			"bank",
+			"currencies",
+			"realMoney",
+			"rulesVersion",
+			"evidence",
+			"event",
+			"receipt",
+			"price",
+			"adjustments"
+		], "invalid_record");
+		if (c.kind !== "fill" && c.kind !== "unlock" || typeof c.realMoney != "boolean") throw t("invalid_record");
+		let m = c.kind, v = i(c.request, m === "fill" ? [
+			"tenantId",
+			"ownerId",
+			"bankId",
+			"sourceId",
+			"eventId",
+			"requestId"
+		] : [
+			"tenantId",
+			"ownerId",
+			"bankId",
+			"bankVersion",
+			"bankDigest",
+			"requestId",
+			"currency"
+		], "invalid_record"), y = s(c.currencies), b = g(c.bank, y, c.realMoney), x = a(c.rulesVersion), C = i(c.event, m === "fill" ? [
+			"id",
+			"sequence",
+			"kind",
+			"at",
+			"authorityId",
+			"eventId",
+			"sourceId",
+			"acceptedAmount",
+			"delta"
+		] : [
+			"id",
+			"sequence",
+			"kind",
+			"at",
+			"amount",
+			"remaining"
+		], "invalid_record"), w = Object.freeze({
+			...C,
+			at: W(C.at),
+			sequence: f(C.sequence, 1, 1e5)
+		}), T = i(c.receipt, m === "fill" ? [
+			"operationId",
+			"requestId",
+			"bankId",
+			"event",
+			"available"
+		] : [
+			"operationId",
+			"requestId",
+			"bankId",
+			"event",
+			"available",
+			"value"
+		], "invalid_record"), D = K(T.available);
+		if (v.tenantId !== n || v.ownerId !== r || v.bankId !== b.id || o.bankId !== b.id || o.id !== E(n, r, a(v.requestId)) || o.digest !== L([m, v]) || w.id !== o.id || w.kind !== m || G(o.createdAt) !== w.at || T.operationId !== w.id || T.requestId !== v.requestId || T.bankId !== b.id || L(T.event) !== L(w) || x === "default.v1") throw t("invalid_record");
+		let O = {
+			bank: b,
+			currencies: y,
+			realMoney: c.realMoney,
+			rulesVersion: x
+		}, k = (await e.query(M(S).where(j("id", J(n, O).id)).limit(1).descriptor))[0];
+		if (!k || L(k) !== L(J(n, O))) throw t("invalid_record");
+		let A = null, N = null, P = [], F;
+		if (m === "fill") {
+			let e = _({
+				tenantId: a(v.tenantId),
+				ownerId: a(v.ownerId),
+				bankId: a(v.bankId),
+				sourceId: a(v.sourceId),
+				eventId: a(v.eventId),
+				requestId: a(v.requestId)
+			}), i = w, s = ee(c.evidence);
+			if (!b.fillFrom.includes(e.sourceId) || s.tenantId !== n || s.ownerId !== r || s.eventId !== e.eventId || s.sourceId !== e.sourceId || s.acceptedAt > w.at || i.authorityId !== s.authorityId || i.eventId !== s.eventId || i.sourceId !== s.sourceId || i.acceptedAmount !== s.amount || o.eventKey !== L([
+				n,
+				b.id,
+				s.authorityId,
+				s.eventId
+			]) || c.price !== null || !Array.isArray(c.adjustments) || c.adjustments.length) throw t("invalid_record");
+			A = s, F = Object.freeze({
+				operationId: w.id,
+				requestId: e.requestId,
+				bankId: b.id,
+				event: i,
+				available: D
+			});
+		} else {
+			let e = d(T.value), r = w, i = l(b.unlock, y, c.realMoney, c.adjustments);
+			N = u(i, () => c.price), P = i.adjustments;
+			let s = p(N, v.currency === null ? null : a(v.currency), 1);
+			if (c.evidence !== null || o.eventKey !== null || v.bankVersion !== b.version || v.bankDigest !== z(b, x) || e.orderId !== w.id || e.offerId !== b.id || e.offerVersion !== b.version || e.offerDigest !== v.bankDigest || e.quantity !== 1 || e.at !== w.at || L(e.pricePaid) !== L(s) || e.grants.length || D !== r.remaining) throw t("invalid_record");
+			let f = [...s.kind === "virtual" && BigInt(s.amount) > 0n ? [{
+				currency: s.currency,
+				amount: s.amount
+			}] : [], {
+				currency: b.currency,
+				amount: K(r.amount)
+			}];
+			if (e.transfers.length !== f.length) throw t("invalid_record");
+			for (let [r, i] of e.transfers.entries()) if (i.currency !== f[r].currency || i.amount !== f[r].amount || i.txId !== R("ect_", n, R("epr_", w.id, "transfer", String(r))) || i.at > w.at) throw t("invalid_record");
+			F = Object.freeze({
+				operationId: w.id,
+				requestId: a(v.requestId),
+				bankId: b.id,
+				event: r,
+				available: D,
+				value: e
+			});
+		}
+		return Object.freeze({
+			kind: m,
+			request: v,
+			...O,
+			evidence: A,
+			event: w,
+			receipt: F,
+			price: N,
+			adjustments: P
+		});
+	}, X = async (e, n, i) => {
+		let a = await B(e, n, i), o = await e.query(M(C).where(A(j("tenantId", n), j("ownerKey", h(n, i)))).limit(r.maxHistoryRows + 1).descriptor);
+		if (o.length > r.maxHistoryRows) throw t("limit_exceeded");
+		if (o.length !== (a?.entriesCount ?? 0)) throw t("invalid_record");
+		o.sort((e, t) => Number(e.sequence) - Number(t.sequence));
+		let s = [], c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+		for (let [r, a] of o.entries()) {
+			if (a.sequence !== r + 1) throw t("invalid_record");
+			let o = await Y(e, n, i, a), l = c.get(o.bank.id) ?? [];
+			if (o.event.at < (s.at(-1)?.event.at ?? 0) || l.length && L(l[0].bank) !== L(o.bank)) throw t("invalid_record");
+			l.push(o), c.set(o.bank.id, l), s.push(o);
+		}
+		for (let [e, n] of c) {
+			let r = y(n[0].bank, n.map((e) => e.event));
+			l.set(e, r);
+			let i = 0n;
+			for (let e of n) if (i = e.event.kind === "fill" ? i + BigInt(e.event.delta) : BigInt(e.event.remaining), e.receipt.available !== i.toString()) throw t("invalid_record");
+		}
+		if ((await B(e, n, i))?.entriesCount !== a?.entriesCount) throw t("conflict");
+		return Object.freeze({
+			accepted: s,
+			groups: c,
+			projections: l,
+			count: o.length
+		});
+	}, Z = async (e, n, r, i, a, o) => {
+		let s = (await X(e, n, r)).accepted.find((e) => e.event.id === i);
+		if (s && a && (s.kind !== a || L(s.request) !== L(o))) throw t("conflict");
+		return s?.receipt;
+	}, Q = (n, s, c) => V(async () => {
+		let { tenantId: f, ownerId: g } = n, v = E(f, g, a(c.requestId)), S = await e.transactional((e) => Z(e, f, g, v, s, c));
+		if (S) return S;
+		await I(f, g);
+		let T = await e.transactional((e) => X(e, f, g));
+		if (T.count >= r.maxHistoryRows) throw t("limit_exceeded");
+		let D = r.banks.find((e) => e.id === c.bankId);
+		if (!D) throw t("not_found");
+		let O = T.groups.get(D.id) ?? [], k = T.projections.get(D.id)?.available ?? "0", B = m();
+		if (B < (T.accepted.at(-1)?.event.at ?? 0)) throw t("invalid_record");
+		let V = {
+			bank: D,
+			currencies: r.currencies,
+			realMoney: r.realMoney,
+			rulesVersion: r.version
+		};
+		await e.transactional((e) => re(e, f, V, !1));
+		let H = null, W = null, G = [], K = Object.freeze({ kind: "free" }), q, J = {
+			bank: D,
+			currencies: r.currencies,
+			realMoney: r.realMoney,
+			available: k,
+			rulesVersion: r.version
+		};
+		if (s === "fill") {
+			let e = _({
+				tenantId: f,
+				ownerId: g,
+				bankId: D.id,
+				sourceId: a(c.sourceId),
+				eventId: a(c.eventId),
+				requestId: a(c.requestId)
+			});
+			if (!D.fillFrom.includes(e.sourceId)) throw t("forbidden");
+			if (H = ee(await U(r.fillSource.read(Object.freeze({
+				tenantId: f,
+				ownerId: g,
+				bank: D,
+				sourceId: e.sourceId,
+				eventId: e.eventId
+			})))), H.tenantId !== f || H.ownerId !== g || H.sourceId !== e.sourceId || H.eventId !== e.eventId || H.acceptedAt > B) throw t("invalid_record");
+			let n = H;
+			if (O.some((e) => e.event.kind === "fill" && e.event.authorityId === n.authorityId && e.event.eventId === n.eventId)) throw t("conflict");
+			q = Object.freeze({
+				id: v,
+				sequence: O.length + 1,
+				kind: "fill",
+				at: B,
+				authorityId: H.authorityId,
+				eventId: H.eventId,
+				sourceId: H.sourceId,
+				acceptedAmount: H.amount,
+				delta: b({
+					...J,
+					acceptedAmount: H.amount
+				}, r.fill)
+			});
+		} else {
+			if (c.bankVersion !== D.version || c.bankDigest !== z(D, r.version)) throw t("conflict");
+			if (k === "0") throw t("limit_exceeded");
+			let e = i(await U(r.unlockSource.read(Object.freeze({
+				subject: n.subject,
+				bank: D,
+				at: B
+			}))), ["eligible", "adjustments"]);
+			if (typeof e.eligible != "boolean") throw t("invalid_input");
+			if (!e.eligible) throw t("forbidden");
+			let o = l(D.unlock, r.currencies, r.realMoney, e.adjustments);
+			W = u(o, r.priceResolver), G = o.adjustments, K = p(W, c.currency === null ? null : a(c.currency), 1);
+			let s = x(J, r.reset);
+			q = Object.freeze({
+				id: v,
+				sequence: O.length + 1,
+				kind: "unlock",
+				at: B,
+				...s
+			});
+		}
+		let Y = H ? L([
+			f,
+			D.id,
+			H.authorityId,
+			H.eventId
+		]) : null, Q = [P(e, async (e) => {
+			if (await ne(e, f, g), await Z(e, f, g, v, s, c)) throw new te();
+			if ((await X(e, f, g)).count !== T.count || Y && (await e.query(M(C).where(A(j("tenantId", f), j("eventKey", Y))).limit(1).descriptor)).length) throw t("conflict");
+			return await re(e, f, V, !0), null;
+		})], ie = q.kind === "unlock" ? [...K.kind === "virtual" && BigInt(K.amount) > 0n ? [{
+			currency: K.currency,
+			amount: K.amount,
+			from: {
+				kind: "wallet",
+				ownerKind: "player",
+				ownerId: g
+			},
+			to: {
+				kind: "system",
+				id: r.systemAccount
+			}
+		}] : [], {
+			currency: D.currency,
+			amount: q.amount,
+			from: {
+				kind: "system",
+				id: r.systemAccount
+			},
+			to: {
+				kind: "wallet",
+				ownerKind: "player",
+				ownerId: g
+			}
+		}] : [];
+		for (let [e, t] of ie.entries()) Q.push(await U(r.economy.prepareTransfer(o, {
+			tenantId: f,
+			requestId: R("epr_", v, "transfer", String(e)),
+			...t,
+			reason: "piggy.unlock",
+			ref: {
+				kind: "piggy",
+				id: v
+			}
+		})));
+		let $ = s === "fill" ? B : m();
+		if ($ < B) throw t("conflict");
+		q = Object.freeze({
+			...q,
+			at: $
+		});
+		let ae = y(D, [...O.map((e) => e.event), q]), oe = F(e, Q, async (e, n) => {
+			let i = {
+				operationId: v,
+				requestId: a(c.requestId),
+				bankId: D.id,
+				available: ae.available
+			}, o = q.kind === "fill" ? Object.freeze({
+				...i,
+				event: q
+			}) : Object.freeze({
+				...i,
+				event: q,
+				value: d({
+					orderId: v,
+					offerId: D.id,
+					offerVersion: D.version,
+					offerDigest: z(D, r.version),
+					quantity: 1,
+					at: $,
+					pricePaid: K,
+					transfers: n.slice(1),
+					grants: []
+				})
+			}), l = Object.freeze({
+				kind: s,
+				request: c,
+				...V,
+				evidence: H,
+				event: q,
+				receipt: o,
+				price: W,
+				adjustments: G
+			});
+			await e.insert(C.tableName, {
+				id: v,
+				tenantId: f,
+				ownerId: g,
+				ownerKey: h(f, g),
+				bankId: D.id,
+				sequence: T.count + 1,
+				state: "fulfilled",
+				eventKey: Y,
+				digest: L([s, c]),
+				body: l,
+				createdAt: new Date($)
+			}), await e.update(w.tableName, h(f, g), { entriesCount: T.count + 1 });
+			let u = (await X(e, f, g)).accepted.find((e) => e.event.id === v);
+			if (!u) throw t("invalid_record");
+			return u.receipt;
+		});
+		try {
+			return (await N(e, [oe]))[0];
+		} catch (t) {
+			if (t instanceof te) {
+				let t = await e.transactional((e) => Z(e, f, g, v, s, c));
+				if (t) return t;
+			}
+			throw t;
+		}
+	}), ie = (t) => H(() => {
+		let n = D(t);
+		return V(() => e.transactional(async (e) => {
+			let t = await X(e, n.tenantId, n.ownerId), i = [];
+			for (let a of r.banks) {
+				await re(e, n.tenantId, {
+					bank: a,
+					currencies: r.currencies,
+					realMoney: r.realMoney,
+					rulesVersion: r.version
+				}, !1);
+				let o = t.projections.get(a.id);
+				i.push(Object.freeze({
+					bank: a,
+					bankDigest: z(a, r.version),
+					available: o?.available ?? "0",
+					cycles: o?.cycles ?? 0
+				}));
+			}
+			return Object.freeze(i);
+		}));
+	}), $ = (e, t) => H(() => {
+		k(e);
+		let n = _(t);
+		return Q(n, "fill", { ...n });
+	}), ae = (e, t) => H(() => {
+		let n = D(e), r = v(t);
+		return Q(n, "unlock", Object.freeze({
+			tenantId: n.tenantId,
+			ownerId: n.ownerId,
+			...r
+		}));
+	}), oe = (t, n) => H(() => {
+		let r = D(t), o = i(n, ["requestId"]), s = a(o.requestId);
+		return V(() => e.transactional(async (e) => {
+			let t = await Z(e, r.tenantId, r.ownerId, E(r.tenantId, r.ownerId, s));
+			return Object.freeze(t ? {
+				requestId: s,
+				state: "fulfilled",
+				receipt: t
+			} : {
+				requestId: s,
+				state: "not-observed"
+			});
+		}));
+	}), se = (t, n) => H(() => {
+		k(t);
+		let r = i(n, [
+			"tenantId",
+			"ownerId",
+			"bankId"
+		]), o = a(r.tenantId), s = a(r.ownerId), c = a(r.bankId);
+		return V(() => e.transactional(async (e) => (await X(e, o, s)).projections.get(c) ?? Object.freeze({
+			events: [],
+			available: "0",
+			cycles: 0
+		})));
+	}), ce = (e) => {
+		let n = i(e, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (n.kind !== "guest" && n.kind !== "user") throw t("forbidden");
+		return {
+			tenant: a(n.tenantId),
+			owner: a(n.subjectId)
+		};
+	};
+	return Object.freeze({
+		list: ie,
+		fill: $,
+		unlock: ae,
+		receipt: oe,
+		rebuild: se,
+		exportSubject: (t) => H(() => {
+			let n = ce(t);
+			return V(() => e.transactional(async (e) => {
+				if ((await B(e, n.tenant, n.owner, !0))?.erased) return Object.freeze({ piggyBanks: [] });
+				let t = await X(e, n.tenant, n.owner);
+				return Object.freeze({ piggyBanks: Object.freeze(t.accepted.map((e) => Object.freeze({
+					bank: e.bank,
+					evidence: e.evidence,
+					receipt: e.receipt
+				}))) });
+			}));
+		}),
+		eraseSubject: (n) => H(() => {
+			let i = ce(n);
+			return V(async () => {
+				await I(i.tenant, i.owner), await e.transactional(async (e) => {
+					await ne(e, i.tenant, i.owner, !0);
+					let n = await B(e, i.tenant, i.owner, !0), a = await e.query(M(C).where(A(j("tenantId", i.tenant), j("ownerKey", h(i.tenant, i.owner)))).limit(r.maxHistoryRows + 1).descriptor);
+					if (a.length > r.maxHistoryRows) throw t("limit_exceeded");
+					if (a.length !== n?.entriesCount) throw t("invalid_record");
+					a.sort((e, t) => Number(e.sequence) - Number(t.sequence));
+					for (let [n, r] of a.entries()) {
+						if (!/^epe_[a-f0-9]{56}$/.test(String(r.id)) || r.sequence !== n + 1 || r.ownerId !== i.owner && r.ownerId !== null || r.state !== "fulfilled" && r.state !== "erased" || r.eventKey !== null && !/^[a-f0-9]{64}$/.test(String(r.eventKey))) throw t("invalid_record");
+						await e.update(C.tableName, String(r.id), {
+							ownerId: null,
+							state: "erased",
+							digest: null,
+							body: null
+						});
+					}
+					await e.update(w.tableName, h(i.tenant, i.owner), {
+						ownerId: null,
+						erased: !0
+					});
+				});
+			});
+		})
+	});
+};
+export { ne as dataStorePiggyBanks, z as piggyBankDigest, q as resolvePiggyStoreOptions };

package/dist/piggyStore.testFixtures.js

@@ -0,0 +1,97 @@
+import { economyTables as e } from "./tables.entity.js";
+import { dataStoreEconomy as t } from "./walletStore.js";
+import { piggyTables as n } from "./piggyTables.entity.js";
+import { dataStorePiggyBanks as r } from "./piggyStore.server.js";
+import { shopAt as i, shopMachine as a, shopUser as o } from "./shop.testFixtures.js";
+import { Effect as s } from "effect";
+import { ensureTableRegistered as c } from "@voltro/database";
+// src/piggyStore.testFixtures.ts
+var l = async (l, u = "tenant", d = {}, f = "1000") => {
+	[...e, ...n].forEach(c);
+	let p = [{
+		id: "test.gold",
+		kind: "soft",
+		cap: f
+	}], m = t(l, {
+		currencies: p,
+		now: () => i
+	}), h = o("a", u);
+	await s.runPromise(m.transfer(a, {
+		tenantId: u,
+		requestId: "fund",
+		currency: "test.gold",
+		amount: "100",
+		from: {
+			kind: "system",
+			id: "fixture"
+		},
+		to: {
+			kind: "wallet",
+			ownerKind: "player",
+			ownerId: "a"
+		},
+		reason: "fixture",
+		ref: {
+			kind: "fixture",
+			id: "fund"
+		}
+	}));
+	let g = i, _ = {
+		currencies: p,
+		economy: m,
+		banks: [{
+			id: "piggy",
+			titleKey: "test.piggy",
+			currency: "test.gold",
+			cap: "20",
+			unlock: {
+				kind: "virtual",
+				options: [{
+					currency: "test.gold",
+					amount: "5"
+				}]
+			},
+			fillFrom: ["match.reward"]
+		}],
+		fillSource: { read: (e) => s.succeed({
+			tenantId: e.tenantId,
+			ownerId: e.ownerId,
+			authorityId: "fixture.match.rewards",
+			eventId: e.eventId,
+			sourceId: e.sourceId,
+			amount: "13",
+			acceptedAt: g
+		}) },
+		unlockSource: { read: () => s.succeed({
+			eligible: !0,
+			adjustments: []
+		}) },
+		version: "fixture.piggy.v1",
+		now: () => g,
+		...d
+	};
+	return {
+		economy: m,
+		user: h,
+		options: _,
+		service: r(l, _),
+		fill: (e, t = e) => ({
+			tenantId: u,
+			ownerId: "a",
+			bankId: "piggy",
+			sourceId: "match.reward",
+			eventId: e,
+			requestId: t
+		}),
+		setAt: (e) => {
+			g = e;
+		}
+	};
+}, u = (e, t = "unlock") => ({
+	bankId: e.bank.id,
+	bankVersion: e.bank.version,
+	bankDigest: e.bankDigest,
+	requestId: t,
+	currency: e.bank.unlock.kind === "virtual" ? e.bank.unlock.options[0].currency : void 0
+});
+export { u as piggyFixtureUnlock, l as piggyStoreFixture };