@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/offerPolicies.js

@@ -0,0 +1,268 @@
+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 { positiveAmount as o } from "./amount.js";
+import { captureCurrencies as s } from "./currency.js";
+import { priceResolverContext as c } from "./price.js";
+import { defineShopOffer as l, shopInteger as u } from "./shop.js";
+import { captureFlashTriggerReceipt as d, defaultFlashTriggerPolicy as f, defaultPersonalizedOfferSelector as p, defineBundle as m, defineFlashOffer as h, definePersonalizedOffers as g, projectBundleValue as _, resolveFlashOffer as v, resolvePersonalizedOffers as y } from "./offerMerchandising.js";
+import { Effect as b } from "effect";
+//#region src/offerPolicies.ts
+var x = (e, n, r = !1) => {
+	let s = i(e, [
+		"offer",
+		"expiresAfterMs",
+		"bonus"
+	]), c = l(s.offer, n, r);
+	if (c.maxQuantity !== 1 || c.limits.perPlayer !== null && c.limits.perPlayer !== 1) throw t("invalid_input");
+	let d = c.currencies;
+	if (s.bonus !== void 0) {
+		let e = i(s.bonus, ["currency", "multiplier"]), n = a(e.currency), r = u(e.multiplier, 1, 1e3);
+		if (!d.some((e) => e.currency === n)) throw t("invalid_input");
+		d = Object.freeze(d.map((e) => e.currency === n ? Object.freeze({
+			currency: n,
+			amount: o(BigInt(e.amount) * BigInt(r)).toString()
+		}) : e));
+	}
+	let f = l({
+		...c,
+		currencies: d,
+		oneTime: !0,
+		limits: {
+			...c.limits,
+			perPlayer: 1
+		}
+	}, n, r);
+	return Object.freeze({
+		offer: f,
+		expiresAfterMs: u(s.expiresAfterMs, 1, 316224e5)
+	});
+}, S = (e, t, n) => {
+	let r = u(t, 0, 864e13), i = u(n, r, 864e13), a = u(e.expiresAfterMs, 1, 316224e5);
+	return i - r < a;
+}, C = (e, n, o = !1) => {
+	let s = i(e, [
+		"id",
+		"version",
+		"from",
+		"until",
+		"variants",
+		"metrics"
+	]), c = u(s.from, 0, 864e13), d = u(s.until, 1, 864e13);
+	if (c >= d) throw t("invalid_input");
+	let f = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Set(), m = Object.freeze(r(s.variants, 32).map((e) => {
+		let s = i(e, [
+			"id",
+			"weight",
+			"offers"
+		]), c = Object.freeze(r(s.offers, 32).map((e) => l(e, n, o)));
+		if (!c.length) throw t("invalid_input");
+		let d = /* @__PURE__ */ new Set();
+		for (let e of c) {
+			if (f.has(e.id)) throw t("invalid_input");
+			f.add(e.id);
+			let n = e.price.kind === "real" ? e.price : e.price.kind === "mixed" ? e.price.real : null;
+			if (n) for (let [e, r] of Object.entries(n.storeProductIds)) {
+				let n = JSON.stringify([e, r]);
+				if (p.has(n)) throw t("invalid_price");
+				d.add(n);
+			}
+		}
+		for (let e of d) p.add(e);
+		return Object.freeze({
+			id: a(s.id),
+			weight: u(s.weight, 1, 1e6),
+			offers: c
+		});
+	}).sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id))), h = Object.freeze(r(s.metrics, 32).map((e) => a(e)));
+	if (m.length < 2 || new Set(m.map((e) => e.id)).size !== m.length || !h.length || new Set(h).size !== h.length) throw t("invalid_input");
+	return Object.freeze({
+		id: a(s.id),
+		version: a(s.version ?? "1"),
+		from: c,
+		until: d,
+		variants: m,
+		metrics: h
+	});
+}, w = ({ experiment: e, tenantId: n, key: r }) => {
+	let i = 2166136261;
+	for (let t of new TextEncoder().encode(JSON.stringify([
+		n,
+		e.id,
+		e.version,
+		r
+	]))) i = Math.imul(i ^ t, 16777619) >>> 0;
+	let a = i % e.variants.reduce((e, t) => e + t.weight, 0);
+	for (let t of e.variants) {
+		if (a < t.weight) return t.id;
+		a -= t.weight;
+	}
+	throw t("invalid_input");
+}, T = (e, n = w) => {
+	if (typeof n != "function") throw t("invalid_input");
+	let r = i(e, [
+		"experiment",
+		"tenantId",
+		"key",
+		"at",
+		"currencies",
+		"realMoney"
+	]), o = s(r.currencies), c = r.realMoney ?? !1;
+	if (typeof c != "boolean") throw t("invalid_input");
+	let l = C(r.experiment, o, c), d = u(r.at, 0, 864e13), f = Object.freeze({
+		experiment: l,
+		at: d,
+		tenantId: a(r.tenantId),
+		key: a(r.key),
+		currencies: o,
+		realMoney: c
+	});
+	if (d < l.from || d >= l.until) return null;
+	let p = a(n(f)), m = l.variants.find((e) => e.id === p);
+	if (!m) throw t("invalid_input");
+	return Object.freeze({
+		experimentId: l.id,
+		version: l.version,
+		variantId: p,
+		offers: m.offers
+	});
+}, E = (o) => {
+	let m = i(o, [
+		"currencies",
+		"realMoney",
+		"source",
+		"starterPacks",
+		"experiments",
+		"experimentBucket",
+		"personalized",
+		"flashOffers",
+		"personalizedSelector",
+		"flashTrigger",
+		"policyVersion"
+	]), _ = s(m.currencies), E = m.realMoney ?? !1;
+	if (typeof E != "boolean") throw t("invalid_input");
+	let D = n(m.source, ["read"]), O = Object.freeze(r(m.starterPacks ?? [], 128).map((e) => x(e, _, E))), k = Object.freeze(r(m.experiments ?? [], 128).map((e) => C(e, _, E))), A = Object.freeze(r(m.personalized ?? [], 128).map((e) => g(e, _, E))), j = Object.freeze(r(m.flashOffers ?? [], 128).map((e) => h(e, _, E))), M = m.personalizedSelector ?? p, N = m.flashTrigger ?? f, P = a(m.policyVersion ?? "default.v1");
+	if ([M, N].some((e) => typeof e != "function") || (A.length || j.length || M !== p || N !== f) && P === "default.v1" || new Set(A.map((e) => e.id)).size !== A.length || new Set(j.map((e) => e.id)).size !== j.length || new Set(j.map((e) => e.offer.id)).size !== j.length) throw t("invalid_input");
+	let F = A.flatMap((e) => e.pool.map((e) => e.offer.id));
+	if (new Set(F).size !== F.length) throw t("invalid_input");
+	let I = m.experimentBucket ?? w;
+	if (typeof I != "function" || new Set(O.map((e) => e.offer.id)).size !== O.length || new Set(k.map((e) => e.id)).size !== k.length) throw t("invalid_input");
+	let L = k.flatMap((e) => e.variants.flatMap((e) => e.offers.map((e) => e.id)));
+	if (new Set(L).size !== L.length) throw t("invalid_input");
+	return Object.freeze({ read: (n) => {
+		let o;
+		try {
+			let e = i(n, [
+				"subject",
+				"offer",
+				"at"
+			]), r = i(e.subject, [
+				"type",
+				"id",
+				"tenantId",
+				"kind",
+				"scopes",
+				"metadata"
+			]);
+			if (r.type !== "user" || r.kind !== void 0 && r.kind !== "guest") throw t("forbidden");
+			o = Object.freeze({
+				subject: Object.freeze({
+					type: "user",
+					id: a(r.id),
+					tenantId: a(r.tenantId),
+					...r.kind === "guest" ? { kind: "guest" } : {}
+				}),
+				offer: l(e.offer, _, E),
+				at: u(e.at, 0, 864e13)
+			});
+		} catch {
+			return b.fail(t("invalid_input"));
+		}
+		let s = o.subject;
+		return s.type === "user" ? b.try({
+			try: () => D.read(Object.freeze({
+				tenantId: s.tenantId,
+				ownerId: s.id,
+				offer: o.offer,
+				at: o.at
+			})),
+			catch: (n) => n instanceof e ? n : t("unavailable")
+		}).pipe(b.flatMap((e) => b.isEffect(e) ? e : b.fail(t("invalid_input"))), b.flatMap((n) => b.try({
+			try: () => {
+				let e = i(n, [
+					"eligible",
+					"adjustments",
+					"firstSessionAt",
+					"experimentKey",
+					"personalization",
+					"flashTriggers"
+				]);
+				if (typeof e.eligible != "boolean") throw t("invalid_input");
+				let l = u(e.firstSessionAt, 0, o.at), f = a(e.experimentKey), p = c(o.offer.price, _, E, e.adjustments).adjustments, m = e.eligible, h = O.find((e) => e.offer.id === o.offer.id);
+				if (h) {
+					if (JSON.stringify(h.offer) !== JSON.stringify(o.offer)) throw t("conflict");
+					m &&= S(h, l, o.at);
+				}
+				for (let e of k) if (e.variants.some((e) => e.offers.some((e) => e.id === o.offer.id))) {
+					let n = T({
+						experiment: e,
+						tenantId: s.tenantId,
+						key: f,
+						at: o.at,
+						currencies: _,
+						realMoney: E
+					}, I)?.offers.find((e) => e.id === o.offer.id);
+					if (n && JSON.stringify(n) !== JSON.stringify(o.offer)) throw t("conflict");
+					m &&= n !== void 0;
+				}
+				for (let n of A) if (n.pool.some((e) => e.offer.id === o.offer.id)) {
+					let r = n.pool.find((e) => e.offer.id === o.offer.id).offer;
+					if (JSON.stringify(r) !== JSON.stringify(o.offer)) throw t("conflict");
+					let a = i(e.personalization, ["ownedItemIds", "playStyles"]), c = y({
+						personalized: n,
+						currencies: _,
+						realMoney: E,
+						tenantId: s.tenantId,
+						key: f,
+						at: o.at,
+						ownedItemIds: a.ownedItemIds,
+						playStyles: a.playStyles,
+						rulesVersion: P
+					}, M);
+					m &&= c?.offers.some((e) => e.id === o.offer.id) === !0;
+				}
+				let g = j.find((e) => e.offer.id === o.offer.id);
+				if (g) {
+					if (JSON.stringify(g.offer) !== JSON.stringify(o.offer)) throw t("conflict");
+					let n = r(e.flashTriggers, 128).map((e) => {
+						let t = i(e, ["flashId", "trigger"]);
+						return Object.freeze({
+							flashId: a(t.flashId),
+							trigger: t.trigger === null ? null : d(t.trigger)
+						});
+					});
+					if (new Set(n.map((e) => e.flashId)).size !== n.length) throw t("invalid_input");
+					let c = n.find((e) => e.flashId === g.id);
+					if (!c) throw t("invalid_input");
+					let l = v({
+						flash: g,
+						currencies: _,
+						realMoney: E,
+						tenantId: s.tenantId,
+						ownerId: s.id,
+						at: o.at,
+						trigger: c.trigger,
+						rulesVersion: P
+					}, N);
+					m &&= l !== null;
+				}
+				return Object.freeze({
+					eligible: m,
+					adjustments: p
+				});
+			},
+			catch: (n) => n instanceof e ? n : t("invalid_input")
+		}))) : b.fail(t("forbidden"));
+	} });
+};
+//#endregion
+export { d as captureFlashTriggerReceipt, w as defaultExperimentBucket, f as defaultFlashTriggerPolicy, p as defaultPersonalizedOfferSelector, m as defineBundle, h as defineFlashOffer, C as defineOfferExperiment, g as definePersonalizedOffers, x as defineStarterPack, E as offerPolicyContextSource, _ as projectBundleValue, v as resolveFlashOffer, T as resolveOfferExperiment, y as resolvePersonalizedOffers, S as starterPackAvailable };

