@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/trades.js

@@ -0,0 +1,288 @@
+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 { shopInteger as c } from "./shop.js";
+import { Context as l } from "effect";
+// src/trades.ts
+var u = (t) => {
+	let n = r(t, [
+		"version",
+		"taxBps",
+		"maxDurationMs",
+		"minTrustScore"
+	]), a = i(n.version);
+	if (a === "default.v1") throw e("invalid_input");
+	return Object.freeze({
+		version: a,
+		taxBps: c(n.taxBps ?? 0, 0, 1e4),
+		maxDurationMs: c(n.maxDurationMs ?? 864e5, 1, 316224e5),
+		minTrustScore: c(n.minTrustScore ?? 0, 0, 1e6)
+	});
+}, d = (t) => {
+	let a = r(t, ["items", "currencies"]), s = Object.freeze(n(a.items, 32).map((e) => {
+		let t = r(e, ["instanceId", "qty"]);
+		return Object.freeze({
+			instanceId: i(t.instanceId),
+			qty: c(t.qty, 1, 1e6)
+		});
+	}).sort((e, t) => e.instanceId < t.instanceId ? -1 : +(e.instanceId > t.instanceId))), l = Object.freeze(n(a.currencies, 32).map((e) => {
+		let t = r(e, ["currency", "amount"]);
+		return Object.freeze({
+			currency: i(t.currency),
+			amount: o(t.amount).toString()
+		});
+	}).sort((e, t) => e.currency < t.currency ? -1 : +(e.currency > t.currency)));
+	if (new Set(s.map((e) => e.instanceId)).size !== s.length || new Set(l.map((e) => e.currency)).size !== l.length) throw e("invalid_input");
+	return Object.freeze({
+		items: s,
+		currencies: l
+	});
+}, f = (t, n) => {
+	let r = d(t), i = s(n);
+	for (let t of r.currencies) {
+		let n = i.find((e) => e.id === t.currency);
+		if (!n || BigInt(t.amount) > BigInt(n.cap)) throw e("invalid_currency");
+	}
+	return r;
+}, p = (t) => {
+	let n = r(t, [
+		"toId",
+		"offered",
+		"requested",
+		"durationMs",
+		"requestId"
+	]), a = d(n.offered), o = d(n.requested);
+	if (!a.items.length && !a.currencies.length && !o.items.length && !o.currencies.length || a.items.some((e) => o.items.some((t) => t.instanceId === e.instanceId))) throw e("invalid_input");
+	return Object.freeze({
+		toId: n.toId === null ? null : i(n.toId),
+		offered: a,
+		requested: o,
+		durationMs: c(n.durationMs, 1, 316224e5),
+		requestId: i(n.requestId)
+	});
+}, m = (e, t, n) => {
+	let r = u(n), i = p(e);
+	return Object.freeze({
+		...i,
+		offered: f(i.offered, t),
+		requested: f(i.requested, t),
+		durationMs: c(i.durationMs, 1, r.maxDurationMs)
+	});
+}, h = (t) => {
+	if (typeof t != "string" || !/^[a-f0-9]{64}$/.test(t)) throw e("invalid_input");
+	return t;
+}, g = (e) => {
+	let t = r(e, [
+		"tradeId",
+		"tradeDigest",
+		"requestId"
+	]);
+	return Object.freeze({
+		tradeId: i(t.tradeId),
+		tradeDigest: h(t.tradeDigest),
+		requestId: i(t.requestId)
+	});
+}, _ = (e) => {
+	let t = r(e, ["tradeId", "requestId"]);
+	return Object.freeze({
+		tradeId: i(t.tradeId),
+		requestId: i(t.requestId)
+	});
+}, v = ({ amount: e, rules: t }) => (o(e) * BigInt(t.taxBps) + 9999n) / 10000n, y = (t, n = v) => {
+	let s = r(t, [
+		"currency",
+		"amount",
+		"rules"
+	]), c = u(s.rules), l = i(s.currency), d = o(s.amount);
+	if (typeof n != "function") throw e("invalid_input");
+	let f = Object.freeze({
+		currency: l,
+		amount: d.toString(),
+		rules: c
+	}), p = a(n(f)), m = a(v(f));
+	if (p > d || p > m) throw e("invalid_input");
+	return Object.freeze({
+		currency: l,
+		gross: d.toString(),
+		net: (d - p).toString(),
+		tax: p.toString()
+	});
+}, b = (e, t, n, r) => e.items.every((e) => {
+	let i = t.items.find((t) => t.instanceId === e.instanceId);
+	return i !== void 0 && i.qty >= e.qty && i.tradable && (!i.locked || i.reservationId === r) && (i.expiresAt === null || i.expiresAt > n);
+}), x = (e) => e.at >= e.createdAt && e.at < e.expiresAt && e.expiresAt - e.createdAt <= e.rules.maxDurationMs && e.proposerId !== e.accepterId && (e.proposedToId === null || e.proposedToId === e.accepterId) && e.proposer.allowed && e.accepter.allowed && e.proposer.trustScore >= e.rules.minTrustScore && e.accepter.trustScore >= e.rules.minTrustScore && b(e.offered, e.proposer, e.at, e.tradeId) && b(e.requested, e.accepter, e.at, e.tradeId), S = (t, a, o) => {
+	let s = r(t, [
+		"tenantId",
+		"ownerId",
+		"allowed",
+		"trustScore",
+		"items"
+	]);
+	if (s.tenantId !== a || s.ownerId !== o || typeof s.allowed != "boolean") throw e("invalid_record");
+	let l = Object.freeze(n(s.items, 1e4).map((t) => {
+		let n = r(t, [
+			"instanceId",
+			"itemId",
+			"qty",
+			"tradable",
+			"locked",
+			"reservationId",
+			"expiresAt"
+		]);
+		if (typeof n.tradable != "boolean" || typeof n.locked != "boolean" || n.locked === !1 && n.reservationId !== null) throw e("invalid_record");
+		return Object.freeze({
+			instanceId: i(n.instanceId),
+			itemId: i(n.itemId),
+			qty: c(n.qty, 1, 1e6),
+			tradable: n.tradable,
+			locked: n.locked,
+			reservationId: n.reservationId === null ? null : i(n.reservationId),
+			expiresAt: n.expiresAt === null ? null : c(n.expiresAt, 0, 864e13)
+		});
+	}));
+	if (new Set(l.map((e) => e.instanceId)).size !== l.length) throw e("invalid_record");
+	return Object.freeze({
+		tenantId: a,
+		ownerId: o,
+		allowed: s.allowed,
+		trustScore: c(s.trustScore, 0, 1e6),
+		items: l
+	});
+}, C = (t, n = x) => {
+	let a = r(t, [
+		"tenantId",
+		"proposerId",
+		"accepterId",
+		"tradeId",
+		"proposedToId",
+		"createdAt",
+		"at",
+		"expiresAt",
+		"rules",
+		"currencies",
+		"offered",
+		"requested",
+		"proposer",
+		"accepter"
+	]), o = i(a.tenantId), l = i(a.proposerId), d = i(a.accepterId), p = u(a.rules), m = s(a.currencies), h = i(a.tradeId), g = c(a.createdAt, 0, 864e13), _ = c(a.at, 0, 864e13), v = c(a.expiresAt, 0, 864e13), y = Object.freeze({
+		tenantId: o,
+		proposerId: l,
+		accepterId: d,
+		tradeId: h,
+		createdAt: g,
+		proposedToId: a.proposedToId === null ? null : i(a.proposedToId),
+		at: _,
+		expiresAt: v,
+		rules: p,
+		currencies: m,
+		offered: f(a.offered, m),
+		requested: f(a.requested, m),
+		proposer: S(a.proposer, o, l),
+		accepter: S(a.accepter, o, d)
+	});
+	if (typeof n != "function") throw e("invalid_input");
+	let b = n(y);
+	if (typeof b != "boolean" || b && !x(y)) throw e("invalid_input");
+	return b;
+}, w = class extends l.Service()("@voltro/TradesPort") {}, T = (e) => t(e, [
+	"propose",
+	"accept",
+	"cancel",
+	"mine",
+	"receipt",
+	"rebuild",
+	"exportSubject",
+	"eraseSubject"
+]), E = (t) => {
+	let s = r(t, [
+		"tradeId",
+		"tradeDigest",
+		"proposerId",
+		"toId",
+		"offered",
+		"requested",
+		"createdAt",
+		"expiresAt",
+		"state",
+		"accepterId",
+		"rulesVersion",
+		"taxes"
+	], "invalid_record"), l = d(s.offered), u = d(s.requested), f = i(s.proposerId), p = s.toId === null ? null : i(s.toId), m = s.accepterId === null ? null : i(s.accepterId), g = c(s.createdAt, 0, 864e13), _ = c(s.expiresAt, 0, 864e13), v = i(s.rulesVersion), y = h(s.tradeDigest);
+	if (![
+		"proposed",
+		"accepted",
+		"cancelled",
+		"expired"
+	].includes(String(s.state)) || v === "default.v1" || _ <= g || _ - g > 316224e5 || p === f || !l.items.length && !l.currencies.length && !u.items.length && !u.currencies.length || l.items.some((e) => u.items.some((t) => t.instanceId === e.instanceId)) || (s.state === "accepted" ? m === null || m === f || p !== null && p !== m : m !== null)) throw e("invalid_record");
+	let b = Object.freeze(n(s.taxes, 64).map((t) => {
+		let n = r(t, [
+			"leg",
+			"currency",
+			"gross",
+			"net",
+			"tax"
+		], "invalid_record");
+		if (n.leg !== "offered" && n.leg !== "requested") throw e("invalid_record");
+		let s = o(n.gross), c = a(n.net), l = a(n.tax);
+		if (s !== c + l) throw e("invalid_record");
+		return Object.freeze({
+			leg: n.leg,
+			currency: i(n.currency),
+			gross: s.toString(),
+			net: c.toString(),
+			tax: l.toString()
+		});
+	})), x = [...l.currencies.map((e) => ({
+		leg: "offered",
+		...e
+	})), ...u.currencies.map((e) => ({
+		leg: "requested",
+		...e
+	}))];
+	if (b.length !== x.length || b.some((e, t) => e.leg !== x[t].leg || e.currency !== x[t].currency || e.gross !== x[t].amount)) throw e("invalid_record");
+	return Object.freeze({
+		tradeId: i(s.tradeId),
+		tradeDigest: y,
+		proposerId: f,
+		toId: p,
+		offered: l,
+		requested: u,
+		createdAt: g,
+		expiresAt: _,
+		state: s.state,
+		accepterId: m,
+		rulesVersion: v,
+		taxes: b
+	});
+}, D = (e) => {
+	let t = r(e, [
+		"operationId",
+		"requestId",
+		"trade"
+	], "invalid_record");
+	return Object.freeze({
+		operationId: i(t.operationId),
+		requestId: i(t.requestId),
+		trade: E(t.trade)
+	});
+}, O = (t) => {
+	let n = r(t, [
+		"requestId",
+		"state",
+		"receipt"
+	], "invalid_record"), a = i(n.requestId);
+	if (n.state === "not-observed" && !Object.hasOwn(n, "receipt")) return Object.freeze({
+		requestId: a,
+		state: "not-observed"
+	});
+	if (n.state !== "fulfilled") throw e("invalid_record");
+	let o = D(n.receipt);
+	if (o.requestId !== a) throw e("invalid_record");
+	return Object.freeze({
+		requestId: a,
+		state: "fulfilled",
+		receipt: o
+	});
+};
+export { w as TradesPort, f as captureTradeLeg, O as captureTradeObservation, S as captureTradeParticipantAuthority, p as captureTradeProposeIntention, D as captureTradeReceipt, E as captureTradeView, T as captureTradesService, x as defaultTradeEligibilityPolicy, v as defaultTradeTaxPolicy, u as defineTradeRules, C as resolveTradeEligibility, y as resolveTradeTax, g as tradeAcceptIntent, _ as tradeCancelIntent, m as tradeProposeIntent };

