@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/server.js

@@ -0,0 +1,43 @@
+import { iapEntitlementsPort as e } from "./iapEntitlements.server.js";
+import { IapNotificationPort as t, captureIapNotificationService as n, iapNotificationNotice as r, isIapRefundChannel as i, issueVerifiedIapNotification as a } from "./iapNotifications.server.js";
+import { observeAcceptedIapNotificationTarget as o } from "./iapNotificationTarget.server.js";
+import { IapCurrentStatePort as s, captureIapCurrentStateService as c, iapCurrentPurchaseState as l, iapCurrentStatePort as u } from "./iapCurrentState.server.js";
+import { economyCurrenciesTable as d, economyLedgerTable as f, economySubjectsTable as p, economyTables as m, economyTransactionsTable as h, economyWalletsTable as g } from "./tables.entity.js";
+import { dataStoreEconomy as _, resolveEconomyStoreOptions as v } from "./walletStore.js";
+import { iapAccountTables as y, iapAccountTokensTable as b, iapAccountsTable as x } from "./iapAccountTables.entity.js";
+import { IapAccountsPort as S, captureIapAccountBindingService as C, dataStoreIapAccountOwners as w, dataStoreIapAccounts as T } from "./iapAccounts.server.js";
+import { IapVerificationPort as E, iapVerificationPort as D } from "./iapVerification.server.js";
+import { iapNamespacesTable as O, iapOrdersTable as k, iapReceiptsTable as A, iapSubjectsTable as j, iapTables as M } from "./iapTables.entity.js";
+import { IapCompletionPort as N, captureIapCompletionService as P, iapCompletionPort as F } from "./iapCompletion.server.js";
+import { dataStoreIap as I, resolveIapStoreOptions as L } from "./iapStore.server.js";
+import { captureIapCheckoutService as R, captureIapDeliveryService as z, captureIapManagementService as B } from "./iapCheckout.server.js";
+import { IapSystemPort as V, captureIapSystemService as H } from "./iapBinding.server.js";
+import { captureTradeExpiryInput as U, tradeExpirySchedule as W } from "./tradeExpiry.server.js";
+import { tradeEscrowParticipant as G } from "./tradeEscrow.server.js";
+import { tradeOperationsTable as K, tradeSubjectsTable as q, tradeTables as J, tradeTenantsTable as Y, tradesTable as X } from "./tradeTables.entity.js";
+import { dataStoreTrades as Z } from "./tradeStore.server.js";
+import { shopCountersTable as Q, shopOffersTable as $, shopOrdersTable as ee, shopSubjectsTable as te, shopTables as ne, shopTenantsTable as re } from "./shopTables.entity.js";
+import { dataStoreShop as ie, resolveShopStoreOptions as ae, shopOfferDigest as oe } from "./shopStore.server.js";
+import { codeClaimsTable as se, codeSubjectsTable as ce, codeTables as le, codeTenantsTable as ue, codesTable as de } from "./codeTables.entity.js";
+import { dataStoreCodes as fe, resolveCodeStoreOptions as pe } from "./codeStore.server.js";
+import { cryptoContainerRandom as me, cryptoContainerRandomLayer as he, sampleContainer as ge } from "./containers.server.js";
+import { containerDefinitionsTable as _e, containerOpeningsTable as ve, containerSubjectsTable as ye, containerTables as be, containerTenantsTable as xe } from "./containerTables.entity.js";
+import { containerDefinitionDigest as Se, dataStoreContainers as Ce, resolveContainersStoreOptions as we } from "./containerStore.server.js";
+import { subscriptionDefinitionsTable as Te, subscriptionEventsTable as Ee, subscriptionSubjectsTable as De, subscriptionTables as Oe, subscriptionTenantsTable as ke } from "./subscriptionTables.entity.js";
+import { dataStoreSubscriptions as Ae, resolveSubscriptionsStoreOptions as je, subscriptionDefinitionDigest as Me } from "./subscriptionStore.server.js";
+import { loyaltyDefinitionsTable as Ne, loyaltyEntriesTable as Pe, loyaltySeasonsTable as Fe, loyaltySubjectsTable as Ie, loyaltyTables as Le, loyaltyTenantsTable as Re } from "./loyaltyTables.entity.js";
+import { dataStoreLoyalty as ze, resolveLoyaltyStoreOptions as Be } from "./loyaltyStore.server.js";
+import { piggyDefinitionsTable as Ve, piggyEventsTable as He, piggySubjectsTable as Ue, piggyTables as We, piggyTenantsTable as Ge } from "./piggyTables.entity.js";
+import { dataStorePiggyBanks as Ke, piggyBankDigest as qe, resolvePiggyStoreOptions as Je } from "./piggyStore.server.js";
+import { checkSqlEconomyConsistency as Ye, economyConsistencySchedule as Xe } from "./consistency.server.js";
+import { EconomyFlowRowSchema as Ze, economyFlowsAggregate as Qe, readEconomyFlows as $e } from "./reports.server.js";
+import { shopLoyaltyReceiptSource as et } from "./loyaltyShopSource.server.js";
+import { bundleValueFromShopReceipts as tt } from "./bundleValue.server.js";
+import { captureTradeAuthorityAdmission as nt, inventoryTradeAuthoritySource as rt } from "./tradeAuthority.server.js";
+import { sanctionsTradePermissionSource as it } from "./sanctionsTradeAuthority.server.js";
+import { appleIapNotificationPort as at } from "./appleIapNotifications.server.js";
+import { appleIapCurrentStatePort as ot, appleIapProvider as st, appleIapVerificationPort as ct } from "./appleIap.server.js";
+import { googleIapNotificationPort as lt } from "./googleIapNotifications.server.js";
+import { googleIapCompletionPort as ut, googleIapCurrentStatePort as dt, googleIapProvider as ft, googleIapVerificationPort as pt } from "./googleIap.server.js";
+import { iapSpendAdmission as mt } from "./iapSpendAdmission.server.js";
+export { Ze as EconomyFlowRowSchema, S as IapAccountsPort, N as IapCompletionPort, s as IapCurrentStatePort, t as IapNotificationPort, V as IapSystemPort, E as IapVerificationPort, ot as appleIapCurrentStatePort, at as appleIapNotificationPort, st as appleIapProvider, ct as appleIapVerificationPort, tt as bundleValueFromShopReceipts, C as captureIapAccountBindingService, R as captureIapCheckoutService, P as captureIapCompletionService, c as captureIapCurrentStateService, z as captureIapDeliveryService, B as captureIapManagementService, n as captureIapNotificationService, H as captureIapSystemService, nt as captureTradeAuthorityAdmission, U as captureTradeExpiryInput, Ye as checkSqlEconomyConsistency, se as codeClaimsTable, ce as codeSubjectsTable, le as codeTables, ue as codeTenantsTable, de as codesTable, Se as containerDefinitionDigest, _e as containerDefinitionsTable, ve as containerOpeningsTable, ye as containerSubjectsTable, be as containerTables, xe as containerTenantsTable, me as cryptoContainerRandom, he as cryptoContainerRandomLayer, fe as dataStoreCodes, Ce as dataStoreContainers, _ as dataStoreEconomy, I as dataStoreIap, w as dataStoreIapAccountOwners, T as dataStoreIapAccounts, ze as dataStoreLoyalty, Ke as dataStorePiggyBanks, ie as dataStoreShop, Ae as dataStoreSubscriptions, Z as dataStoreTrades, Xe as economyConsistencySchedule, d as economyCurrenciesTable, Qe as economyFlowsAggregate, f as economyLedgerTable, p as economySubjectsTable, m as economyTables, h as economyTransactionsTable, g as economyWalletsTable, ut as googleIapCompletionPort, dt as googleIapCurrentStatePort, lt as googleIapNotificationPort, ft as googleIapProvider, pt as googleIapVerificationPort, y as iapAccountTables, b as iapAccountTokensTable, x as iapAccountsTable, F as iapCompletionPort, l as iapCurrentPurchaseState, u as iapCurrentStatePort, e as iapEntitlementsPort, O as iapNamespacesTable, r as iapNotificationNotice, k as iapOrdersTable, A as iapReceiptsTable, mt as iapSpendAdmission, j as iapSubjectsTable, M as iapTables, D as iapVerificationPort, rt as inventoryTradeAuthoritySource, i as isIapRefundChannel, a as issueVerifiedIapNotification, Ne as loyaltyDefinitionsTable, Pe as loyaltyEntriesTable, Fe as loyaltySeasonsTable, Ie as loyaltySubjectsTable, Le as loyaltyTables, Re as loyaltyTenantsTable, o as observeAcceptedIapNotificationTarget, qe as piggyBankDigest, Ve as piggyDefinitionsTable, He as piggyEventsTable, Ue as piggySubjectsTable, We as piggyTables, Ge as piggyTenantsTable, $e as readEconomyFlows, pe as resolveCodeStoreOptions, we as resolveContainersStoreOptions, v as resolveEconomyStoreOptions, L as resolveIapStoreOptions, Be as resolveLoyaltyStoreOptions, Je as resolvePiggyStoreOptions, ae as resolveShopStoreOptions, je as resolveSubscriptionsStoreOptions, ge as sampleContainer, it as sanctionsTradePermissionSource, Q as shopCountersTable, et as shopLoyaltyReceiptSource, oe as shopOfferDigest, $ as shopOffersTable, ee as shopOrdersTable, te as shopSubjectsTable, ne as shopTables, re as shopTenantsTable, Me as subscriptionDefinitionDigest, Te as subscriptionDefinitionsTable, Ee as subscriptionEventsTable, De as subscriptionSubjectsTable, Oe as subscriptionTables, ke as subscriptionTenantsTable, G as tradeEscrowParticipant, W as tradeExpirySchedule, K as tradeOperationsTable, q as tradeSubjectsTable, J as tradeTables, Y as tradeTenantsTable, X as tradesTable };

