@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/codes.d.ts

@@ -0,0 +1,150 @@
+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 captureCodeIntent: (input: RedeemCodeInput) => RedeemCodeInput;
+
+export declare const captureCodeService: (input: CodeService) => CodeService;
+
+/** Case-sensitive code intention, never normalization that expands authority. */
+export declare const captureCodeValue: (input: unknown) => string;
+
+export declare interface CodeDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly campaign: string;
+    readonly items?: readonly {
+        readonly itemId: string | undefined;
+        readonly qty: number;
+    }[];
+    readonly currencies?: readonly {
+        readonly currency: string | undefined;
+        readonly amount: EconomyAmountInput;
+    }[];
+    readonly from?: number | null;
+    readonly until?: number | null;
+    readonly limits: {
+        readonly global: number;
+        readonly perPlayer: number;
+    };
+}
+
+export declare type CodeEligibility = (input: CodeEligibilityContext) => boolean;
+
+export declare interface CodeEligibilityContext {
+    readonly definition: PromoCode;
+    readonly at: number;
+    readonly claims: number;
+    readonly playerClaims: number;
+}
+
+export declare type CodeObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: CodeReceipt;
+};
+
+export declare class CodePort extends CodePort_base {
+}
+
+declare const CodePort_base: Context.ServiceClass<CodePort, "@voltro/CodePort", CodeService>;
+
+export declare interface CodeReceipt {
+    readonly operationId: string;
+    readonly codeId: string;
+    readonly version: string;
+    readonly campaign: string;
+    readonly at: number;
+    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 interface CodeService {
+    readonly create: (subject: Subject, input: CreateCodeInput) => Effect.Effect<void, EconomyError>;
+    readonly redeem: (subject: Subject, input: RedeemCodeInput) => Effect.Effect<CodeReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: RedeemCodeInput) => Effect.Effect<CodeObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare interface CreateCodeInput {
+    readonly tenantId: string;
+    readonly code: string;
+    readonly definition: CodeDefinition | PromoCode;
+}
+
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+/** One default, independently preserved as the hard safety envelope for custom
+ * rules. A custom rule can narrow admission; never raise captured code limits. */
+export declare const defaultCodeEligibility: CodeEligibility;
+
+/** Code values are supplied privately at runtime; declarations contain no code,
+ * provider credential, amount chosen by a player or alternative grant writer. */
+export declare const defineCode: (input: CodeDefinition | PromoCode, declarations: readonly CurrencyDefinition[]) => PromoCode;
+
+declare type EconomyAmountInput = string | number | bigint;
+
+/** 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 PromoCode {
+    readonly id: string;
+    readonly version: string;
+    readonly campaign: string;
+    readonly items: readonly {
+        readonly itemId: string;
+        readonly qty: number;
+    }[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+    readonly from: number | null;
+    readonly until: number | null;
+    readonly limits: {
+        readonly global: number;
+        readonly perPlayer: number;
+    };
+}
+
+export declare interface RedeemCodeInput {
+    readonly code: string;
+    readonly requestId: string;
+}
+
+export declare const resolveCodeEligibility: (input: CodeEligibilityContext, declarations: readonly CurrencyDefinition[], slot?: CodeEligibility) => boolean;
+
+export { }

package/dist/codes.js

@@ -0,0 +1,82 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataList as n, dataObject as r, identifier as i } from "./capture.js";
+import { positiveAmount as a } from "./amount.js";
+import { captureCurrencies as o } from "./currency.js";
+import { shopInteger as s } from "./shop.js";
+import { Context as c } from "effect";
+// src/codes.ts
+var l = (t, c) => {
+	let l = r(t, [
+		"id",
+		"version",
+		"campaign",
+		"items",
+		"currencies",
+		"from",
+		"until",
+		"limits"
+	]), u = o(c), d = Object.freeze(n(l.items ?? [], 16).map((e) => {
+		let t = r(e, ["itemId", "qty"]);
+		return Object.freeze({
+			itemId: i(t.itemId),
+			qty: s(t.qty, 1, 1e6)
+		});
+	})), f = Object.freeze(n(l.currencies ?? [], 16).map((t) => {
+		let n = r(t, ["currency", "amount"]), o = i(n.currency), s = u.find((e) => e.id === o), c = a(n.amount);
+		if (!s || c > BigInt(s.cap)) throw e("invalid_currency");
+		return Object.freeze({
+			currency: o,
+			amount: c.toString()
+		});
+	}));
+	if (!d.length && !f.length || new Set(d.map((e) => e.itemId)).size !== d.length || new Set(f.map((e) => e.currency)).size !== f.length) throw e("invalid_input");
+	let p = l.from == null ? null : s(l.from, 0, 864e13), m = l.until == null ? null : s(l.until, 1, 864e13);
+	if (p !== null && m !== null && p >= m) throw e("invalid_input");
+	let h = r(l.limits, ["global", "perPlayer"]), g = s(h.global, 1, 1e5), _ = s(h.perPlayer, 1, g);
+	return Object.freeze({
+		id: i(l.id),
+		version: i(l.version ?? "1"),
+		campaign: i(l.campaign),
+		items: d,
+		currencies: f,
+		from: p,
+		until: m,
+		limits: Object.freeze({
+			global: g,
+			perPlayer: _
+		})
+	});
+}, u = class extends c.Service()("@voltro/CodePort") {}, d = (e) => t(e, [
+	"create",
+	"redeem",
+	"receipt",
+	"exportSubject",
+	"eraseSubject"
+]), f = ({ definition: e, at: t, claims: n, playerClaims: r }) => (e.from === null || t >= e.from) && (e.until === null || t < e.until) && n < e.limits.global && r < e.limits.perPlayer, p = (t, n, i = f) => {
+	if (typeof i != "function") throw e("invalid_input");
+	let a = r(t, [
+		"definition",
+		"at",
+		"claims",
+		"playerClaims"
+	]), o = l(a.definition, n), c = Object.freeze({
+		definition: o,
+		at: s(a.at, 0, 864e13),
+		claims: s(a.claims, 0, 1e5),
+		playerClaims: s(a.playerClaims, 0, 1e5)
+	});
+	if (c.playerClaims > c.claims) throw e("invalid_input");
+	let u = i(c);
+	if (typeof u != "boolean") throw e("invalid_input");
+	return u && f(c);
+}, m = (t) => {
+	if (typeof t != "string" || !/^[A-Za-z0-9_-]{8,120}$/.test(t)) throw e("invalid_input");
+	return t;
+}, h = (e) => {
+	let t = r(e, ["code", "requestId"]);
+	return Object.freeze({
+		code: m(t.code),
+		requestId: i(t.requestId)
+	});
+};
+export { u as CodePort, h as captureCodeIntent, d as captureCodeService, m as captureCodeValue, f as defaultCodeEligibility, l as defineCode, p as resolveCodeEligibility };

package/dist/components.d.ts

@@ -0,0 +1,397 @@
+import { ReactNode } from 'react';
+
+export declare const captureShopOfferView: (input: ShopOfferView) => ShopOfferView;
+
+declare type ContentProps = {
+    readonly title: (key: string) => string;
+    readonly currencyLabel?: ((id: string) => string) | undefined;
+    readonly renderRewards?: ((view: ShopOfferView) => ReactNode) | undefined;
+};
+
+declare type CopyProps = {
+    readonly locale?: 'en' | 'de' | undefined;
+    readonly copy?: ShopUiCopy | undefined;
+};
+
+declare type CopyProps_2 = {
+    readonly locale?: 'en' | 'de' | undefined;
+    readonly copy?: TradeUiCopy | undefined;
+};
+
+declare type EconomyAmountInput = string | number | bigint;
+
+declare type EconomyChannel = 'web' | 'ios' | 'android' | 'steam';
+
+declare type Labels = {
+    readonly itemLabel?: ((instanceId: string) => string) | undefined;
+    readonly currencyLabel?: ((currency: string) => string) | undefined;
+};
+
+export declare const OfferCard: (props: OfferCardProps) => ReactNode;
+
+export declare interface OfferCardProps extends CopyProps, ContentProps {
+    readonly view: ShopOfferView;
+    readonly at: number;
+    readonly busy?: boolean | undefined;
+    readonly onSelect: (view: ShopOfferView, currency: string | undefined) => void;
+}
+
+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';
+};
+
+/** Protected native-modal confirmation. Transport/journal and uncertain recovery remain parent-owned. */
+export declare const PurchaseDialog: (props: PurchaseDialogProps) => ReactNode;
+
+export declare interface PurchaseDialogProps extends CopyProps, ContentProps {
+    readonly open: boolean;
+    readonly view: ShopOfferView;
+    readonly intention: ShopBuyInput;
+    readonly at: number;
+    readonly busy: boolean;
+    readonly error?: unknown;
+    readonly receipt?: ShopOrderReceipt | undefined;
+    readonly onConfirm: (request: ShopBuyInput) => void;
+    readonly onClose: () => void;
+}
+
+/** Mount above transient offer errors/filters; closing an offer never deletes this reference. */
+export declare const PurchaseRecovery: (props: PurchaseRecoveryProps) => ReactNode;
+
+export declare interface PurchaseRecoveryProps extends CopyProps {
+    readonly reference: ShopPurchaseReference | undefined;
+    readonly busy: boolean;
+    readonly error?: unknown;
+    readonly onRetry: (request: ShopBuyInput) => void;
+}
+
+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;
+}
+
+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 ShopGrid: (props: ShopGridProps) => ReactNode;
+
+export declare interface ShopGridProps extends CopyProps, ContentProps {
+    readonly source: {
+        readonly data: readonly ShopOfferView[] | undefined;
+        readonly loading: boolean;
+        readonly error: unknown;
+    };
+    readonly at: number;
+    readonly busy?: boolean | undefined;
+    readonly onSelect: OfferCardProps['onSelect'];
+}
+
+declare interface ShopItemGrant {
+    readonly itemId: string;
+    readonly qty: number;
+}
+
+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 const shopOfferAvailable: (view: ShopOfferView, at: number) => boolean;
+
+declare interface ShopOfferView {
+    readonly offerDigest: string;
+    readonly offer: ShopOffer;
+    readonly price: Price;
+}
+
+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 const shopPayment: (price: Price, currency: string | null, quantity: number) => ShopOrderReceipt["pricePaid"];
+
+declare interface ShopPurchaseReference {
+    readonly version: 1;
+    /** Stable app + authenticated account/tenant scope; no endpoint credentials. */
+    readonly scope: string;
+    readonly request: ShopBuyInput;
+}
+
+export declare interface ShopPurchaseTerms {
+    readonly request: ShopBuyInput;
+    readonly current: ReturnType<typeof shopPayment>;
+    /** The immutable declaration is the ceiling; a personalized discount is not a fixed quote. */
+    readonly maximum: ReturnType<typeof shopPayment>;
+    readonly discountPercent: number;
+}
+
+export declare const shopPurchaseTerms: (input: ShopOfferView, intention: ShopBuyInput) => ShopPurchaseTerms;
+
+export declare interface ShopUiCopy {
+    readonly shop: string;
+    readonly loading: string;
+    readonly unavailable: string;
+    readonly empty: string;
+    readonly choose: string;
+    readonly free: string;
+    readonly oneTime: string;
+    readonly closed: string;
+    readonly providersMissing: string;
+    readonly confirm: string;
+    readonly cancel: string;
+    readonly sending: string;
+    readonly uncertain: string;
+    readonly retry: string;
+    readonly complete: string;
+    readonly invalid: string;
+    readonly originalRequest: string;
+    readonly originalOffer: string;
+    readonly pricePolicy: string;
+    readonly currentPrice: string;
+    readonly maximumPrice: string;
+    readonly quantity: string;
+    readonly endsIn: (seconds: number) => string;
+    readonly discount: (percent: number) => string;
+}
+
+export declare const shopUiCopy: Readonly<Readonly<Record<"en" | "de", ShopUiCopy>>>;
+
+/** Protected native-modal confirmation. Journal/uncertain recovery remain parent-owned. */
+export declare const TradeAcceptDialog: (props: TradeAcceptDialogProps) => ReactNode;
+
+export declare interface TradeAcceptDialogProps extends TradeTermsProps {
+    readonly open: boolean;
+    readonly actorId: string;
+    readonly at: number;
+    readonly intention: TradeAcceptInput;
+    readonly busy: boolean;
+    readonly error?: unknown;
+    readonly receipt?: TradeReceipt | undefined;
+    readonly onConfirm: (intention: TradeAcceptInput) => void;
+    readonly onClose: () => void;
+}
+
+declare interface TradeAcceptInput {
+    readonly tradeId: string;
+    readonly tradeDigest: string;
+    readonly requestId: string;
+}
+
+declare interface TradeCurrencyIntention {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+declare type TradeIntention = {
+    readonly kind: 'propose';
+    readonly input: TradeProposeInput;
+} | {
+    readonly kind: 'accept';
+    readonly input: TradeAcceptInput;
+} | {
+    readonly kind: 'cancel';
+    readonly input: {
+        readonly tradeId: string;
+        readonly requestId: string;
+    };
+};
+
+/** Mount above transient Trade list errors/dialogs; no dismiss action or silent journal deletion. */
+export declare const TradeIntentionRecovery: (props: TradeIntentionRecoveryProps) => ReactNode;
+
+export declare interface TradeIntentionRecoveryProps extends CopyProps_2, Labels {
+    readonly reference: TradeIntentionReference | undefined;
+    readonly scope: string | undefined;
+    readonly busy: boolean;
+    readonly error?: unknown;
+    readonly onRetry: (intention: TradeIntention) => void;
+    readonly onCheckReceipt?: ((requestId: string) => void) | undefined;
+}
+
+declare interface TradeIntentionReference {
+    readonly version: 1;
+    readonly scope: string;
+    readonly request: TradeIntention;
+}
+
+declare interface TradeItemIntention {
+    readonly instanceId: string;
+    readonly qty: number;
+}
+
+declare interface TradeLeg {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+}
+
+declare interface TradeLegDefinition {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly TradeCurrencyIntention[];
+}
+
+export declare const TradeList: (props: TradeListProps) => ReactNode;
+
+export declare interface TradeListProps extends CopyProps_2, Labels {
+    readonly source: {
+        readonly data: readonly TradeView[] | undefined;
+        readonly loading: boolean;
+        readonly error: unknown;
+    };
+    /** Presentation only. The actual server derives its Subject; this never authorizes a write. */
+    readonly actorId: string;
+    readonly at: number;
+    readonly busy?: boolean | undefined;
+    readonly onAccept: (view: TradeView) => void;
+    readonly onCancel: (view: TradeView) => void;
+}
+
+declare interface TradeProposeInput {
+    readonly toId: string | null;
+    readonly offered: TradeLegDefinition;
+    readonly requested: TradeLegDefinition;
+    readonly durationMs: number;
+    readonly requestId: string;
+}
+
+declare interface TradeReceipt {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly trade: TradeView;
+}
+
+declare interface TradeTaxView {
+    readonly leg: 'offered' | 'requested';
+    readonly currency: string;
+    readonly gross: string;
+    readonly net: string;
+    readonly tax: string;
+}
+
+/** Original server disclosure; no current player values, computed price or trust facts. */
+export declare const TradeTerms: (props: TradeTermsProps) => ReactNode;
+
+export declare interface TradeTermsProps extends CopyProps_2, Labels {
+    readonly view: TradeView;
+}
+
+export declare interface TradeUiCopy {
+    readonly title: string;
+    readonly loading: string;
+    readonly unavailable: string;
+    readonly invalid: string;
+    readonly empty: string;
+    readonly offered: string;
+    readonly requested: string;
+    readonly emptyLeg: string;
+    readonly accept: string;
+    readonly cancel: string;
+    readonly close: string;
+    readonly confirm: string;
+    readonly confirmation: string;
+    readonly confirmationHelp: string;
+    readonly expired: string;
+    readonly sending: string;
+    readonly complete: string;
+    readonly recovery: string;
+    readonly uncertain: string;
+    readonly retry: string;
+    readonly checkReceipt: string;
+    readonly reference: string;
+    readonly operation: {
+        readonly propose: string;
+        readonly accept: string;
+        readonly cancel: string;
+    };
+    readonly status: Readonly<Record<TradeView['state'], string>>;
+    readonly expires: (date: string) => string;
+    readonly payment: (gross: string, net: string, tax: string, currency: string) => string;
+}
+
+export declare const tradeUiCopy: Readonly<Readonly<Record<"en" | "de", TradeUiCopy>>>;
+
+declare interface TradeView {
+    readonly tradeId: string;
+    readonly tradeDigest: string;
+    readonly proposerId: string;
+    readonly toId: string | null;
+    readonly offered: TradeLeg;
+    readonly requested: TradeLeg;
+    readonly createdAt: number;
+    readonly expiresAt: number;
+    readonly state: 'proposed' | 'accepted' | 'cancelled' | 'expired';
+    readonly accepterId: string | null;
+    readonly rulesVersion: string;
+    readonly taxes: readonly TradeTaxView[];
+}
+
+export { }