package/dist/tradesPort.fixture.js

@@ -0,0 +1,93 @@
+import { TradesPort as e } from "./trades.js";
+import { EconomyPort as t } from "./port.js";
+import { economyPlugin as n } from "./plugin.js";
+import { tradeEscrowAt as r } from "./tradeEscrow.testFixtures.js";
+import { tradeStoreFixture as i } from "./tradeStore.testFixtures.js";
+import { Effect as a, Layer as o } from "effect";
+import { InMemoryDataStore as s } from "@voltro/runtime";
+// src/tradesPort.fixture.ts
+var c = {
+	app: {
+		name: "trades-fixture",
+		type: "api",
+		voltroVersion: "0.83.1"
+	},
+	config: {},
+	env: {},
+	logger: {
+		info() {},
+		warn() {},
+		error() {},
+		debug() {}
+	}
+}, l = a.gen(function* () {
+	let e = new s(), t = yield* a.promise(() => i(e, "fixture")), { currencies: o, economy: l, now: u, ...d } = t.options, f = r, p = n({
+		currencies: o,
+		now: () => f,
+		trades: d
+	});
+	return yield* a.promise(async () => {
+		await p.bindDataStore?.(e);
+	}), Object.freeze({
+		store: e,
+		base: t,
+		plugin: p,
+		advance: (e) => {
+			f = r + e;
+		},
+		close: a.suspend(() => p.onDeactivate?.(c))
+	});
+}), u = o.effectContext(a.acquireRelease(l, (e) => e.close).pipe(a.flatMap((e) => o.build(e.plugin.services)))), d = Object.freeze({
+	kind: "port",
+	tag: e,
+	fakeLayer: u,
+	probe: {
+		run: () => a.scoped(a.gen(function* () {
+			let n = yield* e, r = yield* t, i = {
+				type: "user",
+				id: "a",
+				tenantId: "fixture"
+			}, a = yield* n.propose(i, {
+				toId: "b",
+				offered: {
+					items: [],
+					currencies: [{
+						currency: "gold",
+						amount: "30"
+					}]
+				},
+				requested: {
+					items: [],
+					currencies: [{
+						currency: "gold",
+						amount: "10"
+					}]
+				},
+				durationMs: 500,
+				requestId: "scoped.proposal"
+			}), o = {
+				tradeId: a.trade.tradeId,
+				tradeDigest: a.trade.tradeDigest,
+				requestId: "scoped.accept"
+			}, s = {
+				...i,
+				id: "b"
+			}, c = yield* n.accept(s, o), l = yield* n.accept(s, o), u = yield* n.receipt(s, { requestId: o.requestId }), d = yield* r.mine(i);
+			return {
+				same: c.operationId === l.operationId,
+				observed: u.state,
+				state: c.trade.state,
+				balance: d[0].balance,
+				tax: c.trade.taxes.map((e) => e.tax)
+			};
+		}).pipe(a.provide(u))),
+		expected: {
+			same: !0,
+			observed: "fulfilled",
+			state: "accepted",
+			balance: "79",
+			tax: ["1", "1"]
+		}
+	}
+});
+export { u as tradesFakeLayer, l as tradesPortFixture, d as tradesPortSystemFixture };

