@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/tradeStore.testFixtures.js

@@ -0,0 +1,72 @@
+import { economyError as e } from "./errors.js";
+import { tradeTables as t } from "./tradeTables.entity.js";
+import { dataStoreTrades as n } from "./tradeStore.server.js";
+import { tradeEscrowAt as r, tradeEscrowFixture as i, tradeEscrowMachine as a } from "./tradeEscrow.testFixtures.js";
+import { Effect as o } from "effect";
+import { and as s, ensureTableRegistered as c, eq as l, queryFor as u } from "@voltro/database";
+import { prepareSqlMutation as d } from "@voltro/database/sql";
+import { inventoryItemsTable as f, inventorySubjectsTable as p } from "@voltro/plugin-inventory/server";
+// src/tradeStore.testFixtures.ts
+var m = async (m, h = "tenant") => {
+	t.forEach(c);
+	let g = await i(m, h), _ = {
+		read: (t) => o.gen(function* () {
+			let e = yield* g.inventory.mine(g.user(t.ownerId)), n = yield* g.inventory.reservationEvidence(a, {
+				tenantId: t.tenantId,
+				owner: {
+					ownerKind: "player",
+					ownerId: t.ownerId
+				},
+				reservationId: t.tradeId
+			});
+			return {
+				tenantId: t.tenantId,
+				ownerId: t.ownerId,
+				allowed: !0,
+				trustScore: 10,
+				items: e.map((e) => ({
+					instanceId: e.id,
+					itemId: e.itemId,
+					qty: e.qty,
+					tradable: g.item.tradable,
+					locked: e.locked,
+					reservationId: n.state === "reserved" && n.items.some((t) => t.instance.id === e.id) ? t.tradeId : null,
+					expiresAt: e.expiresAt
+				}))
+			};
+		}).pipe(o.mapError(() => e("unavailable"))),
+		prepare: (t) => o.sync(() => d(g.store, async (n) => {
+			for (let r of [...t.participants].sort((e, t) => e.ownerId < t.ownerId ? -1 : 1)) {
+				if (await n.updateMany(p.tableName, { admission: 0 }, { where: s(l("tenantId", t.tenantId), l("ownerId", r.ownerId), l("erased", !1)) }) !== 1) throw e("erased");
+				let i = await n.query(u(f).where(s(l("tenantId", t.tenantId), l("ownerId", r.ownerId))).descriptor);
+				if (i.length !== r.items.length || r.items.some((e) => {
+					let t = i.find((t) => t.id === e.instanceId);
+					return !t || t.qty !== e.qty || t.locked !== e.locked || t.itemId !== e.itemId;
+				})) throw e("conflict");
+			}
+		}))
+	}, v = {
+		...g.options,
+		authority: _,
+		inventory: g.inventory,
+		now: () => r
+	}, y = n(g.store, v), b = {
+		toId: "b",
+		offered: g.terms.offered,
+		requested: g.terms.requested,
+		durationMs: 500,
+		requestId: "proposal"
+	}, x = (e, t = "accept") => ({
+		tradeId: e.trade.tradeId,
+		tradeDigest: e.trade.tradeDigest,
+		requestId: t
+	});
+	return {
+		...g,
+		options: v,
+		service: y,
+		proposed: b,
+		accept: x
+	};
+};
+export { m as tradeStoreFixture };

package/dist/tradeTables.entity.js

@@ -0,0 +1,65 @@
+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/tradeTables.entity.ts
+var s = () => a().maxLength(120).externalId().sensitive("pii"), c = i("_voltro_eco_trade_tenants", {
+	id: t({ prefix: "ett" }),
+	tenantId: s(),
+	admission: n().serverOnly(),
+	tradesCount: n().serverOnly()
+}).index(["tenantId"]), l = i("_voltro_eco_trade_subjects", {
+	id: t({ prefix: "ets" }),
+	tenantId: s(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	erased: e().serverOnly(),
+	admission: n().serverOnly(),
+	operationsCount: n().serverOnly()
+}).index(["tenantId", "ownerId"]), u = i("_voltro_eco_trades", {
+	id: t({ prefix: "etd" }),
+	tenantId: s(),
+	proposerKey: a().maxLength(64).serverOnly(),
+	targetKey: a().maxLength(64).nullable().serverOnly(),
+	accepterKey: a().maxLength(64).nullable().serverOnly(),
+	accepted: e().serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"proposed",
+		"accepted",
+		"cancelled",
+		"expired",
+		"erased"
+	]).serverOnly(),
+	admission: n().serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	proposal: r().nullable().serverOnly(),
+	closing: r().nullable().serverOnly(),
+	createdAt: o().nullable().serverOnly(),
+	expiresAt: o().nullable().serverOnly()
+}).index(["tenantId", "proposerKey"]).index(["tenantId", "targetKey"]).index(["tenantId", "accepterKey"]), d = i("_voltro_eco_trade_operations", {
+	id: t({ prefix: "eto" }),
+	tenantId: s(),
+	ownerKey: a().maxLength(64).serverOnly(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	tradeId: a().maxLength(64).nullable().serverOnly(),
+	kind: a().maxLength(16).oneOf([
+		"propose",
+		"accept",
+		"cancel",
+		"expire"
+	]).serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"fulfilled",
+		"erased"
+	]).serverOnly(),
+	admission: n().serverOnly(),
+	sequence: n().nullable().serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	request: r().nullable().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	at: o().nullable().serverOnly()
+}).index(["tenantId", "ownerKey"]).index(["tenantId", "tradeId"]), f = [
+	c,
+	l,
+	u,
+	d
+];
+export { d as tradeOperationsTable, l as tradeSubjectsTable, f as tradeTables, c as tradeTenantsTable, u as tradesTable };