package/dist/piggyBanks.d.ts

@@ -0,0 +1,272 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const capturePiggyBanksService: (input: PiggyBanksService) => PiggyBanksService;
+
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+export declare const defaultPiggyFill: PiggyFillPolicy;
+
+export declare const defaultPiggyReset: PiggyResetPolicy;
+
+export declare const definePiggyBank: (input: PiggyBankDefinition | PiggyBank, declarations: readonly CurrencyDefinition[], realMoney?: boolean) => PiggyBank;
+
+declare type EconomyAmountInput = string | number | bigint;
+
+declare type EconomyChannel = 'web' | 'ios' | 'android' | 'steam';
+
+/** Redacted codes; never carries owners, amounts or provider payloads. */
+declare class EconomyError extends EconomyError_base {
+}
+
+declare const EconomyError_base: Schema.Class<EconomyError, Schema.TaggedStruct<"EconomyError", {
+    readonly code: Schema.Literals<readonly ["invalid_currency", "invalid_amount", "overflow", "invalid_price", "real_money_disabled", "invalid_input", "invalid_record", "currency_cap_reached", "insufficient_funds", "conflict", "forbidden", "unavailable", "not_found", "erased", "limit_exceeded", "already_redeemed"]>;
+}>, YieldableError>;
+
+export declare interface PiggyBank {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly currency: string;
+    readonly cap: string;
+    readonly unlock: Price;
+    readonly fillFrom: readonly string[];
+    readonly reset: 'onUnlock';
+}
+
+export declare interface PiggyBankDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly currency: string;
+    readonly cap: EconomyAmountInput;
+    readonly unlock: PriceDefinition;
+    readonly fillFrom: readonly string[];
+    readonly reset?: 'onUnlock' | undefined;
+}
+
+export declare class PiggyBanksPort extends PiggyBanksPort_base {
+}
+
+declare const PiggyBanksPort_base: Context.ServiceClass<PiggyBanksPort, "@voltro/PiggyBanksPort", PiggyBanksService>;
+
+export declare interface PiggyBanksService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly PiggyView[], EconomyError>;
+    readonly fill: (subject: Subject, input: PiggyFillInput) => Effect.Effect<PiggyReceipt, EconomyError>;
+    readonly unlock: (subject: Subject, input: PiggyUnlockInput) => Effect.Effect<PiggyReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: {
+        readonly requestId: string;
+    }) => Effect.Effect<PiggyObservation, EconomyError>;
+    readonly rebuild: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly bankId: string;
+    }) => Effect.Effect<PiggyProjection, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare type PiggyEvent = {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'fill';
+    readonly at: number;
+    readonly authorityId: string;
+    readonly eventId: string;
+    readonly sourceId: string;
+    readonly acceptedAmount: string;
+    readonly delta: string;
+} | {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'unlock';
+    readonly at: number;
+    readonly amount: string;
+    readonly remaining: string;
+};
+
+export declare interface PiggyFillContext extends PiggyRuleContext {
+    readonly acceptedAmount: EconomyAmountInput;
+}
+
+export declare interface PiggyFillInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly bankId: string;
+    readonly sourceId: string;
+    readonly eventId: string;
+    readonly requestId: string;
+}
+
+export declare const piggyFillIntent: (input: PiggyFillInput) => PiggyFillInput;
+
+export declare type PiggyFillPolicy = (context: PiggyFillContext) => EconomyAmountInput;
+
+export declare type PiggyObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: PiggyReceipt;
+};
+
+export declare interface PiggyProjection {
+    readonly events: readonly PiggyEvent[];
+    readonly available: string;
+    readonly cycles: number;
+}
+
+export declare type PiggyReceipt = {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly bankId: string;
+    readonly event: Extract<PiggyEvent, {
+        kind: 'fill';
+    }>;
+    readonly available: string;
+} | {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly bankId: string;
+    readonly event: Extract<PiggyEvent, {
+        kind: 'unlock';
+    }>;
+    readonly available: string;
+    readonly value: ShopOrderReceipt;
+};
+
+export declare type PiggyResetPolicy = (context: PiggyRuleContext) => EconomyAmountInput;
+
+export declare interface PiggyRuleContext {
+    readonly bank: PiggyBank;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly available: EconomyAmountInput;
+    readonly rulesVersion?: string;
+}
+
+export declare interface PiggyUnlockInput {
+    readonly bankId: string;
+    readonly bankVersion: string;
+    readonly bankDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+export declare const piggyUnlockIntent: (input: PiggyUnlockInput) => Readonly<{
+    bankId: string;
+    bankVersion: string;
+    bankDigest: string;
+    requestId: string;
+    currency: string | null;
+}>;
+
+export declare interface PiggyView {
+    readonly bank: PiggyBank;
+    readonly bankDigest: string;
+    readonly available: string;
+    readonly cycles: number;
+}
+
+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';
+};
+
+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';
+};
+
+/** One complete accepted history owner for writer/rebuild. SQL/source layers
+ * separately establish receipt authenticity, ownership and complete tail. */
+export declare const projectPiggyBank: (bank: Pick<PiggyBank, "cap" | "fillFrom">, input: readonly PiggyEvent[]) => PiggyProjection;
+
+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 ResolvedVirtualPriceOption {
+    readonly currency: string;
+    readonly amount: string;
+}
+
+/** Custom fill narrows the accepted source amount and remaining cap. No player
+ * event, source validation, SQL grant or wallet mint is implied by this rule. */
+export declare const resolvePiggyFill: (input: PiggyFillContext, slot?: PiggyFillPolicy) => string;
+
+/** Custom reset retains a remainder; only available-minus-remainder is granted,
+ * so retaining points cannot recreate already paid currency. */
+export declare const resolvePiggyReset: (input: PiggyRuleContext, slot?: PiggyResetPolicy) => Readonly<{
+    remaining: string;
+    amount: string;
+}>;
+
+declare interface ShopOrderReceipt {
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly offerDigest: string;
+    readonly quantity: number;
+    readonly at: number;
+    readonly pricePaid: {
+        readonly kind: 'free';
+    } | {
+        readonly kind: 'virtual';
+        readonly currency: string;
+        readonly amount: string;
+    };
+    readonly transfers: readonly {
+        readonly txId: string;
+        readonly currency: string;
+        readonly amount: string;
+        readonly at: number;
+    }[];
+    readonly grants: readonly {
+        readonly operationId: string;
+        readonly kind: 'grant';
+        readonly changes: readonly {
+            readonly instanceId: string;
+            readonly delta: number;
+        }[];
+        readonly at: number;
+    }[];
+}
+
+declare interface VirtualPriceOption {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export { }

package/dist/piggyBanks.fixture.js

@@ -0,0 +1,71 @@
+import { defaultPiggyFill as e, defaultPiggyReset as t, definePiggyBank as n, resolvePiggyFill as r, resolvePiggyReset as i } from "./piggyBanks.js";
+import { Effect as a } from "effect";
+//#region src/piggyBanks.fixture.ts
+var o = () => {
+	let e = [{
+		id: "test.gold",
+		kind: "soft",
+		cap: "1000"
+	}], t = n({
+		id: "test.piggy",
+		titleKey: "test.piggy",
+		currency: "test.gold",
+		cap: "20",
+		unlock: {
+			kind: "virtual",
+			options: [{
+				currency: "test.gold",
+				amount: "5"
+			}]
+		},
+		fillFrom: ["match.reward"]
+	}, e);
+	return Object.freeze({
+		bank: t,
+		currencies: e,
+		available: "13",
+		acceptedAmount: "13",
+		realMoney: !1
+	});
+}, s = o(), c = Object.freeze({
+	bank: s.bank,
+	currencies: s.currencies,
+	available: s.available,
+	realMoney: s.realMoney
+}), l = Object.freeze({
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => a.sync(() => r(s)),
+		expected: "7"
+	},
+	overrideProbe: {
+		run: () => a.sync(() => r({
+			...s,
+			rulesVersion: "test.narrow.v1"
+		}, () => "3")),
+		expected: "3"
+	}
+}), u = Object.freeze({
+	kind: "slot",
+	defaultImplementation: t,
+	defaultProbe: {
+		run: () => a.sync(() => i(c)),
+		expected: {
+			remaining: "0",
+			amount: "13"
+		}
+	},
+	overrideProbe: {
+		run: () => a.sync(() => i({
+			...c,
+			rulesVersion: "test.retain.v1"
+		}, () => "3")),
+		expected: {
+			remaining: "3",
+			amount: "10"
+		}
+	}
+});
+//#endregion
+export { o as piggyBankFixture, l as piggyFillSystemFixture, u as piggyResetSystemFixture };