@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/containerStore.testFixtures.js

@@ -0,0 +1,75 @@
+import { defineContainer as e } from "./containers.js";
+import { containerTables as t } from "./containerTables.entity.js";
+import { dataStoreContainers as n } from "./containerStore.server.js";
+import { shopAt as r, shopFixture as i } from "./shop.testFixtures.js";
+import { Effect as a } from "effect";
+import { ensureTableRegistered as o } from "@voltro/database";
+// src/containerStore.testFixtures.ts
+var s = async (s, c = "tenant", l = {}, u = 4096) => {
+	t.forEach(o);
+	let d = await i(s, c, {}, u), f = d.options.currencies, p = {
+		id: "fixture.chest",
+		price: {
+			kind: "virtual",
+			options: [{
+				currency: "test.gold",
+				amount: "7"
+			}]
+		},
+		countries: ["DE"],
+		drops: [{
+			id: "common",
+			rarity: "common",
+			weight: "9",
+			currencies: [{
+				currency: "test.gold",
+				amount: "2"
+			}]
+		}, {
+			id: "rare",
+			rarity: "legendary",
+			weight: "1",
+			items: [{
+				itemId: "test.potion",
+				qty: 2
+			}],
+			currencies: [{
+				currency: "test.gold",
+				amount: "5"
+			}]
+		}],
+		pity: {
+			guaranteed: "legendary",
+			after: 2
+		}
+	}, m = 0, h = {
+		currencies: f,
+		containers: [e(p, f)],
+		economy: d.economy,
+		inventory: d.inventory,
+		accessSource: { read: () => a.succeed({
+			isMinor: !1,
+			country: "DE",
+			eligible: !0,
+			adjustments: []
+		}) },
+		version: "fixture.v1",
+		random: { draw: () => a.sync(() => (m++, "0")) },
+		now: () => r,
+		...l
+	};
+	return {
+		base: d,
+		options: h,
+		service: n(s, h),
+		draws: () => m
+	};
+}, c = (e, t = "fixture.open") => Object.freeze({
+	containerId: e.container.id,
+	containerVersion: e.container.version,
+	containerDigest: e.containerDigest,
+	disclosureDigest: e.disclosureDigest,
+	requestId: t,
+	...e.container.price.kind === "virtual" ? { currency: e.container.price.options[0].currency } : e.container.price.kind === "mixed" ? { currency: e.container.price.virtual[0].currency } : {}
+});
+export { c as containerOpenIntent, s as containerStoreFixture };

package/dist/containerTables.entity.js

@@ -0,0 +1,45 @@
+import { boolean as e, id as t, integer as n, json as r, table as i, text as a, timestamp as o } from "@voltro/database";
+// src/containerTables.entity.ts
+var s = () => a().maxLength(120).externalId().sensitive("pii"), c = i("_voltro_eco_container_tenants", {
+	id: t({ prefix: "eut" }),
+	tenantId: s(),
+	admission: n().serverOnly()
+}).index(["tenantId"]), l = i("_voltro_eco_containers", {
+	id: t({ prefix: "eud" }),
+	tenantId: s(),
+	definition: r().serverOnly(),
+	currencies: r().serverOnly(),
+	realMoney: e().serverOnly(),
+	rulesVersion: a().maxLength(120).serverOnly(),
+	createdAt: o().serverOnly()
+}).index(["tenantId"]), u = i("_voltro_eco_container_subjects", {
+	id: t({ prefix: "eus" }),
+	tenantId: s(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	erased: e().serverOnly(),
+	admission: n().serverOnly(),
+	pendingId: a().maxLength(64).nullable().serverOnly()
+}).index(["tenantId", "ownerId"]), d = i("_voltro_eco_container_openings", {
+	id: t({ prefix: "euo" }),
+	tenantId: s(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	ownerKey: a().maxLength(64).serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"fulfilled",
+		"erased"
+	]).serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	intent: r().nullable().serverOnly(),
+	selection: r().nullable().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	sequence: n().nullable().serverOnly(),
+	createdAt: o().serverOnly(),
+	fulfilledAt: o().nullable().serverOnly()
+}).index(["tenantId", "ownerKey"]), f = [
+	c,
+	l,
+	u,
+	d
+];
+export { l as containerDefinitionsTable, d as containerOpeningsTable, u as containerSubjectsTable, f as containerTables, c as containerTenantsTable };

package/dist/containers.d.ts

