@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/port.js

@@ -0,0 +1,12 @@
+import { captureBoundMethods as e } from "./capture.js";
+import { Context as t } from "effect";
+// src/port.ts
+var n = class extends t.Service()("@voltro/EconomyPort") {}, r = (t) => e(t, [
+	"transfer",
+	"mine",
+	"auditWallet",
+	"rebuildWallet",
+	"exportSubject",
+	"eraseSubject"
+]);
+export { n as EconomyPort, r as captureEconomyService };

package/dist/price.d.ts

@@ -0,0 +1,99 @@
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+/** The one actual default. A real-money reference never constitutes a receipt. */
+export declare const defaultPriceResolver: PriceResolver;
+
+/** Captures declarations and enforces the global real-money switch. */
+export declare const definePrice: (input: PriceDefinition, currencies: readonly CurrencyDefinition[], realMoney?: boolean) => Price;
+
+declare type EconomyAmountInput = string | number | bigint;
+
+export declare type EconomyChannel = 'web' | 'ios' | 'android' | 'steam';
+
+export declare type Price = {
+    readonly kind: 'virtual';
+    readonly options: readonly ResolvedVirtualPriceOption[];
+} | ({
+    readonly kind: 'real';
+} & RealPriceDefinition) | {
+    readonly kind: 'mixed';
+    readonly real: RealPriceDefinition;
+    readonly virtual: readonly ResolvedVirtualPriceOption[];
+} | {
+    readonly kind: 'free';
+};
+
+export declare type PriceDefinition = {
+    readonly kind: 'virtual';
+    readonly options: readonly VirtualPriceOption[];
+} | ({
+    readonly kind: 'real';
+} & RealPriceDefinition) | {
+    readonly kind: 'mixed';
+    readonly real: RealPriceDefinition;
+    readonly virtual: readonly VirtualPriceOption[];
+} | {
+    readonly kind: 'free';
+};
+
+export declare type PriceResolver = (context: PriceResolverContext) => Price;
+
+export declare interface PriceResolverContext {
+    readonly price: Price;
+    readonly currencies: readonly ResolvedCurrency[];
+    readonly realMoney: boolean;
+    readonly adjustments: readonly Readonly<{
+        currency: string;
+        discountBps: number;
+        minimum: string;
+    }>[];
+}
+
+export declare const priceResolverContext: (price: PriceDefinition, currencies: readonly CurrencyDefinition[], realMoney?: boolean, adjustments?: readonly VirtualPriceAdjustment[]) => PriceResolverContext;
+
+export declare interface RealPriceDefinition {
+    /** Integer minor-unit references; verified store receipts remain authoritative. */
+    readonly prices: Readonly<Record<string, number>>;
+    readonly storeProductIds: Partial<Readonly<Record<EconomyChannel, string>>>;
+}
+
+declare interface ResolvedCurrency {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap: string;
+    readonly premium: boolean;
+    readonly display: {
+        readonly nameKey: string;
+    } | null;
+}
+
+export declare interface ResolvedVirtualPriceOption {
+    readonly currency: string;
+    readonly amount: string;
+}
+
+/** Detaches custom output and preserves alternatives, floors and real references. */
+export declare const resolvePrice: (context: PriceResolverContext, resolver?: PriceResolver) => Price;
+
+export declare interface VirtualPriceAdjustment {
+    readonly currency: string;
+    /** Inclusive integer 0..10000. */
+    readonly discountBps: number;
+    /** A trusted floor, enforced independently of a custom resolver. */
+    readonly minimum: EconomyAmountInput;
+}
+
+export declare interface VirtualPriceOption {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export { }

package/dist/price.js

@@ -0,0 +1,143 @@
+import { economyError as e } from "./errors.js";
+import { dataList as t, dataObject as n, identifier as r } from "./capture.js";
+import { nonNegativeAmount as i } from "./amount.js";
+import { captureCurrencies as a } from "./currency.js";
+// src/price.ts
+var o = [
+	"web",
+	"ios",
+	"android",
+	"steam"
+], s = (t) => {
+	let i = n(t, ["prices", "storeProductIds"], "invalid_price");
+	if (i.prices === null || typeof i.prices != "object" || Array.isArray(i.prices)) throw e("invalid_price");
+	let a = Object.keys(i.prices);
+	if (a.length === 0 || a.length > 64) throw e("invalid_price");
+	let s = n(i.prices, a, "invalid_price"), c = Object.create(null);
+	for (let t of a) {
+		let n = s[t];
+		if (!/^[A-Z]{3}$/.test(t) || typeof n != "number" || !Number.isSafeInteger(n) || n <= 0) throw e("invalid_price");
+		c[t] = n;
+	}
+	let l = n(i.storeProductIds, o, "invalid_price"), u = {};
+	for (let e of o) l[e] !== void 0 && (u[e] = r(l[e], "invalid_price"));
+	if (Object.keys(u).length === 0) throw e("invalid_price");
+	return Object.freeze({
+		prices: Object.freeze(c),
+		storeProductIds: Object.freeze(u)
+	});
+}, c = (a, o) => {
+	let s = t(a, 32, "invalid_price");
+	if (s.length === 0) throw e("invalid_price");
+	let c = /* @__PURE__ */ new Set();
+	return Object.freeze(s.map((t) => {
+		let a = n(t, ["currency", "amount"], "invalid_price"), s = r(a.currency, "invalid_price"), l = o.find((e) => e.id === s);
+		if (!l || c.has(s)) throw e("invalid_price");
+		let u = i(a.amount);
+		if (u > BigInt(l.cap)) throw e("invalid_price");
+		return c.add(s), Object.freeze({
+			currency: s,
+			amount: u.toString()
+		});
+	}));
+}, l = (t, r, i = !1) => {
+	if (typeof i != "boolean") throw e("invalid_input");
+	let o = a(r), l = n(t, [
+		"kind",
+		"options",
+		"prices",
+		"storeProductIds",
+		"real",
+		"virtual"
+	], "invalid_price");
+	switch (l.kind) {
+		case "free": return n(t, ["kind"], "invalid_price"), Object.freeze({ kind: "free" });
+		case "virtual": return n(t, ["kind", "options"], "invalid_price"), Object.freeze({
+			kind: "virtual",
+			options: c(l.options, o)
+		});
+		case "real":
+			if (!i) throw e("real_money_disabled");
+			return n(t, [
+				"kind",
+				"prices",
+				"storeProductIds"
+			], "invalid_price"), Object.freeze({
+				kind: "real",
+				...s({
+					prices: l.prices,
+					storeProductIds: l.storeProductIds
+				})
+			});
+		case "mixed":
+			if (!i) throw e("real_money_disabled");
+			return n(t, [
+				"kind",
+				"real",
+				"virtual"
+			], "invalid_price"), Object.freeze({
+				kind: "mixed",
+				real: s(l.real),
+				virtual: c(l.virtual, o)
+			});
+		default: throw e("invalid_price");
+	}
+}, u = (e, t) => Object.freeze(e.map((e) => {
+	let n = t.adjustments.find((t) => t.currency === e.currency);
+	if (!n) return e;
+	let r = (BigInt(e.amount) * BigInt(1e4 - n.discountBps) + 9999n) / 10000n, i = BigInt(n.minimum);
+	return Object.freeze({
+		currency: e.currency,
+		amount: (r < i ? i : r).toString()
+	});
+})), d = (e) => {
+	switch (e.price.kind) {
+		case "virtual": return Object.freeze({
+			kind: "virtual",
+			options: u(e.price.options, e)
+		});
+		case "mixed": return Object.freeze({
+			kind: "mixed",
+			real: e.price.real,
+			virtual: u(e.price.virtual, e)
+		});
+		default: return e.price;
+	}
+}, f = (o, s, c = !1, u = []) => {
+	let d = a(s), f = l(o, d, c), p = f.kind === "virtual" ? f.options : f.kind === "mixed" ? f.virtual : [], m = /* @__PURE__ */ new Set(), h = t(u, 32, "invalid_price").map((t) => {
+		let a = n(t, [
+			"currency",
+			"discountBps",
+			"minimum"
+		], "invalid_price"), o = r(a.currency, "invalid_price"), s = p.find((e) => e.currency === o), c = a.discountBps, l = i(a.minimum);
+		if (!s || m.has(o) || typeof c != "number" || !Number.isInteger(c) || c < 0 || c > 1e4 || l > BigInt(s.amount)) throw e("invalid_price");
+		return m.add(o), Object.freeze({
+			currency: o,
+			discountBps: c,
+			minimum: l.toString()
+		});
+	});
+	return Object.freeze({
+		price: f,
+		currencies: d,
+		realMoney: c,
+		adjustments: Object.freeze(h)
+	});
+}, p = (t, n = d) => {
+	if (typeof n != "function") throw e("invalid_input");
+	let r = f(t.price, t.currencies, t.realMoney, t.adjustments), i = l(n(r), r.currencies, r.realMoney);
+	if (i.kind !== r.price.kind) throw e("invalid_price");
+	let a = r.price.kind === "virtual" ? r.price.options : r.price.kind === "mixed" ? r.price.virtual : [], o = i.kind === "virtual" ? i.options : i.kind === "mixed" ? i.virtual : [];
+	if (a.length !== o.length) throw e("invalid_price");
+	for (let t of o) {
+		let n = a.find((e) => e.currency === t.currency), i = r.adjustments.find((e) => e.currency === t.currency)?.minimum ?? "0";
+		if (!n || BigInt(t.amount) < BigInt(i) || BigInt(t.amount) > BigInt(n.amount)) throw e("invalid_price");
+	}
+	let s = r.price.kind === "real" ? r.price : r.price.kind === "mixed" ? r.price.real : null, c = i.kind === "real" ? i : i.kind === "mixed" ? i.real : null;
+	if (s && c) {
+		let t = Object.keys(s.prices), n = Object.keys(s.storeProductIds);
+		if (Object.keys(c.prices).length !== t.length || Object.keys(c.storeProductIds).length !== n.length || t.some((e) => s.prices[e] !== c.prices[e]) || n.some((e) => s.storeProductIds[e] !== c.storeProductIds[e])) throw e("invalid_price");
+	}
+	return i;
+};
+export { d as defaultPriceResolver, l as definePrice, f as priceResolverContext, p as resolvePrice };

package/dist/purchaseRecovery.js

@@ -0,0 +1,55 @@
+import { economyError as e } from "./errors.js";
+import { dataObject as t, identifier as n } from "./capture.js";
+import { captureShopOrderReceipt as r, shopBuyIntent as i } from "./shop.js";
+import { browserIntentionJournal as a, createIntentionRecovery as o } from "./intentionRecovery.js";
+// src/purchaseRecovery.ts
+var s = (e) => {
+	let t = i(e);
+	return Object.freeze({
+		offerId: t.offerId,
+		offerVersion: t.offerVersion,
+		offerDigest: t.offerDigest,
+		requestId: t.requestId,
+		qty: t.qty,
+		...t.currency === null ? {} : { currency: t.currency }
+	});
+}, c = (i) => {
+	let a = t(i, [
+		"requestId",
+		"state",
+		"receipt"
+	], "invalid_record"), o = n(a.requestId, "invalid_record");
+	if (a.state === "not-observed" || a.state === "pending") {
+		if (Object.hasOwn(a, "receipt")) throw e("invalid_record");
+		return Object.freeze({
+			requestId: o,
+			state: a.state
+		});
+	}
+	if (a.state !== "fulfilled") throw e("invalid_record");
+	return Object.freeze({
+		requestId: o,
+		state: "fulfilled",
+		receipt: r(a.receipt)
+	});
+}, l = (t, n) => {
+	let r = c(n);
+	if (r.requestId !== t.requestId) throw e("conflict");
+	if (r.state !== "fulfilled") return r;
+	let a = r.receipt, o = i(t);
+	if (a.offerId !== o.offerId || a.offerVersion !== o.offerVersion || a.offerDigest !== o.offerDigest || a.quantity !== o.qty || (a.pricePaid.kind === "free" ? o.currency !== null : a.pricePaid.currency !== o.currency)) throw e("conflict");
+	return r;
+}, u = (e, t) => o(e, t, {
+	request: (e) => s(e),
+	observation: c,
+	fulfilled: (e, t) => ({
+		requestId: e.requestId,
+		state: "fulfilled",
+		receipt: t
+	}),
+	resolve: (e, t) => {
+		let n = l(e, t);
+		return n.state === "fulfilled" ? n.receipt : void 0;
+	}
+}), d = (e, t) => a(e, t, "voltro:shop-purchase:v1:", 2048, (e) => s(e));
+export { d as browserShopPurchaseJournal, u as createShopPurchaseRecovery };

package/dist/reports.server.js

@@ -0,0 +1,114 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { dataObject as n, identifier as r } from "./capture.js";
+import { nonNegativeAmount as i } from "./amount.js";
+import { economyLedgerTable as a } from "./tables.entity.js";
+import { economyLedgerAt as o, readEconomyTransferEvidence as s } from "./walletStore.js";
+import { Effect as c, Schema as l } from "effect";
+import { eq as u, queryFor as d } from "@voltro/database";
+import { defineAggregate as f } from "@voltro/runtime";
+// src/reports.server.ts
+var p = l.Struct({
+	day: l.String,
+	currency: l.String,
+	reason: l.String,
+	sources: l.String,
+	sinks: l.String,
+	playerTransfers: l.String,
+	transactions: l.Number
+}), m = (e) => {
+	let i = n(e, [
+		"tenantId",
+		"maxRows",
+		"maxGroups"
+	]), a = i.maxRows ?? 1e4, o = i.maxGroups ?? 1e3;
+	if (typeof a != "number" || !Number.isSafeInteger(a) || a < 2 || a > 1e5 || typeof o != "number" || !Number.isSafeInteger(o) || o < 1 || o > 1e4) throw t("invalid_input");
+	return Object.freeze({
+		tenantId: r(i.tenantId),
+		maxRows: a,
+		maxGroups: o
+	});
+}, h = (e, n) => {
+	let a = /* @__PURE__ */ new Map();
+	for (let s of e) {
+		if (s.length !== 2) throw t("invalid_record");
+		let e = s.find((e) => i(e.debit) > 0n), c = s.find((e) => i(e.credit) > 0n);
+		if (!e || !c) throw t("invalid_record");
+		let l = new Date(o(e.at)).toISOString().split("T")[0], u = r(e.currency), d = r(e.reason), f = JSON.stringify([
+			l,
+			u,
+			d
+		]), p = a.get(f);
+		if (!p) {
+			if (a.size === n) throw t("limit_exceeded");
+			p = {
+				day: l,
+				currency: u,
+				reason: d,
+				sources: 0n,
+				sinks: 0n,
+				playerTransfers: 0n,
+				transactions: 0
+			}, a.set(f, p);
+		}
+		let m = i(e.debit);
+		e.accountKind === "system" ? p.sources += m : c.accountKind === "system" ? p.sinks += m : p.playerTransfers += m, p.transactions++;
+	}
+	return Object.freeze([...a.values()].sort((e, t) => e.day.localeCompare(t.day) || e.currency.localeCompare(t.currency) || e.reason.localeCompare(t.reason)).map((e) => Object.freeze({
+		...e,
+		sources: e.sources.toString(),
+		sinks: e.sinks.toString(),
+		playerTransfers: e.playerTransfers.toString()
+	})));
+}, g = (n, i) => {
+	try {
+		let o = m(i);
+		return c.tryPromise({
+			try: () => n.transactional(async (e) => {
+				let n = await e.query(d(a).where(u("tenantId", o.tenantId)).orderBy("id", "asc").limit(o.maxRows + 1).descriptor);
+				if (n.length > o.maxRows) throw t("limit_exceeded");
+				let i = /* @__PURE__ */ new Map();
+				for (let e of n) {
+					if (e.tenantId !== o.tenantId) throw t("invalid_record");
+					let n = r(e.currency), a = r(e.txId), s = i.get(n);
+					s || (s = /* @__PURE__ */ new Set(), i.set(n, s)), s.add(a);
+				}
+				let c = [];
+				for (let [t, n] of i) {
+					let r = await s(e, o.tenantId, [...n], t);
+					for (let { pair: e } of r.values()) c.push(e);
+				}
+				return h(c, o.maxGroups);
+			}),
+			catch: (n) => n instanceof e ? n : t("unavailable")
+		});
+	} catch (n) {
+		return c.fail(n instanceof e ? n : t("invalid_input"));
+	}
+}, _ = (e) => {
+	let i = n(e, [
+		"tenantId",
+		"maxRows",
+		"maxGroups",
+		"name",
+		"refresh"
+	]), a = m({
+		tenantId: i.tenantId,
+		...i.maxRows === void 0 ? {} : { maxRows: i.maxRows },
+		...i.maxGroups === void 0 ? {} : { maxGroups: i.maxGroups }
+	}), o = r(i.name ?? "economy.flows"), s = i.refresh ?? "1h";
+	if (typeof s != "string" || !/^[1-9][0-9]{0,6}(ms|s|m|h|d)$/.test(s)) throw t("invalid_input");
+	return f({
+		name: o,
+		refresh: s,
+		output: p,
+		bootRefresh: "persistent",
+		strategy: "replace",
+		indexes: [[
+			"day",
+			"currency",
+			"reason"
+		]],
+		build: (e) => g(e.store, a)
+	});
+};
+export { p as EconomyFlowRowSchema, m as captureEconomyReportOptions, _ as economyFlowsAggregate, g as readEconomyFlows };