@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/googleIapSubscription.server.js

@@ -0,0 +1,183 @@
+import { economyError as e } from "./errors.js";
+import { dataList as t, dataObject as n, identifier as r } from "./capture.js";
+import { captureIapPaidAmount as i, iapTimestamp as a } from "./iap.js";
+import { canonicalDataJson as o } from "./canonicalDataJson.js";
+import { captureIapTransactionFacts as s } from "./iapVerification.server.js";
+import { iapProviderRecord as c, iapProviderText as l, iapProviderTimestamp as u } from "./iapProviderCapture.server.js";
+import { createHash as d } from "node:crypto";
+// src/googleIapSubscription.server.ts
+var f = (i) => {
+	let a = t(i === void 0 ? [] : i, 4096).map((e) => {
+		let t = n(e, [
+			"offerId",
+			"offerVersion",
+			"basePlanId",
+			"storeOfferId"
+		]);
+		return Object.freeze({
+			offerId: r(t.offerId),
+			offerVersion: r(t.offerVersion),
+			basePlanId: r(t.basePlanId),
+			storeOfferId: t.storeOfferId === null ? null : r(t.storeOfferId)
+		});
+	});
+	if (new Set(a.map((e) => e.offerId + ":" + e.offerVersion)).size !== a.length) throw e("invalid_input");
+	return Object.freeze(a);
+}, p = (t, n, r) => {
+	let i = c(t), a = r.find((e) => e.offerId === n.product.offer.id && e.offerVersion === n.product.offer.version);
+	if (!a || i.basePlanId !== a.basePlanId || (i.offerId ?? null) !== a.storeOfferId) throw e("forbidden");
+}, m = (t) => {
+	let n = c(t), r = n.units ?? "0", a = n.nanos ?? 0;
+	if (typeof r != "string" || !/^(0|[1-9][0-9]{0,18})$/.test(r) || typeof a != "number" || !Number.isInteger(a) || a < 0 || a > 999999999) throw e("invalid_record");
+	let o = i({
+		currency: n.currencyCode,
+		units: (BigInt(r) * 1000000000n + BigInt(a)).toString(),
+		scale: 9
+	});
+	if (!o) throw e("invalid_record");
+	return o;
+}, h = (e) => d("sha256").update(e).digest("hex"), g = (t) => {
+	if (t === "ACKNOWLEDGEMENT_STATE_PENDING") return "pending";
+	if (t === "ACKNOWLEDGEMENT_STATE_ACKNOWLEDGED") return "acknowledged";
+	throw e("invalid_record");
+}, _ = (n, r, i, a) => {
+	let o = c(n), s = c(o.externalAccountIdentifiers);
+	if (r.product.kind !== "subscription" || s.obfuscatedExternalAccountId !== r.accountToken || o.linkedPurchaseToken !== void 0 || o.outOfAppPurchaseContext !== void 0 || (i === "sandbox" ? o.testPurchase === void 0 : o.testPurchase !== void 0)) throw e("forbidden");
+	if (o.testPurchase !== void 0 && c(o.testPurchase), typeof o.subscriptionState != "string" || ![
+		"SUBSCRIPTION_STATE_PENDING",
+		"SUBSCRIPTION_STATE_ACTIVE",
+		"SUBSCRIPTION_STATE_PAUSED",
+		"SUBSCRIPTION_STATE_IN_GRACE_PERIOD",
+		"SUBSCRIPTION_STATE_ON_HOLD",
+		"SUBSCRIPTION_STATE_CANCELED",
+		"SUBSCRIPTION_STATE_EXPIRED",
+		"SUBSCRIPTION_STATE_PENDING_PURCHASE_CANCELED"
+	].includes(o.subscriptionState)) throw e("invalid_record");
+	let d = t(o.lineItems, 32, "invalid_record");
+	if (d.length !== 1) throw e("forbidden");
+	let f = c(d[0]);
+	if (f.productId !== r.product.storeProductId || f.itemReplacement !== void 0 || f.deferredItemReplacement !== void 0 || f.deferredItemRemoval !== void 0 || f.autoRenewingPlan === void 0 == (f.prepaidPlan === void 0)) throw e("forbidden");
+	return c(f.autoRenewingPlan ?? f.prepaidPlan), p(f.offerDetails, r, a), Object.freeze({
+		orderId: l(f.latestSuccessfulOrderId, 512),
+		expiresAt: u(f.expiryTime),
+		startedAt: u(o.startTime),
+		acknowledgement: g(o.acknowledgementState),
+		state: o.subscriptionState
+	});
+}, v = (n, r, i, a, l, d, f = i.orderId) => {
+	let g = c(n);
+	if (g.orderId !== f || g.purchaseToken !== r.intent.receipt || ![
+		"PROCESSED",
+		"PARTIALLY_REFUNDED",
+		"REFUNDED"
+	].includes(String(g.state))) throw e("forbidden");
+	let _ = t(g.lineItems, 32, "invalid_record");
+	if (_.length !== 1) throw e("forbidden");
+	let v = c(_[0]), y = c(v.subscriptionDetails), b = c(g.orderHistory);
+	if (v.productId !== r.product.storeProductId || v.oneTimePurchaseDetails !== void 0 || v.paidAppDetails !== void 0) throw e("forbidden");
+	p(y, r, d);
+	let x = c(y.offerPhaseDetails), S = [
+		"baseDetails",
+		"introductoryPriceDetails",
+		"freeTrialDetails"
+	].filter((e) => x[e] !== void 0);
+	if (S.length !== 1 || x.prorationPeriodDetails !== void 0) throw e("forbidden");
+	c(x[S[0]]);
+	let C = m(g.total), w = m(v.total);
+	if (o(C) !== o(w)) throw e("invalid_record");
+	let T = u(c(b.processedEvent).eventTime), E = u(y.servicePeriodStartTime), D = u(y.servicePeriodEndTime), O = u(g.lastEventTime);
+	if (E > T || T >= D || i.startedAt > E || O < T || O > r.at || b.cancellationEvent !== void 0) throw e("invalid_record");
+	let k = s({
+		channel: "android",
+		environment: l,
+		applicationId: a,
+		transactionId: f,
+		originalTransactionId: h(r.intent.receipt),
+		storeProductId: r.product.storeProductId,
+		kind: "subscription",
+		quantity: 1,
+		purchasedAt: T,
+		expiresAt: D,
+		paid: C,
+		acknowledgement: i.acknowledgement,
+		consumption: "none"
+	});
+	return Object.freeze({
+		facts: k,
+		startsAt: E,
+		orderState: g.state,
+		history: b,
+		lastEventAt: O,
+		currentExpiresAt: i.expiresAt
+	});
+}, y = (n, r, i, a, o, s) => {
+	let c = _(n, i, o, s), l = v(r, i, c, a, o, s);
+	if (c.state !== "SUBSCRIPTION_STATE_ACTIVE" && c.state !== "SUBSCRIPTION_STATE_CANCELED" || l.orderState !== "PROCESSED" || l.history.refundEvent !== void 0 || t(l.history.partialRefundEvents ?? [], 1e3, "invalid_record").length !== 0 || l.facts.expiresAt === null || c.expiresAt < l.facts.expiresAt || l.facts.expiresAt <= i.at || l.startsAt > i.at) throw e("forbidden");
+	return l.facts;
+}, b = (t, n) => {
+	if (n <= 0n || t <= 0n || t >= n) throw e("invalid_record");
+	let r = t, i = n;
+	for (; i;) {
+		let e = r % i;
+		r = i, i = e;
+	}
+	let a = t / r, o = n / r;
+	if (o > 100000n) throw e("limit_exceeded");
+	return {
+		numerator: Number(a),
+		denominator: Number(o)
+	};
+}, x = (n, r, i, s, d, f, p) => {
+	let g = a(f);
+	if (g < i.at) throw e("invalid_record");
+	let y = l(c(i.material.detail).purchaseToken, 4096);
+	if (h(y) !== i.facts.originalTransactionId) throw e("forbidden");
+	let x = {
+		scope: i.scope,
+		product: i.product,
+		accountToken: i.accountToken,
+		at: g,
+		intent: {
+			channel: "android",
+			offerId: i.product.offer.id,
+			offerVersion: i.product.offer.version,
+			requestId: i.orderId,
+			receipt: y
+		}
+	}, S = v(r, x, _(n, x, d, p), s, d, p, i.facts.transactionId), C = (e) => o({
+		...e,
+		acknowledgement: "none",
+		consumption: "none"
+	});
+	if (C(S.facts) !== C(i.facts)) throw e("conflict");
+	let w = 0, T = 1, E = null;
+	if (S.orderState === "REFUNDED") {
+		if (E = u(c(S.history.refundEvent).eventTime), E < i.facts.purchasedAt || E > S.lastEventAt || E > g) throw e("invalid_record");
+		w = 1;
+	} else {
+		if (S.history.refundEvent !== void 0) throw e("invalid_record");
+		let n = 0n;
+		for (let r of t(S.history.partialRefundEvents ?? [], 1e3, "invalid_record")) {
+			let t = c(r);
+			if (t.state === "PENDING") continue;
+			if (t.state !== "PROCESSED_SUCCESSFULLY") throw e("invalid_record");
+			let a = u(t.processTime), o = m(c(t.refundDetails).total);
+			if (a < i.facts.purchasedAt || a > S.lastEventAt || a > g || o.currency !== S.facts.paid?.currency || BigInt(o.units) <= 0n) throw e("invalid_record");
+			n += BigInt(o.units);
+		}
+		if (S.orderState === "PARTIALLY_REFUNDED") {
+			let e = b(n, BigInt(S.facts.paid.units));
+			w = e.numerator, T = e.denominator;
+		} else if (n !== 0n) throw e("invalid_record");
+	}
+	return Object.freeze({
+		orderId: i.orderId,
+		channel: "android",
+		state: w === 0 ? "active" : w === T ? "revoked" : "partially-refunded",
+		refundNumerator: w,
+		refundDenominator: T,
+		observedAt: g,
+		revokedAt: E
+	});
+};
+export { _ as captureGoogleSubscription, v as captureGoogleSubscriptionOrder, f as captureGoogleSubscriptionPlans, y as projectGoogleIapSubscription, x as projectGoogleIapSubscriptionCurrentState };