package/dist/tradeUiCopy.js

@@ -0,0 +1,78 @@
+// src/tradeUiCopy.ts
+var e = Object.freeze({
+	en: Object.freeze({
+		title: "Trades",
+		loading: "Loading trades…",
+		unavailable: "Trades could not be refreshed. Check the connection and refresh.",
+		invalid: "These trade details could not be verified. Refresh before continuing.",
+		empty: "No trades to show.",
+		offered: "Proposer offers",
+		requested: "Counterparty offers",
+		emptyLeg: "No items or currency selected.",
+		accept: "Review trade",
+		cancel: "Cancel trade",
+		close: "Close",
+		confirm: "Accept these terms",
+		confirmation: "Confirm trade",
+		confirmationHelp: "Review both sides and the tax deduction. Acceptance uses these original terms; the server checks availability and permission again.",
+		expired: "This trade has expired. Refresh to check its final outcome.",
+		sending: "Checking the original outcome…",
+		complete: "Trade accepted.",
+		recovery: "Unresolved trade request",
+		uncertain: "The outcome is not confirmed. Check the receipt or retry the saved request.",
+		retry: "Retry saved request",
+		checkReceipt: "Check receipt",
+		reference: "Recovery reference",
+		operation: Object.freeze({
+			propose: "Propose trade",
+			accept: "Accept trade",
+			cancel: "Cancel trade"
+		}),
+		status: Object.freeze({
+			proposed: "Awaiting acceptance",
+			accepted: "Accepted",
+			cancelled: "Cancelled",
+			expired: "Expired"
+		}),
+		expires: (e) => `Expires ${e}`,
+		payment: (e, t, n, r) => `${e} ${r} offered · ${t} received · ${n} tax`
+	}),
+	de: Object.freeze({
+		title: "Handel",
+		loading: "Handel wird geladen…",
+		unavailable: "Der Handel konnte nicht aktualisiert werden. Verbindung prüfen und neu laden.",
+		invalid: "Diese Handelsdetails konnten nicht geprüft werden. Vor dem Fortfahren neu laden.",
+		empty: "Keine Handelsvorgänge vorhanden.",
+		offered: "Angebot des Vorschlagenden",
+		requested: "Angebot der Gegenseite",
+		emptyLeg: "Keine Items oder Währung gewählt.",
+		accept: "Handel prüfen",
+		cancel: "Handel abbrechen",
+		close: "Schließen",
+		confirm: "Diese Bedingungen annehmen",
+		confirmation: "Handel bestätigen",
+		confirmationHelp: "Beide Seiten und den Steuerabzug prüfen. Die Annahme verwendet diese Originalbedingungen; der Server prüft Verfügbarkeit und Berechtigung erneut.",
+		expired: "Dieser Handel ist abgelaufen. Neu laden, um das endgültige Ergebnis zu prüfen.",
+		sending: "Das Originalergebnis wird geprüft…",
+		complete: "Handel angenommen.",
+		recovery: "Ungelöste Handelsanfrage",
+		uncertain: "Das Ergebnis ist nicht bestätigt. Beleg prüfen oder die gespeicherte Anfrage erneut senden.",
+		retry: "Gespeicherte Anfrage erneut senden",
+		checkReceipt: "Beleg prüfen",
+		reference: "Recovery-Referenz",
+		operation: Object.freeze({
+			propose: "Handel vorschlagen",
+			accept: "Handel annehmen",
+			cancel: "Handel abbrechen"
+		}),
+		status: Object.freeze({
+			proposed: "Annahme ausstehend",
+			accepted: "Angenommen",
+			cancelled: "Abgebrochen",
+			expired: "Abgelaufen"
+		}),
+		expires: (e) => `Läuft ab: ${e}`,
+		payment: (e, t, n, r) => `${e} ${r} angeboten · ${t} empfangen · ${n} Steuer`
+	})
+});
+export { e as tradeUiCopy };

