@fased/fased 0.1.62 → 0.1.64

package/dist/federation/marketplace-settlement-ledger.js

@@ -0,0 +1,352 @@
+import { resolveProcessScopedMap } from "../shared/process-scoped-map.js";
+import { acquireFileLock } from "../plugin-sdk/file-lock.js";
+import "../infra/file-lock.js";
+import { ensureWalletStateDir } from "../wallet/wallet-runtime-config.js";
+import { serializeWalletState, writeWalletStateFileAtomically } from "../wallet/wallet-atomic-state.js";
+import syncFs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+
+//#region src/federation/marketplace-settlement-ledger.ts
+const ACTIVE_ORDERS = resolveProcessScopedMap(Symbol.for("fased.marketplace.settlement.activeOrders"));
+const ACTIONS = new Set([
+	"direct",
+	"fund",
+	"release",
+	"refund",
+	"cancel"
+]);
+const ACTION_STATES = new Set([
+	"reserved",
+	"pending",
+	"unknown",
+	"executed",
+	"evidence_pending",
+	"complete",
+	"failed"
+]);
+const PHASES = new Set([
+	"open",
+	"direct_pending",
+	"direct_unknown",
+	"direct_paid",
+	"direct_evidence_pending",
+	"direct_settled",
+	"fund_pending",
+	"fund_unknown",
+	"held",
+	"release_pending",
+	"release_unknown",
+	"released",
+	"refund_pending",
+	"refund_unknown",
+	"refunded",
+	"cancelled"
+]);
+const STATE_TRANSITIONS = {
+	reserved: new Set([
+		"reserved",
+		"pending",
+		"unknown",
+		"complete",
+		"failed"
+	]),
+	pending: new Set([
+		"pending",
+		"unknown",
+		"executed",
+		"complete",
+		"failed"
+	]),
+	unknown: new Set([
+		"unknown",
+		"executed",
+		"complete",
+		"failed"
+	]),
+	executed: new Set([
+		"executed",
+		"evidence_pending",
+		"complete"
+	]),
+	evidence_pending: new Set(["evidence_pending", "complete"]),
+	complete: new Set(["complete"]),
+	failed: new Set(["failed", "pending"])
+};
+const LOCK_OPTIONS = {
+	retries: {
+		retries: 1,
+		factor: 1,
+		minTimeout: 10,
+		maxTimeout: 10,
+		randomize: false
+	},
+	stale: 3e4
+};
+function canonicalJson(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") {
+		return JSON.stringify(value);
+	}
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) {
+			throw new Error("marketplace settlement intent contains a non-finite number");
+		}
+		return JSON.stringify(value);
+	}
+	if (Array.isArray(value)) {
+		return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+	}
+	if (value && typeof value === "object") {
+		const record = value;
+		return `{${Object.keys(record).filter((key) => record[key] !== undefined).toSorted().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+	}
+	throw new Error("marketplace settlement intent contains an unsupported value");
+}
+function marketplaceSettlementIntentDigest(intent) {
+	return `sha256:${createHash("sha256").update(canonicalJson(intent)).digest("hex")}`;
+}
+function orderDigest(orderId) {
+	return createHash("sha256").update(orderId).digest("hex");
+}
+function stateDirectory(env) {
+	return path.join(ensureWalletStateDir(env).rootDir, "marketplace-settlements");
+}
+function entryPath(orderId, env) {
+	return path.join(stateDirectory(env), `${orderDigest(orderId)}.json`);
+}
+function lockTarget(orderId, env) {
+	return path.join(stateDirectory(env), ".executions", orderDigest(orderId));
+}
+function readEntry(orderId, env) {
+	const filePath = entryPath(orderId, env);
+	if (!syncFs.existsSync(filePath)) {
+		return null;
+	}
+	try {
+		const value = JSON.parse(syncFs.readFileSync(filePath, "utf8"));
+		if (value.version !== 1 || value.orderId !== orderId || typeof value.phase !== "string" || !PHASES.has(value.phase) || !value.actions || Array.isArray(value.actions) || typeof value.actions !== "object" || typeof value.createdAt !== "string" || typeof value.updatedAt !== "string") {
+			throw new Error("invalid shape");
+		}
+		for (const [actionName, action] of Object.entries(value.actions)) {
+			if (!ACTIONS.has(actionName) || !action || typeof action !== "object" || action.action !== actionName || typeof action.intentDigest !== "string" || !/^sha256:[0-9a-f]{64}$/u.test(action.intentDigest) || typeof action.executionIntentId !== "string" || !action.executionIntentId.trim() || typeof action.state !== "string" || !ACTION_STATES.has(action.state) || typeof action.createdAt !== "string" || typeof action.updatedAt !== "string") {
+				throw new Error("invalid action");
+			}
+			for (const field of [
+				"requestId",
+				"txHash",
+				"evidenceRef",
+				"reason"
+			]) {
+				if (action[field] !== undefined && typeof action[field] !== "string") {
+					throw new Error(`invalid action ${field}`);
+				}
+			}
+		}
+		return value;
+	} catch (error) {
+		throw new Error("marketplace settlement ledger is unreadable; refusing monetary actions", { cause: error });
+	}
+}
+function writeEntry(entry, env) {
+	syncFs.mkdirSync(stateDirectory(env), {
+		recursive: true,
+		mode: 448
+	});
+	writeWalletStateFileAtomically(entryPath(entry.orderId, env), serializeWalletState(entry));
+}
+function getMarketplaceSettlementEntry(params) {
+	return readEntry(params.orderId.trim(), params.env ?? process.env);
+}
+async function claimMarketplaceSettlementOrder(orderIdRaw, env = process.env) {
+	const orderId = orderIdRaw.trim();
+	if (!orderId) {
+		throw new Error("marketplace settlement orderId is required");
+	}
+	const key = `${stateDirectory(env)}\0${orderId}`;
+	if (ACTIVE_ORDERS.has(key)) {
+		throw new Error("marketplace settlement action is already in progress");
+	}
+	ACTIVE_ORDERS.set(key, true);
+	let lock;
+	try {
+		lock = await acquireFileLock(lockTarget(orderId, env), LOCK_OPTIONS);
+	} catch (error) {
+		ACTIVE_ORDERS.delete(key);
+		throw new Error("marketplace settlement action is already in progress", { cause: error });
+	}
+	let released = false;
+	return async () => {
+		if (released) {
+			return;
+		}
+		released = true;
+		ACTIVE_ORDERS.delete(key);
+		await lock.release();
+	};
+}
+function initialEntry(params) {
+	const now = new Date().toISOString();
+	return {
+		version: 1,
+		orderId: params.orderId,
+		phase: params.initialPhase,
+		actions: {},
+		createdAt: now,
+		updatedAt: now
+	};
+}
+function actionAllowed(phase, action) {
+	if (action === "direct") {
+		return phase === "open" || phase.startsWith("direct_");
+	}
+	if (action === "fund") {
+		return phase === "open" || phase.startsWith("fund_") || phase === "held";
+	}
+	if (action === "release") {
+		return phase === "held" || phase.startsWith("release_") || phase === "released";
+	}
+	if (action === "refund") {
+		return phase === "held" || phase.startsWith("refund_") || phase === "refunded";
+	}
+	return phase === "open" || phase === "cancelled";
+}
+function reservedPhase(action) {
+	switch (action) {
+		case "direct": return "direct_pending";
+		case "fund": return "fund_pending";
+		case "release": return "release_pending";
+		case "refund": return "refund_pending";
+		case "cancel": return "cancelled";
+	}
+}
+function reserveMarketplaceSettlementAction(params) {
+	const env = params.env ?? process.env;
+	const orderId = params.orderId.trim();
+	const executionIntentId = params.executionIntentId.trim();
+	const intentDigest = marketplaceSettlementIntentDigest(params.intent);
+	const entry = readEntry(orderId, env) ?? initialEntry({
+		orderId,
+		initialPhase: params.initialPhase
+	});
+	const existing = entry.actions[params.action];
+	if (existing) {
+		if (existing.intentDigest !== intentDigest || existing.executionIntentId !== executionIntentId) {
+			throw new Error(`marketplace ${params.action} identity is already bound to a different immutable intent`);
+		}
+		return {
+			entry,
+			action: existing,
+			created: false
+		};
+	}
+	if (!actionAllowed(entry.phase, params.action)) {
+		throw new Error(`marketplace ${params.action} is forbidden while settlement phase is ${entry.phase}`);
+	}
+	const now = new Date().toISOString();
+	const action = {
+		action: params.action,
+		intentDigest,
+		executionIntentId,
+		state: params.action === "cancel" ? "complete" : "reserved",
+		createdAt: now,
+		updatedAt: now
+	};
+	entry.actions[params.action] = action;
+	entry.phase = reservedPhase(params.action);
+	entry.updatedAt = now;
+	writeEntry(entry, env);
+	return {
+		entry,
+		action,
+		created: true
+	};
+}
+function phaseForUpdate(params) {
+	const { action, state } = params;
+	if (action === "direct") {
+		if (state === "unknown") {
+			return "direct_unknown";
+		}
+		if (state === "executed") {
+			return "direct_paid";
+		}
+		if (state === "evidence_pending") {
+			return "direct_evidence_pending";
+		}
+		if (state === "complete") {
+			return "direct_settled";
+		}
+		if (state === "failed") {
+			return "open";
+		}
+		return "direct_pending";
+	}
+	if (action === "fund") {
+		if (state === "unknown") {
+			return "fund_unknown";
+		}
+		if (state === "executed" || state === "complete") {
+			return "held";
+		}
+		if (state === "failed") {
+			return "open";
+		}
+		return "fund_pending";
+	}
+	if (action === "release") {
+		if (state === "unknown") {
+			return "release_unknown";
+		}
+		if (state === "executed" || state === "complete") {
+			return "released";
+		}
+		if (state === "failed") {
+			return "held";
+		}
+		return "release_pending";
+	}
+	if (action === "refund") {
+		if (state === "unknown") {
+			return "refund_unknown";
+		}
+		if (state === "executed" || state === "complete") {
+			return "refunded";
+		}
+		if (state === "failed") {
+			return "held";
+		}
+		return "refund_pending";
+	}
+	return state === "failed" ? "open" : "cancelled";
+}
+function updateMarketplaceSettlementAction(params) {
+	const env = params.env ?? process.env;
+	const orderId = params.orderId.trim();
+	const entry = readEntry(orderId, env);
+	const action = entry?.actions[params.action];
+	if (!entry || !action) {
+		throw new Error("marketplace settlement action is not reserved");
+	}
+	if (!params.expectedStates.includes(action.state)) {
+		throw new Error(`marketplace ${params.action} is ${action.state}; expected ${params.expectedStates.join(" or ")}`);
+	}
+	if (!STATE_TRANSITIONS[action.state].has(params.state)) {
+		throw new Error(`marketplace ${params.action} cannot transition from ${action.state} to ${params.state}`);
+	}
+	action.state = params.state;
+	action.requestId = params.requestId?.trim() || action.requestId;
+	action.txHash = params.txHash?.trim() || action.txHash;
+	action.evidenceRef = params.evidenceRef?.trim() || action.evidenceRef;
+	action.reason = params.reason?.trim() || action.reason;
+	action.updatedAt = new Date().toISOString();
+	entry.phase = phaseForUpdate({
+		action: params.action,
+		state: params.state
+	});
+	entry.updatedAt = action.updatedAt;
+	writeEntry(entry, env);
+	return entry;
+}
+
+//#endregion
+export { claimMarketplaceSettlementOrder, getMarketplaceSettlementEntry, reserveMarketplaceSettlementAction, updateMarketplaceSettlementAction };

package/dist/federation/offers.js

@@ -478,13 +478,7 @@ function defaultDeliveryTargetMasked(kind, input) {
 function isAllowedDeliveryUrl(value, opts = {}) {
 	try {
 		const url = new URL(value);
-		if (url.protocol === "https:" || opts.allowWebSocket && url.protocol === "wss:") {
-			return true;
-		}
-		if (url.protocol !== "http:") {
-			return false;
-		}
-		return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+		return url.protocol === "https:" || Boolean(opts.allowWebSocket && url.protocol === "wss:");
 	} catch {
 		return false;
 	}
@@ -883,6 +877,10 @@ function normalizeMarketplaceOrder(input, index) {
 		...trimString(input.sellerSyncError) ? { sellerSyncError: trimString(input.sellerSyncError) } : {},
 		...trimString(input.sellerSyncedAt) ? { sellerSyncedAt: trimString(input.sellerSyncedAt) } : {},
 		...trimString(input.sellerAcceptedAt) ? { sellerAcceptedAt: trimString(input.sellerAcceptedAt) } : {},
+		...trimString(input.peerNodeId) ? { peerNodeId: trimString(input.peerNodeId) } : {},
+		...trimString(input.peerRemoteOrderId) ? { peerRemoteOrderId: trimString(input.peerRemoteOrderId) } : {},
+		...trimString(input.peerRequestDigest) ? { peerRequestDigest: trimString(input.peerRequestDigest) } : {},
+		...trimString(input.peerDeliveryDigest) ? { peerDeliveryDigest: trimString(input.peerDeliveryDigest) } : {},
 		serviceKind,
 		title,
 		...pricing ? { pricing } : {},
@@ -1447,6 +1445,10 @@ function upsertMarketplaceOrderConfig(params) {
 		sellerSyncError: params.input.sellerSyncError,
 		sellerSyncedAt: params.input.sellerSyncedAt ?? existingOrder?.sellerSyncedAt,
 		sellerAcceptedAt: params.input.sellerAcceptedAt ?? existingOrder?.sellerAcceptedAt,
+		peerNodeId: params.input.peerNodeId ?? existingOrder?.peerNodeId,
+		peerRemoteOrderId: params.input.peerRemoteOrderId ?? existingOrder?.peerRemoteOrderId,
+		peerRequestDigest: params.input.peerRequestDigest ?? existingOrder?.peerRequestDigest,
+		peerDeliveryDigest: params.input.peerDeliveryDigest ?? existingOrder?.peerDeliveryDigest,
 		serviceKind: params.input.serviceKind,
 		title: params.input.title,
 		pricing: params.input.pricing,