package/dist/shop.d.ts

@@ -0,0 +1,279 @@
+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';
+
+/** The same detached receipt admission serves SQL history and browser recovery. */
+export declare const captureShopOrderReceipt: (input: unknown) => ShopOrderReceipt;
+
+/** Capture required methods without invoking accessors; retain the original receiver, including class instances. */
+export declare const captureShopService: (input: ShopService) => ShopService;
+
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+/** `grantless`: the offer may grant nothing, for a store subscription whose value is its paid
+ * period (an entitlement such as game time). Every other offer grants items or currencies. */
+export declare const defineShopOffer: (input: ShopOfferDefinition | ShopOffer, declarations: readonly CurrencyDefinition[], realMoney?: boolean, options?: {
+    readonly grantless?: boolean;
+}) => ShopOffer;
+
+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 type PriceResolver = (context: PriceResolverContext) => Price;
+
+declare interface PriceResolverContext {
+    readonly price: Price;
+    readonly currencies: readonly ResolvedCurrency[];
+    readonly realMoney: boolean;
+    readonly adjustments: readonly Readonly<{
+        currency: string;
+        discountBps: number;
+        minimum: string;
+    }>[];
+}
+
+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;
+}
+
+declare interface ResolvedVirtualPriceOption {
+    readonly currency: string;
+    readonly amount: string;
+}
+
+export declare interface ShopBuyInput {
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly offerDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+    readonly qty?: number | undefined;
+}
+
+export declare const shopBuyIntent: (input: ShopBuyInput) => Readonly<{
+    offerId: string;
+    offerVersion: string;
+    offerDigest: string;
+    requestId: string;
+    currency: string | null;
+    qty: number;
+}>;
+
+export declare interface ShopContextInput {
+    readonly subject: Subject;
+    readonly offer: ShopOffer;
+    readonly at: number;
+}
+
+export declare interface ShopContextSnapshot {
+    readonly eligible: boolean;
+    readonly adjustments: readonly VirtualPriceAdjustment[];
+}
+
+/** Trusted external profile/segment/flag facts; never inside a replayable SQL callback. */
+export declare interface ShopContextSource {
+    readonly read: (input: ShopContextInput) => Effect.Effect<ShopContextSnapshot, EconomyError>;
+}
+
+export declare interface ShopCurrencyGrant {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export declare const shopInteger: (input: unknown, minimum: number, maximum: number) => number;
+
+export declare interface ShopItemGrant {
+    readonly itemId: string;
+    readonly qty: number;
+}
+
+export declare interface ShopOffer {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly price: Price;
+    readonly items: readonly ShopItemGrant[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+    readonly from: number | null;
+    readonly until: number | null;
+    readonly segment: string | null;
+    readonly flag: string | null;
+    readonly countries: readonly string[];
+    readonly limits: {
+        readonly perPlayer: number | null;
+        readonly perDay: number | null;
+        readonly global: number | null;
+    };
+    readonly oneTime: boolean;
+    readonly maxQuantity: number;
+}
+
+export declare interface ShopOfferDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly price: PriceDefinition;
+    readonly items?: readonly ShopItemGrant[] | undefined;
+    readonly currencies?: readonly ShopCurrencyGrant[] | undefined;
+    readonly from?: number | null | undefined;
+    readonly until?: number | null | undefined;
+    readonly segment?: string | null | undefined;
+    readonly flag?: string | null | undefined;
+    readonly countries?: readonly string[] | undefined;
+    readonly limits?: {
+        readonly perPlayer?: number | null | undefined;
+        readonly perDay?: number | null | undefined;
+        readonly global?: number | null | undefined;
+    } | undefined;
+    readonly oneTime?: boolean | undefined;
+    readonly maxQuantity?: number | undefined;
+}
+
+export declare interface ShopOfferView {
+    readonly offerDigest: string;
+    readonly offer: ShopOffer;
+    readonly price: Price;
+}
+
+export 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;
+    }[];
+}
+
+export declare const shopPayment: (price: Price, currency: string | null, quantity: number) => ShopOrderReceipt["pricePaid"];
+
+export declare class ShopPort extends ShopPort_base {
+}
+
+declare const ShopPort_base: Context.ServiceClass<ShopPort, "@voltro/ShopPort", ShopService>;
+
+/** Nonterminal observations never authorize a new request identity or prove that no purchase can commit. */
+export declare type ShopPurchaseObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: ShopOrderReceipt;
+};
+
+export declare interface ShopRules {
+    readonly offers: readonly (ShopOfferDefinition | ShopOffer)[];
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly contextSource?: ShopContextSource | undefined;
+    readonly version?: string | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly maxOrders?: number | undefined;
+    readonly maxAuditRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare interface ShopService {
+    readonly offers: (subject: Subject) => Effect.Effect<readonly ShopOfferView[], EconomyError>;
+    readonly buy: (subject: Subject, input: ShopBuyInput) => Effect.Effect<ShopOrderReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: ShopBuyInput) => Effect.Effect<ShopPurchaseObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+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;
+}
+
+declare interface VirtualPriceOption {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export { }

package/dist/shop.js

@@ -0,0 +1,195 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataList as n, dataObject as r, identifier as i } from "./capture.js";
+import { nonNegativeAmount as a, positiveAmount as o } from "./amount.js";
+import { captureCurrencies as s } from "./currency.js";
+import { definePrice as c } from "./price.js";
+import { Context as l } from "effect";
+// src/shop.ts
+var u = (t, n, r) => {
+	if (typeof t != "number" || !Number.isSafeInteger(t) || t < n || t > r) throw e("invalid_input");
+	return t;
+}, d = (t, a, l = !1, d = {}) => {
+	let f = r(t, [
+		"id",
+		"version",
+		"titleKey",
+		"price",
+		"items",
+		"currencies",
+		"from",
+		"until",
+		"segment",
+		"flag",
+		"countries",
+		"limits",
+		"oneTime",
+		"maxQuantity"
+	]), p = s(a), m = u(f.maxQuantity ?? 1, 1, 1e3), h = n(f.items ?? [], 16).map((t) => {
+		let n = r(t, ["itemId", "qty"]), a = u(n.qty, 1, 1e6);
+		if (a * m > 1e6) throw e("limit_exceeded");
+		return Object.freeze({
+			itemId: i(n.itemId),
+			qty: a
+		});
+	}), g = n(f.currencies ?? [], 16).map((t) => {
+		let n = r(t, ["currency", "amount"]), a = i(n.currency), s = p.find((e) => e.id === a), c = o(n.amount);
+		if (!s || c * BigInt(m) > BigInt(s.cap)) throw e("invalid_currency");
+		return Object.freeze({
+			currency: a,
+			amount: c.toString()
+		});
+	});
+	if (!h.length && !g.length && d.grantless !== !0 || new Set(h.map((e) => e.itemId)).size !== h.length || new Set(g.map((e) => e.currency)).size !== g.length) throw e("invalid_input");
+	let _ = f.from == null ? null : u(f.from, 0, 864e13), v = f.until == null ? null : u(f.until, 1, 864e13);
+	if (_ !== null && v !== null && _ >= v) throw e("invalid_input");
+	let y = n(f.countries ?? [], 256).map((t) => {
+		if (typeof t != "string" || !/^[A-Z]{2}$/.test(t)) throw e("invalid_input");
+		return t;
+	});
+	if (new Set(y).size !== y.length) throw e("invalid_input");
+	let b = r(f.limits ?? {}, [
+		"perPlayer",
+		"perDay",
+		"global"
+	]), x = f.oneTime ?? !1;
+	if (typeof x != "boolean") throw e("invalid_input");
+	let S = (e) => e == null ? null : u(e, 1, 2147483647), C = S(b.perPlayer), w = S(b.perDay), T = S(b.global);
+	if (x && (m !== 1 || C !== null && C !== 1)) throw e("invalid_input");
+	return Object.freeze({
+		id: i(f.id),
+		version: i(f.version ?? "1"),
+		titleKey: i(f.titleKey),
+		price: c(f.price, p, l),
+		items: Object.freeze(h),
+		currencies: Object.freeze(g),
+		from: _,
+		until: v,
+		segment: f.segment == null ? null : i(f.segment),
+		flag: f.flag == null ? null : i(f.flag),
+		countries: Object.freeze(y),
+		limits: Object.freeze({
+			perPlayer: x ? 1 : C,
+			perDay: w,
+			global: T
+		}),
+		oneTime: x,
+		maxQuantity: m
+	});
+}, f = class extends l.Service()("@voltro/ShopPort") {}, p = (t) => {
+	let n = r(t, [
+		"offerId",
+		"offerVersion",
+		"offerDigest",
+		"requestId",
+		"currency",
+		"qty"
+	]);
+	if (typeof n.offerDigest != "string" || !/^[a-f0-9]{64}$/.test(n.offerDigest)) throw e("invalid_input");
+	return Object.freeze({
+		offerId: i(n.offerId),
+		offerVersion: i(n.offerVersion),
+		offerDigest: n.offerDigest,
+		requestId: i(n.requestId),
+		currency: n.currency === void 0 ? null : i(n.currency),
+		qty: u(n.qty ?? 1, 1, 1e3)
+	});
+}, m = (t, n, r) => {
+	if (u(r, 1, 1e3), t.kind === "free") {
+		if (n !== null) throw e("invalid_price");
+		return Object.freeze({ kind: "free" });
+	}
+	let i = (t.kind === "virtual" ? t.options : t.kind === "mixed" ? t.virtual : []).find((e) => e.currency === n);
+	if (!i) throw e("invalid_price");
+	return Object.freeze({
+		kind: "virtual",
+		currency: i.currency,
+		amount: a(BigInt(i.amount) * BigInt(r)).toString()
+	});
+}, h = (e) => t(e, [
+	"offers",
+	"buy",
+	"receipt",
+	"exportSubject",
+	"eraseSubject"
+]), g = (t) => {
+	try {
+		let o = (t) => {
+			if (typeof t != "string" || a(t).toString() !== t) throw e("invalid_record");
+			return t;
+		}, s = r(t, [
+			"orderId",
+			"offerId",
+			"offerVersion",
+			"offerDigest",
+			"quantity",
+			"at",
+			"pricePaid",
+			"transfers",
+			"grants"
+		], "invalid_record");
+		if (typeof s.offerDigest != "string" || !/^[a-f0-9]{64}$/.test(s.offerDigest)) throw e("invalid_record");
+		let c = r(s.pricePaid, [
+			"kind",
+			"currency",
+			"amount"
+		], "invalid_record"), l;
+		if (c.kind === "free") r(s.pricePaid, ["kind"], "invalid_record"), l = Object.freeze({ kind: "free" });
+		else if (c.kind === "virtual") l = Object.freeze({
+			kind: "virtual",
+			currency: i(c.currency, "invalid_record"),
+			amount: o(c.amount)
+		});
+		else throw e("invalid_record");
+		let d = Object.freeze(n(s.transfers, 33, "invalid_record").map((e) => {
+			let t = r(e, [
+				"txId",
+				"currency",
+				"amount",
+				"at"
+			], "invalid_record");
+			return Object.freeze({
+				txId: i(t.txId, "invalid_record"),
+				currency: i(t.currency, "invalid_record"),
+				amount: o(t.amount),
+				at: u(t.at, 0, 864e13)
+			});
+		})), f = Object.freeze(n(s.grants, 16, "invalid_record").map((t) => {
+			let a = r(t, [
+				"operationId",
+				"kind",
+				"changes",
+				"at"
+			], "invalid_record");
+			if (a.kind !== "grant") throw e("invalid_record");
+			let o = Object.freeze(n(a.changes, 1e4, "invalid_record").map((e) => {
+				let t = r(e, ["instanceId", "delta"], "invalid_record");
+				return Object.freeze({
+					instanceId: i(t.instanceId, "invalid_record"),
+					delta: u(t.delta, 1, 1e6)
+				});
+			}));
+			if (new Set(o.map((e) => e.instanceId)).size !== o.length) throw e("invalid_record");
+			return Object.freeze({
+				operationId: i(a.operationId, "invalid_record"),
+				kind: "grant",
+				changes: o,
+				at: u(a.at, 0, 864e13)
+			});
+		})), p = u(s.at, 0, 864e13);
+		if (new Set(d.map((e) => e.txId)).size !== d.length || new Set(f.map((e) => e.operationId)).size !== f.length || d.some((e) => e.at > p) || f.some((e) => e.at > p)) throw e("invalid_record");
+		return Object.freeze({
+			orderId: i(s.orderId, "invalid_record"),
+			offerId: i(s.offerId, "invalid_record"),
+			offerVersion: i(s.offerVersion, "invalid_record"),
+			offerDigest: s.offerDigest,
+			quantity: u(s.quantity, 1, 1e3),
+			at: u(s.at, 0, 864e13),
+			pricePaid: l,
+			transfers: d,
+			grants: f
+		});
+	} catch {
+		throw e("invalid_record");
+	}
+};
+export { f as ShopPort, g as captureShopOrderReceipt, h as captureShopService, d as defineShopOffer, p as shopBuyIntent, u as shopInteger, m as shopPayment };