package/dist/iap.d.ts

@@ -0,0 +1,309 @@
+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';
+
+/** A decoded observation, not purchase/completion authority. */
+export declare const captureIapCompletionReceipt: (input: unknown) => IapCompletionReceipt;
+
+/** Shared strict wire/recovery admission; private notices and financial movements are absent. */
+export declare const captureIapObservation: (input: unknown) => IapOrderObservation;
+
+/** Wire admission only. Actual own financial authority is the SQL receipt service. */
+export declare const captureIapOrderReceipt: (input: unknown) => IapOrderReceipt;
+
+export declare const captureIapPaidAmount: (input: unknown) => IapPaidAmount | null;
+
+export declare const captureIapRefundDisposition: (input: unknown) => IapRefundDisposition;
+
+export declare const captureIapScope: (input: IapScope) => IapScope;
+
+export declare const captureIapService: (input: IapService) => IapService;
+
+export declare const captureIapSubscriptionPeriod: (input: unknown) => IapSubscriptionPeriod;
+
+/** Hash the canonical string representation used by SQL; no raw receipt is retained in the result. */
+export declare const createIapReceiptReference: (input: IapReceiptIntent) => Promise<IapReceiptReference>;
+
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+/** Declarations, not store prices, purchase evidence or grant authority. */
+export declare const defineIapCatalog: (definitions: readonly IapProductDefinition[], currencies: readonly CurrencyDefinition[], realMoney?: boolean) => readonly IapProduct[];
+
+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>;
+
+export declare const iapChannel: (value: unknown) => EconomyChannel;
+
+export declare interface IapCompletionReceipt {
+    readonly orderId: string;
+    readonly channel: EconomyChannel;
+    readonly operation: 'acknowledge' | 'consume' | 'finalize' | 'finish';
+    readonly observedAt: number;
+}
+
+export declare type IapEnvironment = 'sandbox' | 'production';
+
+export declare const iapEnvironment: (value: unknown) => IapEnvironment;
+
+export declare type IapOrderObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: IapOrderReceipt;
+    readonly refund?: IapRefundDisposition;
+} | {
+    readonly requestId: string;
+    readonly state: 'partially-refunded' | 'refunded';
+    readonly receipt: IapOrderReceipt;
+    readonly refund: IapRefundDisposition;
+};
+
+export declare interface IapOrderReceipt {
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly quantity: number;
+    readonly at: number;
+    readonly pricePaid: IapPaidAmount | null;
+    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;
+    }[];
+}
+
+/** Provider units retain their own decimal scale. Reference prices are never substituted. */
+export declare interface IapPaidAmount {
+    readonly currency: string;
+    readonly units: string;
+    readonly scale: number;
+}
+
+export declare class IapPort extends IapPort_base {
+}
+
+declare const IapPort_base: Context.ServiceClass<IapPort, "@voltro/IapPort", IapService>;
+
+export declare interface IapProduct {
+    readonly offer: ShopOffer;
+    readonly channel: EconomyChannel;
+    readonly kind: IapProductKind;
+    readonly storeProductId: string;
+}
+
+export declare interface IapProductDefinition {
+    readonly offer: ShopOfferDefinition | ShopOffer;
+    readonly channel: EconomyChannel;
+    readonly kind: IapProductKind;
+}
+
+export declare type IapProductKind = 'consumable' | 'non-consumable' | 'subscription';
+
+export declare const iapProductKind: (value: unknown) => IapProductKind;
+
+/** Console preparation only. Does not provision products or assert actual prices. */
+export declare const iapProductsCsv: (catalog: readonly IapProduct[]) => string;
+
+export declare interface IapReceiptIntent {
+    readonly channel: EconomyChannel;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    /** Opaque store evidence. Never log or persist this in player receipts. */
+    readonly receipt: string;
+}
+
+/** Players select an offer and submit evidence; no owner, price or state. */
+export declare const iapReceiptIntent: (input: IapReceiptIntent) => IapReceiptIntent;
+
+/** Read-only original-intention reference. Never send raw receipts in query parameters. */
+export declare interface IapReceiptReference {
+    readonly channel: EconomyChannel;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    readonly receiptDigest: string;
+}
+
+export declare const iapReceiptReference: (input: IapReceiptReference) => IapReceiptReference;
+
+/** Accepted SQL refund history only. This projection never authorizes a grant or completion. */
+export declare interface IapRefundDisposition {
+    readonly sequence: number;
+    readonly state: 'active' | 'partially-refunded' | 'revoked';
+    readonly refundNumerator: number;
+    readonly refundDenominator: number;
+    readonly observedAt: number;
+}
+
+export declare interface IapScope {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+export declare interface IapService {
+    readonly redeem: (subject: Subject, input: IapReceiptIntent) => Effect.Effect<IapOrderReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: IapReceiptReference) => Effect.Effect<IapOrderObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+/** An accepted store period, not a fresh provider observation or financial capability. */
+export declare interface IapSubscriptionPeriod {
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly channel: EconomyChannel;
+    readonly startsAt: number;
+    readonly expiresAt: number;
+    readonly refund: IapRefundDisposition | null;
+}
+
+export declare const iapTimestamp: (value: unknown) => number;
+
+export declare interface IapTransactionFacts {
+    readonly channel: EconomyChannel;
+    readonly environment: IapEnvironment;
+    readonly applicationId: string;
+    readonly transactionId: string;
+    readonly originalTransactionId: string | null;
+    readonly storeProductId: string;
+    readonly kind: IapProductKind;
+    readonly quantity: number;
+    readonly purchasedAt: number;
+    readonly expiresAt: number | null;
+    readonly paid: IapPaidAmount | null;
+    readonly acknowledgement: 'none' | 'pending' | 'acknowledged';
+    readonly consumption: 'none' | 'available' | 'consumed';
+}
+
+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>>>;
+}
+
+declare interface ResolvedVirtualPriceOption {
+    readonly currency: string;
+    readonly amount: string;
+}
+
+declare interface ShopCurrencyGrant {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+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;
+}
+
+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;
+}
+
+declare interface VirtualPriceOption {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export { }