package/dist/trades.d.ts

@@ -0,0 +1,246 @@
+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 captureTradeLeg: (input: TradeLegDefinition | TradeLeg, declarations: readonly CurrencyDefinition[]) => TradeLeg;
+
+export declare const captureTradeObservation: (input: unknown) => TradeObservation;
+
+export declare const captureTradeParticipantAuthority: (value: unknown, tenantId: string, expectedOwner: string) => TradeParticipantAuthority;
+
+/** Pure detached wire shape only. New admission must still validate actual
+ * currencies and rules; originals compare before current declarations. */
+export declare const captureTradeProposeIntention: (input: TradeProposeInput) => Readonly<{
+    toId: string | null;
+    offered: TradeLeg;
+    requested: TradeLeg;
+    durationMs: number;
+    requestId: string;
+}>;
+
+export declare const captureTradeReceipt: (input: unknown) => TradeReceipt;
+
+export declare const captureTradesService: (input: TradesService) => TradesService;
+
+/** Browser-safe detached receipt shape, never a substitute for server custody/permission proof. */
+export declare const captureTradeView: (input: unknown) => TradeView;
+
+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 defaultTradeEligibilityPolicy: TradeEligibilityPolicy;
+
+/** Seller deduction, rounded upward; gross = net + tax exactly. No real-money
+ * channel or minted treasury value is part of a tax projection. */
+export declare const defaultTradeTaxPolicy: TradeTaxPolicy;
+
+export declare const defineTradeRules: (input: TradeRulesDefinition | TradeRules) => TradeRules;
+
+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 const resolveTradeEligibility: (input: TradeEligibilityContext, policy?: TradeEligibilityPolicy) => boolean;
+
+export declare const resolveTradeTax: (input: TradeTaxContext, policy?: TradeTaxPolicy) => Readonly<{
+    currency: string;
+    gross: string;
+    net: string;
+    tax: string;
+}>;
+
+export declare interface TradeAcceptInput {
+    readonly tradeId: string;
+    readonly tradeDigest: string;
+    readonly requestId: string;
+}
+
+export declare const tradeAcceptIntent: (input: TradeAcceptInput) => TradeAcceptInput;
+
+export declare const tradeCancelIntent: (input: {
+    readonly tradeId: string;
+    readonly requestId: string;
+}) => Readonly<{
+    tradeId: string;
+    requestId: string;
+}>;
+
+export declare interface TradeCurrencyIntention {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export declare interface TradeEligibilityContext {
+    readonly tenantId: string;
+    readonly proposerId: string;
+    readonly accepterId: string;
+    readonly tradeId: string;
+    readonly proposedToId: string | null;
+    readonly createdAt: number;
+    readonly at: number;
+    readonly expiresAt: number;
+    readonly rules: TradeRules;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly offered: TradeLeg;
+    readonly requested: TradeLeg;
+    readonly proposer: TradeParticipantAuthority;
+    readonly accepter: TradeParticipantAuthority;
+}
+
+export declare type TradeEligibilityPolicy = (input: TradeEligibilityContext) => boolean;
+
+export declare interface TradeItemAuthority {
+    readonly instanceId: string;
+    readonly itemId: string;
+    readonly qty: number;
+    readonly tradable: boolean;
+    readonly locked: boolean;
+    readonly reservationId: string | null;
+    readonly expiresAt: number | null;
+}
+
+export declare interface TradeItemIntention {
+    readonly instanceId: string;
+    readonly qty: number;
+}
+
+export declare interface TradeLeg {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+}
+
+export declare interface TradeLegDefinition {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly TradeCurrencyIntention[];
+}
+
+export declare type TradeObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: TradeReceipt;
+};
+
+export declare interface TradeParticipantAuthority {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly allowed: boolean;
+    readonly trustScore: number;
+    readonly items: readonly TradeItemAuthority[];
+}
+
+export declare interface TradeProposeInput {
+    readonly toId: string | null;
+    readonly offered: TradeLegDefinition;
+    readonly requested: TradeLegDefinition;
+    readonly durationMs: number;
+    readonly requestId: string;
+}
+
+export declare const tradeProposeIntent: (input: TradeProposeInput, currencies: readonly CurrencyDefinition[], rulesInput: TradeRulesDefinition) => Readonly<{
+    offered: TradeLeg;
+    requested: TradeLeg;
+    durationMs: number;
+    toId: string | null;
+    requestId: string;
+}>;
+
+export declare interface TradeReceipt {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly trade: TradeView;
+}
+
+export declare interface TradeRules {
+    readonly version: string;
+    readonly taxBps: number;
+    readonly maxDurationMs: number;
+    readonly minTrustScore: number;
+}
+
+export declare interface TradeRulesDefinition {
+    readonly version: string;
+    readonly taxBps?: number;
+    readonly maxDurationMs?: number;
+    readonly minTrustScore?: number;
+}
+
+export declare class TradesPort extends TradesPort_base {
+}
+
+declare const TradesPort_base: Context.ServiceClass<TradesPort, "@voltro/TradesPort", TradesService>;
+
+/** Full owning service; no default implementation or escrow installation is
+ * inferred from a Tag. SQL reservation/transfer/expiry/privacy own acceptance. */
+export declare interface TradesService {
+    readonly propose: (subject: Subject, input: TradeProposeInput) => Effect.Effect<TradeReceipt, EconomyError>;
+    readonly accept: (subject: Subject, input: TradeAcceptInput) => Effect.Effect<TradeReceipt, EconomyError>;
+    readonly cancel: (subject: Subject, input: {
+        readonly tradeId: string;
+        readonly requestId: string;
+    }) => Effect.Effect<TradeReceipt, EconomyError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly TradeView[], EconomyError>;
+    readonly receipt: (subject: Subject, input: {
+        readonly requestId: string;
+    }) => Effect.Effect<TradeObservation, EconomyError>;
+    readonly rebuild: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly tradeId: string;
+    }) => Effect.Effect<TradeView, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare interface TradeTaxContext {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+    readonly rules: TradeRules;
+}
+
+export declare type TradeTaxPolicy = (input: TradeTaxContext) => EconomyAmountInput;
+
+export declare interface TradeTaxView {
+    readonly leg: 'offered' | 'requested';
+    readonly currency: string;
+    readonly gross: string;
+    readonly net: string;
+    readonly tax: string;
+}
+
+export 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 { }