package/dist/shop.testFixtures.js

@@ -0,0 +1,113 @@
+import { economyTables as e } from "./tables.entity.js";
+import { dataStoreEconomy as t } from "./walletStore.js";
+import { shopTables as n } from "./shopTables.entity.js";
+import { dataStoreShop as r, resolveShopStoreOptions as i, shopOfferDigest as a } from "./shopStore.server.js";
+import { Effect as o } from "effect";
+import { systemSubject as s } from "@voltro/protocol";
+import { ensureTableRegistered as c } from "@voltro/database";
+import { dataStoreCatalog as l, dataStoreInventory as u, inventoryTables as d } from "@voltro/plugin-inventory/server";
+import { inventoryFixture as f } from "@voltro/plugin-inventory/testing";
+// src/shop.testFixtures.ts
+var p = [
+	...e,
+	...d,
+	...n
+], m = Date.UTC(2026, 9, 10), h = s("shop.fixture"), g = (e = "a", t = "tenant") => ({
+	type: "user",
+	id: e,
+	tenantId: t,
+	kind: "guest"
+}), _ = (e, t = "buy.1") => {
+	let n = i(e), r = n.offers[0], o = r.price.kind === "virtual" ? r.price.options : r.price.kind === "mixed" ? r.price.virtual : [];
+	return {
+		offerId: r.id,
+		offerVersion: r.version,
+		offerDigest: a(r, n.version),
+		requestId: t,
+		...o[0] ? { currency: o[0].currency } : {}
+	};
+}, v = async (e, n = "tenant", i = {}, a = 4096) => {
+	p.forEach(c);
+	let { item: s, content: d } = f(), v = l(e, {
+		items: [s],
+		now: () => m
+	});
+	await o.runPromise(v.importSnapshot(h, {
+		tenantId: n,
+		channel: "live",
+		locale: "en",
+		revision: "shop.r1",
+		items: [d]
+	}));
+	let y = t(e, {
+		currencies: [{
+			id: "test.gold",
+			kind: "soft"
+		}],
+		now: () => m
+	}), b = u(e, {
+		items: [s],
+		catalogSource: { read: v.read },
+		channel: "live",
+		locale: "en",
+		maxInstances: a,
+		now: () => m
+	});
+	await o.runPromise(y.transfer(h, {
+		tenantId: n,
+		requestId: "fund.a",
+		currency: "test.gold",
+		amount: "100",
+		from: {
+			kind: "system",
+			id: "fixture"
+		},
+		to: {
+			kind: "wallet",
+			ownerKind: "player",
+			ownerId: "a"
+		},
+		reason: "fixture.reward",
+		ref: {
+			kind: "fixture",
+			id: "fund.a"
+		}
+	}));
+	let x = {
+		currencies: [{
+			id: "test.gold",
+			kind: "soft"
+		}],
+		realMoney: !1,
+		economy: y,
+		inventory: b,
+		now: () => m,
+		offers: [{
+			id: "potion",
+			titleKey: "shop.potion",
+			price: {
+				kind: "virtual",
+				options: [{
+					currency: "test.gold",
+					amount: "7"
+				}]
+			},
+			items: [{
+				itemId: s.id,
+				qty: 2
+			}],
+			oneTime: !0
+		}],
+		...i
+	}, S = _(x);
+	return {
+		economy: y,
+		inventory: b,
+		catalog: v,
+		options: x,
+		shop: r(e, x),
+		user: g("a", n),
+		buy: S
+	};
+};
+export { m as shopAt, v as shopFixture, _ as shopFixtureBuy, p as shopFixtureTables, h as shopMachine, g as shopUser };