package/dist/walletEscrow.js

@@ -0,0 +1,105 @@
+import { economyError as e } from "./errors.js";
+import { dataObject as t, identifier as n } from "./capture.js";
+import { nonNegativeAmount as r, positiveAmount as i } from "./amount.js";
+import { captureAccount as a } from "./ledger.js";
+// src/walletEscrow.ts
+var o = (t) => {
+	let n = a(t);
+	if (n.kind !== "wallet") throw e("invalid_input");
+	return n;
+}, s = (e) => {
+	let r = t(e, [
+		"tenantId",
+		"owner",
+		"reservationId",
+		"currency"
+	]);
+	return Object.freeze({
+		tenantId: n(r.tenantId),
+		owner: o(r.owner),
+		reservationId: n(r.reservationId),
+		currency: n(r.currency)
+	});
+}, c = (e) => {
+	let n = t(e, [
+		"tenantId",
+		"owner",
+		"reservationId",
+		"currency",
+		"amount"
+	]);
+	return Object.freeze({
+		...s({
+			tenantId: n.tenantId,
+			owner: n.owner,
+			reservationId: n.reservationId,
+			currency: n.currency
+		}),
+		amount: i(n.amount).toString()
+	});
+}, l = (n) => {
+	let r = t(n, [
+		"tenantId",
+		"owner",
+		"reservationId",
+		"currency",
+		"to"
+	]), i = s({
+		tenantId: r.tenantId,
+		owner: r.owner,
+		reservationId: r.reservationId,
+		currency: r.currency
+	}), a = o(r.to);
+	if (i.owner.ownerKind === a.ownerKind && i.owner.ownerId === a.ownerId) throw e("invalid_input");
+	return Object.freeze({
+		...i,
+		to: a
+	});
+}, u = (i) => {
+	let a = t(i, [
+		"tenantId",
+		"owner",
+		"reservationId",
+		"currency",
+		"to",
+		"taxAmount",
+		"taxAccountId"
+	]), o = l({
+		tenantId: a.tenantId,
+		owner: a.owner,
+		reservationId: a.reservationId,
+		currency: a.currency,
+		to: a.to
+	}), s = n(a.taxAccountId ?? "escrow.tax.default");
+	if (!s.startsWith("escrow.tax.")) throw e("invalid_input");
+	return Object.freeze({
+		...o,
+		taxAmount: r(a.taxAmount).toString(),
+		taxAccountId: s
+	});
+}, d = (n) => {
+	let r = t(n, [
+		"tenantId",
+		"owner",
+		"reservationId",
+		"currency",
+		"amount",
+		"to",
+		"taxAmount",
+		"taxAccountId"
+	]), a = u({
+		tenantId: r.tenantId,
+		owner: r.owner,
+		reservationId: r.reservationId,
+		currency: r.currency,
+		to: r.to,
+		taxAmount: r.taxAmount,
+		taxAccountId: r.taxAccountId
+	}), o = i(r.amount).toString();
+	if (BigInt(a.taxAmount) > BigInt(o)) throw e("invalid_amount");
+	return Object.freeze({
+		...a,
+		amount: o
+	});
+};
+export { o as captureEscrowWallet, s as captureWalletEscrowInput, c as captureWalletEscrowReserveInput, d as captureWalletEscrowReserveTaxSettleInput, l as captureWalletEscrowSettleInput, u as captureWalletEscrowTaxSettleInput };