@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/tradeStore.server.js

@@ -0,0 +1,750 @@
+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 { shopInteger as s } from "./shop.js";
+import { canonicalDataJson as c } from "./canonicalDataJson.js";
+import { captureTradeParticipantAuthority as l, captureTradeProposeIntention as u, captureTradeReceipt as d, defaultTradeEligibilityPolicy as f, defaultTradeTaxPolicy as p, defineTradeRules as m, resolveTradeEligibility as h, resolveTradeTax as g, tradeAcceptIntent as _, tradeCancelIntent as v, tradeProposeIntent as ee } from "./trades.js";
+import { captureTradeExpiryInput as te } from "./tradeExpiry.server.js";
+import { tradeEscrowParticipant as ne } from "./tradeEscrow.server.js";
+import { tradeOperationsTable as y, tradeSubjectsTable as b, tradeTenantsTable as x, tradesTable as S } from "./tradeTables.entity.js";
+import { Effect as C, Result as w } from "effect";
+import { systemSubject as re } from "@voltro/protocol";
+import { createHash as ie } from "node:crypto";
+import { and as T, eq as E, queryFor as D } from "@voltro/database";
+import { executeSqlMutations as ae, prepareSqlMutation as oe, prepareSqlMutationGroup as O } from "@voltro/database/sql";
+import { InventoryError as se } from "@voltro/plugin-inventory/errors";
+import { SanctionsError as k } from "@voltro/plugin-sanctions/errors";
+//#region src/tradeStore.server.ts
+var ce = (e) => {
+	let c = i(e, [
+		"currencies",
+		"rules",
+		"taxPolicy",
+		"economy",
+		"inventory",
+		"allowedServices",
+		"authority",
+		"eligibility",
+		"maxHistoryRows",
+		"now"
+	]), l = c.now ?? Date.now, u = c.eligibility ?? f, d = c.taxPolicy ?? p;
+	if (typeof l != "function" || typeof u != "function" || typeof d != "function") throw t("invalid_input");
+	let h = Object.freeze(r(c.allowedServices ?? [], 256).map((e) => a(e)));
+	if (new Set(h).size !== h.length) throw t("invalid_input");
+	return Object.freeze({
+		currencies: o(c.currencies),
+		rules: m(c.rules),
+		authority: n(c.authority, ["read", "prepare"]),
+		economy: n(c.economy, [
+			"prepareEscrowReserve",
+			"prepareEscrowRelease",
+			"prepareEscrowTaxSettle",
+			"prepareEscrowReserveTaxSettle",
+			"escrow"
+		]),
+		inventory: c.inventory === void 0 ? void 0 : n(c.inventory, [
+			"prepareReserve",
+			"prepareRelease",
+			"prepareReservationTransfer",
+			"prepareReserveTransfer",
+			"reservation",
+			"reservationEvidence"
+		]),
+		now: l,
+		eligibility: u,
+		taxPolicy: d,
+		allowedServices: h,
+		maxHistoryRows: s(c.maxHistoryRows ?? 1e4, 1, 1e5)
+	});
+}, A = (e) => ie("sha256").update(c(e)).digest("hex"), j = (e, ...t) => e + A(t).slice(0, 56), M = (e) => s(e, 0, 864e13), N = (e) => M(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN), P = (e, t) => c(e) === c(t), F = (n) => n instanceof k ? t(n.code === "forbidden" || n.code === "identity_required" ? "forbidden" : n.code === "conflict" ? "conflict" : "unavailable") : n instanceof e ? n : n instanceof se && [
+	"invalid_input",
+	"invalid_record",
+	"not_found",
+	"erased",
+	"forbidden",
+	"conflict",
+	"limit_exceeded"
+].includes(n.code) ? t(n.code) : t("unavailable"), I = async (e) => {
+	let t = await C.runPromise(C.result(e));
+	if (w.isFailure(t)) throw t.failure;
+	return t.success;
+}, L = (e) => C.tryPromise({
+	try: e,
+	catch: F
+}), R = (e) => {
+	try {
+		return e();
+	} catch (e) {
+		return C.fail(F(e));
+	}
+}, z = class extends Error {
+	constructor() {
+		super("Original Trade operation won admission"), this.name = "TradeReplay";
+	}
+}, B = (e, c) => {
+	let f = ce(c), p = f.currencies, C = f.rules, w = f.authority, ie = f.now, se = f.eligibility, k = f.maxHistoryRows, F = new Set(f.allowedServices), B = re("economy.trades"), V = {
+		currencies: p,
+		rules: C,
+		economy: f.economy,
+		inventory: f.inventory,
+		taxPolicy: f.taxPolicy,
+		allowedServices: [...F]
+	}, le = ne(e, V), ue = n(V.economy, ["escrow"]), de = f.inventory === void 0 ? void 0 : n(f.inventory, ["reservationEvidence"]), H = () => M(ie()), U = (e, t) => j("ets_", e, t), W = (e) => j("ett_", e), G = (e, t, n) => j("eto_", e, t, n), fe = (e, t, n) => j("etd_", e, t, n), K = (e) => {
+		let n = structuredClone(e);
+		if (n.type !== "user") throw t("forbidden");
+		return Object.freeze({
+			tenant: a(n.tenantId),
+			owner: a(n.id),
+			subject: n
+		});
+	}, q = (e) => {
+		let n = structuredClone(e);
+		if (n.type !== "system" && (n.type !== "service" || !F.has(n.service))) throw t("forbidden");
+	}, pe = async (t, n) => {
+		await e.insertIgnore(x.tableName, {
+			id: W(t),
+			tenantId: t,
+			admission: 0,
+			tradesCount: 0
+		}, { conflictColumns: ["id"] }), await e.insertIgnore(b.tableName, {
+			id: U(t, n),
+			tenantId: t,
+			ownerId: n,
+			erased: !1,
+			admission: 0,
+			operationsCount: 0
+		}, { conflictColumns: ["id"] });
+	}, me = async (e, n, r, i = !1) => {
+		let a = (await e.query(D(b).where(E("id", U(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 (s(a.operationsCount, 0, k), a.erased && !i) throw t("erased");
+			return a;
+		}
+	}, J = async (e, n, r, i = !1) => {
+		if (await e.updateMany(x.tableName, { admission: 0 }, { where: E("id", W(n)) }) !== 1) throw t("unavailable");
+		for (let a of [...new Set(r)].sort()) if (await e.updateMany(b.tableName, { admission: 0 }, { where: E("id", U(n, a)) }) !== 1 || !await me(e, n, a, i)) throw t("unavailable");
+	}, Y = async (e, n, r, i = !1) => {
+		let o = await me(e, n, r, i), s = await e.query(D(y).where(T(E("tenantId", n), E("ownerKey", U(n, r)))).limit(k + 1).descriptor);
+		if (s.length > k) throw t("limit_exceeded");
+		if (s.length > 0 && !o) throw t("invalid_record");
+		for (let e of s) {
+			if (e.tenantId !== n || e.ownerKey !== U(n, r) || e.ownerId !== (o?.erased ? null : r) || e.admission !== 0 || typeof e.id != "string" || !/^eto_[a-f0-9]{56}$/.test(e.id) || ![
+				"propose",
+				"accept",
+				"cancel",
+				"expire"
+			].includes(String(e.kind)) || ![
+				"pending",
+				"fulfilled",
+				"erased"
+			].includes(String(e.state)) || (a(e.tradeId), e.sequence === null && (e.state !== "pending" && e.state !== "erased" || e.receipt !== null || e.request !== null || e.digest !== null || e.at !== null))) throw t("invalid_record");
+			if (e.state === "fulfilled") {
+				let i = e.kind === "propose" ? u(e.request) : e.kind === "accept" ? _(e.request) : v(e.request), a = d(e.receipt);
+				if (!P(a, e.receipt) || !P(i, e.request) || e.id !== G(n, r, i.requestId) || e.digest !== A([e.kind, i]) || a.operationId !== e.id || a.requestId !== i.requestId || a.trade.tradeId !== e.tradeId || e.kind === "propose" && (a.trade.state !== "proposed" || a.trade.proposerId !== r || e.tradeId !== fe(n, r, i.requestId)) || e.kind === "accept" && (a.trade.state !== "accepted" || a.trade.accepterId !== r) || e.kind === "cancel" && (a.trade.state !== "cancelled" || a.trade.proposerId !== r) || e.kind === "expire" && (a.trade.state !== "expired" || a.trade.proposerId !== r)) throw t("invalid_record");
+				M(N(e.at));
+			}
+		}
+		let c = s.filter((e) => e.sequence !== null).sort((e, t) => Number(e.sequence) - Number(t.sequence));
+		if (c.length !== (o?.operationsCount ?? 0)) throw t("invalid_record");
+		for (let [e, n] of c.entries()) if (n.sequence !== e + 1 || n.state !== "fulfilled" && n.state !== "erased" || n.state === "erased" && (n.receipt !== null || n.request !== null || n.digest !== null || n.at !== null)) throw t("invalid_record");
+		return {
+			parent: o,
+			rows: s
+		};
+	}, X = async (e, n) => {
+		let r = (await e.query(D(x).where(E("id", W(n))).limit(1).descriptor))[0], i = await e.query(D(S).where(E("tenantId", n)).limit(k + 1).descriptor);
+		if (i.length > k) throw t("limit_exceeded");
+		if (i.length > 0 && !r || r && (r.tenantId !== n || r.admission !== 0) || i.some((e) => typeof e.accepted != "boolean") || i.filter((e) => e.accepted === !0).length !== (r ? s(r.tradesCount, 0, k) : 0)) throw t("invalid_record");
+		for (let e of i) if (e.accepted === !1 && (e.state !== "pending" && e.state !== "erased" || e.proposal !== null || e.digest !== null || e.closing !== null || e.createdAt !== null || e.expiresAt !== null)) throw t("invalid_record");
+		return {
+			parent: r,
+			rows: i
+		};
+	}, he = (e) => A({
+		tenantId: e.tenantId,
+		proposerId: e.proposerId,
+		intent: e.intent,
+		currencies: e.currencies,
+		rules: e.rules,
+		createdAt: e.createdAt,
+		expiresAt: e.expiresAt,
+		taxes: e.taxes
+	}), Z = (e, t, n) => Object.freeze({
+		tradeId: e,
+		tradeDigest: he(t),
+		proposerId: t.proposerId,
+		toId: t.intent.toId,
+		offered: t.intent.offered,
+		requested: t.intent.requested,
+		createdAt: t.createdAt,
+		expiresAt: t.expiresAt,
+		accepterId: n?.kind === "accept" ? n.ownerId : null,
+		rulesVersion: t.rules.version,
+		taxes: Object.freeze(t.taxes.map((e, n) => Object.freeze({
+			leg: n < t.intent.offered.currencies.length ? "offered" : "requested",
+			...e
+		}))),
+		state: n?.kind === "accept" ? "accepted" : n?.kind === "cancel" ? "cancelled" : n ? "expired" : "proposed"
+	}), ge = (e) => {
+		let n = i(e.proposal, [
+			"tenantId",
+			"proposerId",
+			"intent",
+			"currencies",
+			"rules",
+			"createdAt",
+			"expiresAt",
+			"taxes",
+			"held"
+		], "invalid_record"), s = o(n.currencies), c = m(n.rules), l = ee(n.intent, s, c), u = a(n.tenantId), d = a(n.proposerId), f = M(n.createdAt), p = M(n.expiresAt), h = r(n.taxes, 64).map((e) => {
+			let n = i(e, [
+				"currency",
+				"gross",
+				"net",
+				"tax"
+			], "invalid_record"), r = g({
+				currency: a(n.currency),
+				amount: n.gross,
+				rules: c
+			}, () => n.tax);
+			if (!P(r, n)) throw t("invalid_record");
+			return r;
+		}), _ = [...l.offered.currencies, ...l.requested.currencies].map((e) => [e.currency, e.amount]);
+		if (h.length !== _.length || h.some((e, t) => e.currency !== _[t][0] || e.gross !== _[t][1]) || p !== f + l.durationMs || l.toId === d || e.tenantId !== u || e.id !== fe(u, d, l.requestId) || e.proposerKey !== U(u, d) || e.targetKey !== (l.toId === null ? null : U(u, l.toId)) || N(e.createdAt) !== f || N(e.expiresAt) !== p) throw t("invalid_record");
+		let v = Object.freeze({
+			tenantId: u,
+			proposerId: d,
+			intent: l,
+			currencies: s,
+			rules: c,
+			createdAt: f,
+			expiresAt: p,
+			taxes: Object.freeze(h),
+			held: n.held
+		});
+		if (e.digest !== he(v)) throw t("invalid_record");
+		return v;
+	}, Q = async (e, n, r, o = !1, s) => {
+		let c = (s ?? await X(e, n)).rows.find((e) => e.id === r);
+		if (!c || c.accepted === !1 && c.state === "pending") throw t("not_found");
+		if (c.state === "erased") throw c.proposal !== null || c.closing !== null || c.digest !== null ? t("invalid_record") : t("erased");
+		if (c.accepted !== !0) throw t("invalid_record");
+		let l = ge(c), u = G(n, l.proposerId, l.intent.requestId), d = null;
+		if (c.closing !== null) {
+			let e = i(c.closing, [
+				"ownerId",
+				"kind",
+				"request",
+				"at",
+				"value"
+			], "invalid_record"), n = a(e.ownerId), o = M(e.at);
+			if (e.kind !== "accept" && e.kind !== "cancel" && e.kind !== "expire" || o < l.createdAt) throw t("invalid_record");
+			let s = e.kind === "accept" ? _(e.request) : v(e.request);
+			if (s.tradeId !== r || e.kind === "accept" && (s.tradeDigest !== c.digest || n === l.proposerId || l.intent.toId !== null && l.intent.toId !== n || o >= l.expiresAt) || e.kind !== "accept" && n !== l.proposerId || e.kind === "expire" && o < l.expiresAt) throw t("invalid_record");
+			d = Object.freeze({
+				ownerId: n,
+				kind: e.kind,
+				request: s,
+				at: o,
+				value: e.value
+			});
+		}
+		let f = Z(r, l, d), p = d?.kind === "accept" ? U(n, d.ownerId) : null;
+		if (c.accepterKey !== p || !o && c.state !== f.state) throw t("invalid_record");
+		let m = await e.query(D(y).where(T(E("tenantId", n), E("tradeId", r))).limit(k + 1).descriptor);
+		if (m.length > k) throw t("limit_exceeded");
+		let h = m.filter((e) => e.sequence !== null);
+		if (h.length !== (d ? 2 : 1)) throw t("invalid_record");
+		let g = (e, r, a, o, s, c) => {
+			if (!e || e.state !== "fulfilled" || e.kind !== a || e.ownerId !== r || e.ownerKey !== U(n, r) || e.digest !== A([a, o]) || !P(e.request, o) || N(e.at) !== c || !P(e.receipt, {
+				operationId: e.id,
+				requestId: i(o, a === "propose" ? [
+					"toId",
+					"offered",
+					"requested",
+					"durationMs",
+					"requestId"
+				] : a === "accept" ? [
+					"tradeId",
+					"tradeDigest",
+					"requestId"
+				] : ["tradeId", "requestId"]).requestId,
+				trade: s
+			})) throw t("invalid_record");
+		};
+		return g(h.find((e) => e.id === u), l.proposerId, "propose", l.intent, Z(r, l, null), l.createdAt), d && g(h.find((e) => e.id === G(n, d.ownerId, d.request.requestId)), d.ownerId, d.kind, d.request, f, d.at), {
+			row: c,
+			proposal: l,
+			closing: d,
+			view: f
+		};
+	}, _e = (n) => ne(e, {
+		...V,
+		currencies: n.currencies,
+		rules: n.rules,
+		taxPolicy: (e) => {
+			let r = n.taxes.filter((t) => t.currency === e.currency && t.gross === String(e.amount));
+			if (!r.length || r.some((e) => e.tax !== r[0].tax)) throw t("invalid_record");
+			return r[0].tax;
+		}
+	}), ve = (e) => ({
+		tenantId: e.proposal.tenantId,
+		tradeId: e.view.tradeId,
+		proposerId: e.proposal.proposerId,
+		offered: e.proposal.intent.offered,
+		requested: e.proposal.intent.requested
+	}), $ = async (e) => {
+		let { proposal: n, closing: a } = e;
+		if (i(n.held, [
+			"tradeId",
+			"inventory",
+			"currencies"
+		], "invalid_record"), a && a.kind !== "accept") {
+			let o = i(a.value, [
+				"tradeId",
+				"inventory",
+				"currencies"
+			], "invalid_record");
+			if (o.tradeId !== e.view.tradeId || r(o.currencies, 32).length !== n.intent.offered.currencies.length) throw t("invalid_record");
+		}
+		let o = async (r, o, s, c) => {
+			if (c && i(c, ["inventory", "currencies"], "invalid_record"), o.items.length) {
+				if (!de) throw t("unavailable");
+				let i = await I(de.reservationEvidence(B, {
+					tenantId: n.tenantId,
+					owner: {
+						ownerKind: "player",
+						ownerId: r
+					},
+					reservationId: e.view.tradeId
+				}));
+				if (i.items.length !== o.items.length || i.items.some((e, t) => e.instance.id !== o.items[t].instanceId || e.qty !== o.items[t].qty) || i.state !== (a?.kind === "accept" ? "transferred" : a ? "released" : "reserved") || !i.reserve || s && !P(i.reserve, s.inventory) || c && (!i.transfer?.to || !P(c.inventory, {
+					reservationId: e.view.tradeId,
+					from: i.transfer.from,
+					to: i.transfer.to
+				})) || a && a.kind !== "accept" && !P(i.release, a.value.inventory)) throw t("invalid_record");
+			} else if (s?.inventory !== null && s !== null || c?.inventory !== null && c !== null) throw t("invalid_record");
+			if (s && (s.tradeId !== e.view.tradeId || s.currencies.length !== o.currencies.length) || c && c.currencies.length !== o.currencies.length) throw t("invalid_record");
+			for (let [l, u] of o.currencies.entries()) {
+				let o = await I(ue.escrow(B, {
+					tenantId: n.tenantId,
+					owner: {
+						kind: "wallet",
+						ownerKind: "player",
+						ownerId: r
+					},
+					reservationId: e.view.tradeId,
+					currency: u.currency
+				}));
+				if (o.state === "not-observed" || o.amount !== u.amount || o.state !== (a?.kind === "accept" ? "settled" : a ? "released" : "held") || s && !P(o.receipt, s.currencies[l])) throw t("invalid_record");
+				if (c) {
+					let r = c.currencies[l];
+					i(r, ["reserve", "settlement"], "invalid_record"), i(r.settlement, [
+						"reservationId",
+						"currency",
+						"gross",
+						"net",
+						"tax",
+						"payout",
+						"taxReceipt"
+					], "invalid_record");
+					let a = n.taxes.find((e) => e.currency === u.currency && e.gross === u.amount);
+					if (!a || !P(o.receipt, r.reserve) || !P(o.closingReceipt, r.settlement.payout) || !P(o.taxReceipt, r.settlement.taxReceipt) || !P({
+						currency: r.settlement.currency,
+						gross: r.settlement.gross,
+						net: r.settlement.net,
+						tax: r.settlement.tax
+					}, a) || r.settlement.reservationId !== e.view.tradeId) throw t("invalid_record");
+				} else if (a && !P(o.closingReceipt, a.value.currencies[l])) throw t("invalid_record");
+			}
+		}, s = a?.kind === "accept" ? a.value : null;
+		if (s && (i(s, [
+			"tradeId",
+			"offered",
+			"requested"
+		], "invalid_record"), s.tradeId !== e.view.tradeId)) throw t("invalid_record");
+		await o(n.proposerId, n.intent.offered, n.held, s?.offered ?? null), s && await o(a.ownerId, n.intent.requested, null, s.requested);
+	}, ye = async (n, r, i, o, s) => {
+		let c = await e.transactional(async (e) => {
+			await Y(e, n, r);
+			let c = (await e.query(D(y).where(E("id", G(n, r, i))).limit(1).descriptor))[0];
+			if (c && c.state !== "pending") {
+				if (c.state === "erased") throw t("erased");
+				if (o !== void 0 && (c.kind !== o || c.digest !== A([o, s]))) throw t("conflict");
+				return {
+					value: await Q(e, n, a(c.tradeId)),
+					op: c
+				};
+			}
+		});
+		if (c) return await $(c.value), await e.transactional(async (e) => {
+			if (await Y(e, n, r), !P((await Q(e, n, c.value.view.tradeId)).row, c.value.row)) throw t("conflict");
+		}), c.op.receipt;
+	}, be = async (n, r, i, a, o) => {
+		await pe(n, r), await e.transactional(async (e) => {
+			await J(e, n, [r]), await Y(e, n, r);
+			let s = G(n, r, i), c = (await e.query(D(y).where(E("id", s)).limit(1).descriptor))[0];
+			if (c) {
+				if (c.state === "erased") throw t("erased");
+			} else await e.insert(y.tableName, {
+				id: s,
+				tenantId: n,
+				ownerKey: U(n, r),
+				ownerId: r,
+				tradeId: o,
+				kind: a,
+				state: "pending",
+				admission: 0,
+				sequence: null,
+				digest: null,
+				request: null,
+				receipt: null,
+				at: null
+			});
+		});
+	}, xe = async (e, n, r, i, a, o, c) => {
+		let l = G(n, r, a.requestId), u = await Y(e, n, r), d = u.rows.find((e) => e.id === l);
+		if (!d || d.state !== "pending" || d.digest !== null || d.receipt !== null || d.request !== null || d.sequence !== null || d.kind !== i || d.tradeId !== o.tradeId) throw t("conflict");
+		let f = s(u.parent?.operationsCount, 0, k - 1) + 1, p = Object.freeze({
+			operationId: l,
+			requestId: a.requestId,
+			trade: o
+		});
+		return await e.update(y.tableName, l, {
+			state: "fulfilled",
+			sequence: f,
+			digest: A([i, a]),
+			request: a,
+			receipt: p,
+			at: new Date(c)
+		}), await e.update(b.tableName, U(n, r), { operationsCount: f }), p;
+	}, Se = async (e, n) => {
+		try {
+			return await e();
+		} catch (e) {
+			let r = await n();
+			if (r) return r;
+			throw e instanceof z ? t("invalid_record") : e;
+		}
+	}, Ce = (n, r) => R(() => {
+		let i = K(n), a = u(r);
+		if (a.toId === i.owner) throw t("invalid_input");
+		return L(async () => {
+			let n = () => ye(i.tenant, i.owner, a.requestId, "propose", a);
+			return await n() || Se(async () => {
+				let n = ee(a, p, C), r = fe(i.tenant, i.owner, n.requestId), o = H(), c = M(o + n.durationMs), u = l(await I(w.read({
+					tenantId: i.tenant,
+					ownerId: i.owner,
+					tradeId: r,
+					at: o
+				})), i.tenant, i.owner);
+				if (!u.allowed || u.trustScore < C.minTrustScore || n.offered.items.some((e) => {
+					let t = u.items.find((t) => t.instanceId === e.instanceId);
+					return !t || !t.tradable || t.locked || t.qty < e.qty || t.expiresAt !== null && t.expiresAt <= o;
+				})) throw t("forbidden");
+				let d = [...n.offered.currencies, ...n.requested.currencies].map((e) => g({
+					currency: e.currency,
+					amount: e.amount,
+					rules: C
+				}, V.taxPolicy));
+				if (d.some((e) => d.some((t) => e.currency === t.currency && e.gross === t.gross && e.tax !== t.tax))) throw t("invalid_input");
+				await be(i.tenant, i.owner, n.requestId, "propose", r), n.toId !== null && await pe(i.tenant, n.toId), await e.insertIgnore(S.tableName, {
+					id: r,
+					tenantId: i.tenant,
+					proposerKey: U(i.tenant, i.owner),
+					targetKey: n.toId === null ? null : U(i.tenant, n.toId),
+					accepterKey: null,
+					accepted: !1,
+					state: "pending",
+					admission: 0,
+					digest: null,
+					proposal: null,
+					closing: null,
+					createdAt: null,
+					expiresAt: null
+				}, { conflictColumns: ["id"] });
+				let f = await I(w.prepare(Object.freeze({
+					tenantId: i.tenant,
+					tradeId: r,
+					phase: "propose",
+					at: o,
+					expiresAt: c,
+					participants: Object.freeze([u])
+				}))), m = O(e, [f], async (e) => {
+					await J(e, i.tenant, [i.owner, ...n.toId === null ? [] : [n.toId]]), await Y(e, i.tenant, i.owner);
+					let a = (await X(e, i.tenant)).rows.find((e) => e.id === r);
+					if (!a || a.state === "erased") throw t("erased");
+					if (a.proposal !== null) throw new z();
+					if (a.proposerKey !== U(i.tenant, i.owner) || a.targetKey !== (n.toId === null ? null : U(i.tenant, n.toId))) throw t("conflict");
+				}), h = await I(le.prepareReserve(B, {
+					tenantId: i.tenant,
+					tradeId: r,
+					proposerId: i.owner,
+					offered: n.offered,
+					requested: n.requested
+				}, m)), _ = O(e, [h], async (e, [t]) => {
+					let a = Object.freeze({
+						tenantId: i.tenant,
+						proposerId: i.owner,
+						intent: n,
+						currencies: p,
+						rules: C,
+						createdAt: o,
+						expiresAt: c,
+						taxes: Object.freeze(d),
+						held: t
+					}), l = Z(r, a, null), u = await X(e, i.tenant), f = s(u.parent?.tradesCount, 0, k - 1) + 1;
+					return await e.update(S.tableName, r, {
+						accepted: !0,
+						state: "proposed",
+						digest: l.tradeDigest,
+						proposal: a,
+						createdAt: new Date(o),
+						expiresAt: new Date(c)
+					}), await e.update(x.tableName, W(i.tenant), { tradesCount: f }), xe(e, i.tenant, i.owner, "propose", n, l, o);
+				});
+				return (await ae(e, [_]))[0];
+			}, n);
+		});
+	}), we = (n, r, i, o) => R(() => {
+		let s = i === "expire" ? (q(n), {
+			tenant: a(o),
+			owner: "",
+			subject: structuredClone(n)
+		}) : K(n), c = i === "accept" ? _(r) : v(r);
+		return L(async () => {
+			let n = await e.transactional((e) => Q(e, s.tenant, c.tradeId)), r = i === "expire" ? n.proposal.proposerId : s.owner, a = () => ye(s.tenant, r, c.requestId, i, c);
+			return await a() || Se(async () => {
+				if (n.closing || i !== "accept" && r !== n.proposal.proposerId || i === "accept" && (c.tradeDigest !== n.view.tradeDigest || r === n.proposal.proposerId || n.proposal.intent.toId !== null && n.proposal.intent.toId !== r)) throw t("conflict");
+				let a = H();
+				if (a < n.proposal.createdAt || i === "accept" && a >= n.proposal.expiresAt || i === "expire" && a < n.proposal.expiresAt) throw t("forbidden");
+				let o;
+				if (i === "accept") {
+					let e = await Promise.all([n.proposal.proposerId, r].map(async (e) => l(await I(w.read({
+						tenantId: s.tenant,
+						ownerId: e,
+						tradeId: c.tradeId,
+						at: a
+					})), s.tenant, e)));
+					if (!h({
+						tenantId: s.tenant,
+						proposerId: n.proposal.proposerId,
+						accepterId: r,
+						tradeId: c.tradeId,
+						proposedToId: n.proposal.intent.toId,
+						createdAt: n.proposal.createdAt,
+						at: a,
+						expiresAt: n.proposal.expiresAt,
+						rules: n.proposal.rules,
+						currencies: n.proposal.currencies,
+						offered: n.proposal.intent.offered,
+						requested: n.proposal.intent.requested,
+						proposer: e[0],
+						accepter: e[1]
+					}, se)) throw t("forbidden");
+					o = await I(w.prepare(Object.freeze({
+						tenantId: s.tenant,
+						tradeId: c.tradeId,
+						phase: "accept",
+						at: a,
+						expiresAt: n.proposal.expiresAt,
+						participants: Object.freeze(e)
+					})));
+				}
+				await be(s.tenant, r, c.requestId, i, c.tradeId);
+				let u = oe(e, async (e) => {
+					let a = i === "accept" ? [r, n.proposal.proposerId] : [r];
+					await J(e, s.tenant, a);
+					for (let t of a) await Y(e, s.tenant, t);
+					let o = await Q(e, s.tenant, c.tradeId);
+					if ((await e.query(D(y).where(E("id", G(s.tenant, r, c.requestId))).limit(1).descriptor))[0]?.state === "fulfilled") throw new z();
+					if (o.closing || !P(o.proposal, n.proposal)) throw t("conflict");
+				}), d = o ? O(e, [o, u], async () => {}) : u, f = _e(n.proposal);
+				return (async (t) => {
+					let o = O(e, [t], async (e, [t]) => {
+						let o = Object.freeze({
+							ownerId: r,
+							kind: i,
+							request: c,
+							at: a,
+							value: t
+						}), l = Z(c.tradeId, n.proposal, o);
+						return await e.update(S.tableName, c.tradeId, {
+							state: l.state,
+							closing: o,
+							accepterKey: i === "accept" ? U(s.tenant, r) : null
+						}), xe(e, s.tenant, r, i, c, l, a);
+					});
+					return (await ae(e, [o]))[0];
+				})(i === "accept" ? await I(f.prepareExchange(B, {
+					...ve(n),
+					accepterId: r
+				}, d)) : await I(f.prepareRelease(B, ve(n), d)));
+			}, a);
+		});
+	}), Te = (n, r) => R(() => {
+		let o = i(n, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (o.kind !== "guest" && o.kind !== "user") throw t("invalid_input");
+		let s = a(o.tenantId), c = a(o.subjectId);
+		return L(async () => (await pe(s, c), e.transactional(async (e) => (await J(e, s, [c], !0), await Y(e, s, c, !0), await X(e, s), r(e, s, c)))));
+	}), Ee = Object.freeze({
+		expireDue: (n, r) => R(() => {
+			q(n);
+			let i = structuredClone(n), o = te(r);
+			return L(async () => {
+				let n = H(), r = await e.transactional(async (e) => {
+					let r = await X(e, o.tenantId), i = [], s = /* @__PURE__ */ new Set(), c = async (t) => {
+						s.has(t) || (await Y(e, o.tenantId, t), s.add(t));
+					};
+					for (let s of r.rows) {
+						if (s.state === "erased") {
+							if (s.proposal !== null || s.closing !== null || s.digest !== null || s.createdAt !== null || s.expiresAt !== null) throw t("invalid_record");
+							continue;
+						}
+						if (s.accepted !== !0) continue;
+						let l = await Q(e, o.tenantId, a(s.id), !1, r);
+						await c(l.proposal.proposerId), l.closing?.kind === "accept" && await c(l.closing.ownerId), l.view.state === "proposed" && l.proposal.expiresAt <= n && i.push(l.view.tradeId);
+					}
+					if (i.length > o.maxTrades) throw t("limit_exceeded");
+					return {
+						scannedRows: r.rows.length,
+						due: i.sort()
+					};
+				}), s = 0, c = 0;
+				for (let t of r.due) try {
+					await I(Ee.expire(i, {
+						tenantId: o.tenantId,
+						tradeId: t
+					})), s++;
+				} catch (n) {
+					let r = await e.transactional((e) => Q(e, o.tenantId, t));
+					if (r.view.state === "proposed") throw n;
+					await $(r), c++;
+				}
+				return Object.freeze({
+					capturedAt: n,
+					scannedRows: r.scannedRows,
+					dueTrades: r.due.length,
+					expiredTrades: s,
+					alreadyClosedTrades: c
+				});
+			});
+		}),
+		propose: Ce,
+		accept: (e, t) => we(e, t, "accept"),
+		cancel: (e, t) => we(e, t, "cancel"),
+		expire: (e, t) => R(() => {
+			q(e);
+			let n = i(t, ["tenantId", "tradeId"]), r = a(n.tenantId), o = a(n.tradeId);
+			return we(e, {
+				tradeId: o,
+				requestId: j("expiry.", r, o)
+			}, "expire", r);
+		}),
+		mine: (t) => R(() => {
+			let n = K(t);
+			return L(async () => {
+				let t = await e.transactional(async (e) => {
+					await Y(e, n.tenant, n.owner);
+					let t = await X(e, n.tenant), r = U(n.tenant, n.owner), i = [];
+					for (let o of t.rows) o.accepted === !0 && o.state !== "erased" && [
+						o.proposerKey,
+						o.targetKey,
+						o.accepterKey
+					].includes(r) && i.push(await Q(e, n.tenant, a(o.id)));
+					return i;
+				});
+				for (let e of t) await $(e);
+				return Object.freeze(t.map((e) => e.view).sort((e, t) => e.tradeId < t.tradeId ? -1 : 1));
+			});
+		}),
+		receipt: (e, t) => R(() => {
+			let n = K(e), r = i(t, ["requestId"]), o = a(r.requestId);
+			return L(async () => {
+				let e = await ye(n.tenant, n.owner, o);
+				return Object.freeze(e ? {
+					requestId: o,
+					state: "fulfilled",
+					receipt: e
+				} : {
+					requestId: o,
+					state: "not-observed"
+				});
+			});
+		}),
+		rebuild: (n, r) => R(() => {
+			q(n);
+			let o = i(r, ["tenantId", "tradeId"]), s = a(o.tenantId), c = a(o.tradeId);
+			return L(async () => {
+				let n = await e.transactional((e) => Q(e, s, c, !0));
+				return await $(n), e.transactional(async (e) => {
+					await J(e, s, [n.proposal.proposerId, ...n.closing?.kind === "accept" ? [n.closing.ownerId] : []]);
+					let r = await Q(e, s, c, !0);
+					for (let t of [n.proposal.proposerId, ...n.closing?.kind === "accept" ? [n.closing.ownerId] : []]) await Y(e, s, t);
+					if (!P(r.row, n.row)) throw t("conflict");
+					return await e.update(S.tableName, c, { state: r.view.state }), r.view;
+				});
+			});
+		}),
+		exportSubject: (e) => Te(e, async (e, t, n) => {
+			let r = U(t, n), i = await X(e, t), a = await Y(e, t, n, !0);
+			return {
+				trades: i.rows.filter((e) => [
+					e.proposerKey,
+					e.targetKey,
+					e.accepterKey
+				].includes(r) && e.proposal !== null).map((e) => ({
+					tradeId: e.id,
+					proposal: e.proposal,
+					closing: e.closing
+				})),
+				operations: a.rows.map((e) => ({
+					operationId: e.id,
+					state: e.state,
+					request: e.request,
+					receipt: e.receipt
+				}))
+			};
+		}),
+		eraseSubject: (e) => Te(e, async (e, t, n) => {
+			let r = U(t, n), i = (await X(e, t)).rows.filter((e) => [
+				e.proposerKey,
+				e.targetKey,
+				e.accepterKey
+			].includes(r));
+			for (let n of i) await e.update(S.tableName, String(n.id), {
+				state: "erased",
+				digest: null,
+				proposal: null,
+				closing: null,
+				createdAt: null,
+				expiresAt: null
+			}), await e.updateMany(y.tableName, {
+				state: "erased",
+				digest: null,
+				request: null,
+				receipt: null,
+				at: null
+			}, { where: T(E("tenantId", t), E("tradeId", n.id)) });
+			await e.updateMany(y.tableName, {
+				state: "erased",
+				ownerId: null,
+				digest: null,
+				request: null,
+				receipt: null,
+				at: null
+			}, { where: T(E("tenantId", t), E("ownerKey", r)) }), await e.update(b.tableName, r, {
+				ownerId: null,
+				erased: !0
+			});
+		})
+	});
+	return Ee;
+};
+//#endregion
+export { B as dataStoreTrades, ce as resolveTradeStoreOptions };