package/dist/trades.fixture.js

@@ -0,0 +1,102 @@
+import { captureTradeLeg as e, defaultTradeEligibilityPolicy as t, defaultTradeTaxPolicy as n, defineTradeRules as r, resolveTradeEligibility as i, resolveTradeTax as a } from "./trades.js";
+import { Effect as o } from "effect";
+// src/trades.fixture.ts
+var s = () => {
+	let t = [{
+		id: "test.gold",
+		kind: "soft"
+	}], n = r({
+		version: "fixture.trade.v1",
+		taxBps: 500,
+		minTrustScore: 50
+	}), i = e({
+		items: [{
+			instanceId: "instance.a",
+			qty: 2
+		}],
+		currencies: []
+	}, t), a = e({
+		items: [],
+		currencies: [{
+			currency: "test.gold",
+			amount: "10"
+		}]
+	}, t);
+	return Object.freeze({
+		currencies: t,
+		rules: n,
+		tenantId: "fixture",
+		tradeId: "trade.a",
+		proposerId: "a",
+		accepterId: "b",
+		proposedToId: "b",
+		createdAt: 0,
+		at: 100,
+		expiresAt: 1e3,
+		offered: i,
+		requested: a,
+		proposer: {
+			tenantId: "fixture",
+			ownerId: "a",
+			allowed: !0,
+			trustScore: 80,
+			items: [{
+				instanceId: "instance.a",
+				itemId: "test.potion",
+				qty: 3,
+				tradable: !0,
+				locked: !0,
+				reservationId: "trade.a",
+				expiresAt: 5e3
+			}]
+		},
+		accepter: {
+			tenantId: "fixture",
+			ownerId: "b",
+			allowed: !0,
+			trustScore: 60,
+			items: []
+		}
+	});
+}, c = s(), l = Object.freeze({
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => o.sync(() => a({
+			currency: "test.gold",
+			amount: "100",
+			rules: c.rules
+		})),
+		expected: {
+			currency: "test.gold",
+			gross: "100",
+			net: "95",
+			tax: "5"
+		}
+	},
+	overrideProbe: {
+		run: () => o.sync(() => a({
+			currency: "test.gold",
+			amount: "100",
+			rules: c.rules
+		}, () => "2")),
+		expected: {
+			currency: "test.gold",
+			gross: "100",
+			net: "98",
+			tax: "2"
+		}
+	}
+}), u = Object.freeze({
+	kind: "slot",
+	defaultImplementation: t,
+	defaultProbe: {
+		run: () => o.sync(() => i(c)),
+		expected: !0
+	},
+	overrideProbe: {
+		run: () => o.sync(() => i(c, () => !1)),
+		expected: !1
+	}
+});
+export { u as tradeEligibilitySystemFixture, s as tradeFixture, l as tradeTaxSystemFixture };