@@ -0,0 +1,311 @@
+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 captureContainerIntent: (input: ContainerOpenInput) => Readonly<{
+    containerId: string;
+    containerVersion: string;
+    containerDigest: string;
+    disclosureDigest: string;
+    requestId: string;
+    currency: string | null;
+}>;
+
+export declare const captureContainersService: (input: ContainersService) => ContainersService;
+
+export declare interface Container {
+    readonly id: string;
+    readonly version: string;
+    readonly group: string;
+    readonly price: Price;
+    readonly drops: readonly ContainerDrop[];
+    readonly pity: Readonly<{
+        guaranteed: string;
+        after: number;
+        softFrom: number | null;
+        softRampBps: number;
+    }> | null;
+    readonly countries: readonly string[];
+}
+
+export declare interface ContainerAccessContext {
+    readonly container: Container;
+    readonly at: number;
+    readonly isMinor: boolean;
+    readonly country: string;
+    readonly eligible: boolean;
+}
+
+export declare interface ContainerDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly group?: string;
+    readonly price: PriceDefinition;
+    readonly drops: readonly ContainerDropDefinition[];
+    readonly pity?: {
+        readonly guaranteed: string;
+        readonly after: number;
+        readonly softFrom?: number;
+        readonly softRampBps?: number;
+    };
+    readonly countries?: readonly string[];
+}
+
+export declare interface ContainerDistribution {
+    readonly entries: readonly ContainerProbabilityWeight[];
+    readonly total: string;
+    readonly guaranteed: boolean;
+}
+
+export declare interface ContainerDrop {
+    readonly id: string;
+    readonly rarity: string;
+    readonly weight: string;
+    readonly items: readonly {
+        readonly itemId: string;
+        readonly qty: number;
+    }[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+}
+
+export declare interface ContainerDropDefinition {
+    readonly id: string;
+    readonly rarity: string;
+    readonly weight: EconomyAmountInput;
+    readonly items?: readonly {
+        readonly itemId: string | undefined;
+        readonly qty: number;
+    }[];
+    readonly currencies?: readonly {
+        readonly currency: string | undefined;
+        readonly amount: EconomyAmountInput;
+    }[];
+}
+
+export declare type ContainerEligibility = (input: ContainerAccessContext) => boolean;
+
+export declare type ContainerObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: ContainerReceipt;
+};
+
+export declare interface ContainerOpenInput {
+    readonly containerId: string;
+    readonly containerVersion: string;
+    readonly containerDigest: string;
+    readonly disclosureDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+export declare interface ContainerProbabilityContext {
+    readonly container: Container;
+    readonly misses: number;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+}
+
+export declare const containerProbabilityContext: (input: ContainerProbabilityContext) => ContainerProbabilityContext;
+
+export declare type ContainerProbabilityResolver = (input: ContainerProbabilityContext) => readonly ContainerProbabilityWeight[];
+
+export declare interface ContainerProbabilityWeight {
+    readonly dropId: string;
+    readonly weight: string;
+}
+
+/** Server authority only: no player draw/seed/state is accepted by any route. */
+export declare class ContainerRandomPort extends ContainerRandomPort_base {
+}
+
+declare const ContainerRandomPort_base: Context.ServiceClass<ContainerRandomPort, "@voltro/ContainerRandomPort", ContainerRandomService>;
+
+export declare interface ContainerRandomService {
+    readonly draw: (exclusiveMaximum: string) => Effect.Effect<string, EconomyError>;
+}
+
+export declare interface ContainerReceipt {
+    readonly operationId: string;
+    readonly containerId: string;
+    readonly containerVersion: string;
+    readonly containerDigest: string;
+    readonly dropId: string;
+    readonly rarity: string;
+    readonly previousMisses: number;
+    readonly misses: number;
+    readonly sequence: number;
+    readonly at: number;
+    readonly distribution: ContainerDistribution;
+    readonly pricePaid: ShopOrderReceipt['pricePaid'];
+    readonly transfers: ShopOrderReceipt['transfers'];
+    readonly grants: ShopOrderReceipt['grants'];
+}
+
+export declare interface ContainerRollContext {
+    readonly distribution: ContainerDistribution;
+    readonly draw: string;
+}
+
+export declare type ContainerRollResolver = (input: ContainerRollContext) => string;
+
+export declare class ContainersPort extends ContainersPort_base {
+}
+
+declare const ContainersPort_base: Context.ServiceClass<ContainersPort, "@voltro/ContainersPort", ContainersService>;
+
+export declare interface ContainersService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly ContainerView[], EconomyError>;
+    readonly open: (subject: Subject, input: ContainerOpenInput) => Effect.Effect<ContainerReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: ContainerOpenInput) => Effect.Effect<ContainerObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare interface ContainerView {
+    readonly container: Container;
+    readonly containerDigest: string;
+    readonly disclosureDigest: string;
+    readonly misses: number;
+    readonly price: Price;
+    readonly disclosure: ReturnType<typeof discloseContainer>;
+}
+
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+/** Required trusted facts; absent age/country never means adult or eligible. */
+export declare const defaultContainerEligibility: ContainerEligibility;
+
+/** Exact integer distribution. Soft pity redistributes probability mass while
+ * preserving relative weights inside each rarity group; hard pity has no miss. */
+export declare const defaultContainerProbability: ContainerProbabilityResolver;
+
+export declare const defaultContainerRoll: ContainerRollResolver;
+
+/** Captured content only. Opening/payment/history must be owned by an ordinary
+ * authoritative service; this declaration creates no value or mutable counter. */
+export declare const defineContainer: (input: ContainerDefinition | Container, declarations: readonly CurrencyDefinition[], realMoney?: boolean) => Container;
+
+/** Public disclosure uses the exact same captured distribution as the draw. */
+export declare const discloseContainer: (input: ContainerProbabilityContext, slot?: ContainerProbabilityResolver) => Readonly<{
+    guaranteed: boolean;
+    probabilities: readonly Readonly<{
+        dropId: string;
+        numerator: string;
+        denominator: string;
+    }>[];
+}>;
+
+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>;
+
+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';
+};
+
+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>>>;
+}
+
+export declare const resolveContainerDistribution: (input: ContainerProbabilityContext, slot?: ContainerProbabilityResolver) => ContainerDistribution;
+
+export declare const resolveContainerEligibility: (input: ContainerAccessContext, declarations: readonly CurrencyDefinition[], realMoney?: boolean, slot?: ContainerEligibility) => boolean;
+
+export declare const resolveContainerRoll: (input: ContainerProbabilityContext, draw: string, probability?: ContainerProbabilityResolver, roll?: ContainerRollResolver) => Readonly<{
+    drop: ContainerDrop;
+    misses: number;
+    distribution: ContainerDistribution;
+}>;
+
+declare interface ResolvedVirtualPriceOption {
+    readonly currency: string;
+    readonly 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/containers.fixture.js

@@ -0,0 +1,128 @@
+import { economyError as e } from "./errors.js";
+import { ContainerRandomPort as t, defaultContainerEligibility as n, defaultContainerProbability as r, defaultContainerRoll as i, defineContainer as a, resolveContainerDistribution as o, resolveContainerEligibility as s, resolveContainerRoll as c } from "./containers.js";
+import { Effect as l, Layer as u } from "effect";
+// src/containers.fixture.ts
+var d = () => {
+	let e = [{
+		id: "test.gold",
+		kind: "soft",
+		cap: "1000000"
+	}], t = a({
+		id: "test.container",
+		price: {
+			kind: "virtual",
+			options: [{
+				currency: "test.gold",
+				amount: "5"
+			}]
+		},
+		drops: [{
+			id: "common",
+			rarity: "common",
+			weight: "99",
+			currencies: [{
+				currency: "test.gold",
+				amount: "1"
+			}]
+		}, {
+			id: "legendary",
+			rarity: "legendary",
+			weight: "1",
+			items: [{
+				itemId: "test.skin",
+				qty: 1
+			}]
+		}],
+		pity: {
+			guaranteed: "legendary",
+			after: 90,
+			softFrom: 75,
+			softRampBps: 600
+		}
+	}, e);
+	return Object.freeze({
+		container: t,
+		currencies: e,
+		misses: 0,
+		realMoney: !1
+	});
+}, f = u.succeed(t, Object.freeze({ draw: (t) => typeof t == "string" && /^[1-9][0-9]{0,255}$/.test(t) ? l.succeed("0") : l.fail(e("invalid_input")) })), p = d(), m = {
+	...p,
+	misses: 89
+}, h = Object.freeze({
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => l.sync(() => o(p)),
+		expected: {
+			entries: [{
+				dropId: "common",
+				weight: "99"
+			}, {
+				dropId: "legendary",
+				weight: "1"
+			}],
+			total: "100",
+			guaranteed: !1
+		}
+	},
+	overrideProbe: {
+		run: () => l.sync(() => o(p, () => [{
+			dropId: "common",
+			weight: "1"
+		}, {
+			dropId: "legendary",
+			weight: "1"
+		}])),
+		expected: {
+			entries: [{
+				dropId: "common",
+				weight: "1"
+			}, {
+				dropId: "legendary",
+				weight: "1"
+			}],
+			total: "2",
+			guaranteed: !1
+		}
+	}
+}), g = Object.freeze({
+	kind: "slot",
+	defaultImplementation: i,
+	defaultProbe: {
+		run: () => l.sync(() => c(p, "0").drop.id),
+		expected: "common"
+	},
+	overrideProbe: {
+		run: () => l.sync(() => c(p, "0", r, () => "legendary").drop.id),
+		expected: "legendary"
+	}
+}), _ = Object.freeze({
+	kind: "port",
+	tag: t,
+	fakeLayer: f,
+	probe: {
+		run: () => l.scoped(l.gen(function* () {
+			return yield* (yield* t).draw(o(m).total);
+		}).pipe(l.provide(f))),
+		expected: "0"
+	}
+}), v = Object.freeze({
+	container: p.container,
+	at: 0,
+	isMinor: !1,
+	country: "DE",
+	eligible: !0
+}), y = Object.freeze({
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => l.sync(() => s(v, p.currencies)),
+		expected: !0
+	},
+	overrideProbe: {
+		run: () => l.sync(() => s(v, p.currencies, !1, (e) => n(e) && e.at > 0)),
+		expected: !1
+	}
+});
+export { y as containerEligibilitySystemFixture, d as containerFixture, h as containerProbabilitySystemFixture, f as containerRandomFakeLayer, _ as containerRandomPortSystemFixture, g as containerRollSystemFixture };