@seams/wallet-server 0.7.3 → 0.9.0

package/dist/esm/core/ThresholdService/stores/WalletSessionStore.js

@@ -1,541 +0,0 @@
-import { normalizeOptionalTrimmedString } from "../../../shared-ts/src/utils/normalize.js";
-import { isPlainObject } from "../../../shared-ts/src/utils/validation.js";
-import { failure } from "../../../shared-ts/src/utils/failure.js";
-import { parseEcdsaWalletSessionRecord, parseEd25519WalletSessionRecord, toThresholdEcdsaPrefixFromBase, toThresholdEcdsaWalletSessionPrefix, toThresholdEd25519PrefixFromBase, toThresholdEd25519WalletSessionPrefix } from "../validation.js";
-import { RedisTcpClient, UpstashRedisRestClient, redisGetJson, redisSetJson } from "../kv.js";
-import { EXPORT_REPLAY_GUARD_CLOCK_SKEW_MS, EXPORT_REPLAY_GUARD_MIN_RETENTION_MS } from "./exportReplayGuard.js";
-import { createCloudflareDurableObjectThresholdEcdsaStores, createCloudflareDurableObjectThresholdEd25519Stores } from "./CloudflareDurableObjectStore.js";
-import { readNonDurableObjectThresholdStoreKind } from "./StoreConfig.js";
-//#region src/core/ThresholdService/stores/WalletSessionStore.ts
-/** A wallet session store's keys: record, use counter, consume-once markers, replay guards. */
-var WalletSessionKeys = class {
-	constructor(keyPrefix) {
-		this.prefix = toThresholdEd25519WalletSessionPrefix(keyPrefix);
-	}
-	meta(id) {
-		return `${this.prefix}${id}`;
-	}
-	uses(id) {
-		return `${this.prefix}${id}:uses`;
-	}
-	consumeOnce(id, idempotencyKey) {
-		return `${this.uses(id)}:once:${normalizeConsumeOnceKey(idempotencyKey)}`;
-	}
-	replayGuard(scopeId, replayKey) {
-		return `${this.prefix}replay:${normalizeConsumeOnceKey(scopeId)}:${normalizeConsumeOnceKey(replayKey)}`;
-	}
-};
-var InMemoryWalletSessionStore = class {
-	constructor(input) {
-		this.map = /* @__PURE__ */ new Map();
-		this.replayGuards = /* @__PURE__ */ new Map();
-		this.keys = new WalletSessionKeys(input.keyPrefix);
-	}
-	/** The session's entry, or why it cannot be used: missing, or expired (and dropped). */
-	liveEntry(id) {
-		const key = this.keys.meta(id);
-		const entry = this.map.get(key);
-		if (!entry) return failure("wallet_session_missing", "Wallet Session is missing");
-		if (entry.expiresAtMs <= Date.now()) {
-			this.map.delete(key);
-			return failure("wallet_session_expired", "Wallet Session expired");
-		}
-		return entry;
-	}
-	async putSession(id, record, opts) {
-		const key = this.keys.meta(id);
-		const ttlMs = Math.max(0, Number(opts.ttlMs) || 0);
-		const expiresAtMs = Date.now() + ttlMs;
-		this.map.set(key, {
-			record,
-			remainingUses: Math.max(0, Number(opts.remainingUses) || 0),
-			expiresAtMs,
-			consumedIdempotencyKeys: /* @__PURE__ */ new Set()
-		});
-	}
-	async getSession(id) {
-		const key = this.keys.meta(id);
-		const entry = this.map.get(key);
-		if (!entry) return null;
-		if (entry.expiresAtMs <= Date.now()) {
-			this.map.delete(key);
-			return null;
-		}
-		return entry.record;
-	}
-	async getSessionStatus(id) {
-		const key = this.keys.meta(id);
-		const entry = this.map.get(key);
-		if (!entry) return {
-			ok: false,
-			code: "wallet_session_missing"
-		};
-		if (entry.expiresAtMs <= Date.now()) {
-			this.map.delete(key);
-			return {
-				ok: false,
-				code: "wallet_session_expired"
-			};
-		}
-		return {
-			ok: true,
-			status: {
-				record: entry.record,
-				expiresAtMs: entry.expiresAtMs,
-				remainingUses: entry.remainingUses
-			}
-		};
-	}
-	async consumeUseCount(id) {
-		const entry = this.liveEntry(id);
-		if ("ok" in entry) return entry;
-		if (entry.remainingUses <= 0) return failure("wallet_budget_exhausted", "Wallet Session exhausted");
-		entry.remainingUses -= 1;
-		return {
-			ok: true,
-			remainingUses: entry.remainingUses
-		};
-	}
-	async consumeUseCountOnce(id, idempotencyKey) {
-		const entry = this.liveEntry(id);
-		if ("ok" in entry) return entry;
-		const consumeKey = String(idempotencyKey || "").trim();
-		if (consumeKey && entry.consumedIdempotencyKeys.has(consumeKey)) return {
-			ok: true,
-			remainingUses: entry.remainingUses
-		};
-		if (entry.remainingUses <= 0) return failure("wallet_budget_exhausted", "Wallet Session exhausted");
-		entry.remainingUses -= 1;
-		if (consumeKey) entry.consumedIdempotencyKeys.add(consumeKey);
-		return {
-			ok: true,
-			remainingUses: entry.remainingUses
-		};
-	}
-	async hasConsumedUseCountOnce(id, idempotencyKey) {
-		const entry = this.liveEntry(id);
-		if ("ok" in entry) return entry;
-		const consumeKey = String(idempotencyKey || "").trim();
-		return {
-			ok: true,
-			consumed: !!consumeKey && entry.consumedIdempotencyKeys.has(consumeKey)
-		};
-	}
-	async reserveReplayGuard(scopeId, replayKey, expiresAtMs) {
-		const key = this.keys.replayGuard(scopeId, replayKey);
-		if (!key) return replayGuardInvalid();
-		const nowMs = Date.now();
-		const existingExpiresAtMs = this.replayGuards.get(key);
-		if (existingExpiresAtMs !== void 0 && existingExpiresAtMs > nowMs) return replayGuardDuplicate();
-		if (existingExpiresAtMs !== void 0) this.replayGuards.delete(key);
-		const ttlMs = replayGuardTtlMs(expiresAtMs, nowMs);
-		if (ttlMs <= 0) return replayGuardExpired();
-		this.replayGuards.set(key, nowMs + ttlMs);
-		return { ok: true };
-	}
-};
-/** A backend failure as an `internal` result: the error's message, else `fallback`. */
-function walletSessionStoreFailure(error, fallback) {
-	return failure("internal", String(error && typeof error === "object" && "message" in error ? error.message : error || fallback));
-}
-/**
-* A remote store's session status: the parsed record while it is live, with its remaining uses.
-* A backend failure, or a use count that is not a non-negative integer, reads as unavailable.
-*/
-async function readWalletSessionStatus(input) {
-	try {
-		const record = await input.readRecord();
-		if (!record) return {
-			ok: false,
-			code: "wallet_session_missing"
-		};
-		if (record.expiresAtMs <= Date.now()) return {
-			ok: false,
-			code: "wallet_session_expired"
-		};
-		const remainingUses = Number(await input.readRemainingUses());
-		if (!Number.isSafeInteger(remainingUses) || remainingUses < 0) return {
-			ok: false,
-			code: "wallet_session_unavailable"
-		};
-		return {
-			ok: true,
-			status: {
-				record,
-				expiresAtMs: record.expiresAtMs,
-				remainingUses
-			}
-		};
-	} catch {
-		return {
-			ok: false,
-			code: "wallet_session_unavailable"
-		};
-	}
-}
-function normalizeConsumeOnceKey(value) {
-	return String(value || "").trim().replace(/[^A-Za-z0-9._:-]/g, "_").slice(0, 512);
-}
-function replayGuardTtlMs(expiresAtMs, nowMs = Date.now()) {
-	const expires = Number(expiresAtMs);
-	if (!Number.isFinite(expires)) return 0;
-	const retainUntilMs = expires + EXPORT_REPLAY_GUARD_CLOCK_SKEW_MS;
-	if (retainUntilMs <= nowMs) return 0;
-	return Math.max(EXPORT_REPLAY_GUARD_MIN_RETENTION_MS, Math.floor(retainUntilMs - nowMs));
-}
-function replayGuardInvalid() {
-	return failure("invalid_body", "Invalid replay guard key");
-}
-function replayGuardExpired() {
-	return failure("export_authorization_expired", "Export authorization expired");
-}
-function replayGuardDuplicate() {
-	return failure("export_nonce_replay", "Export authorization nonce already used");
-}
-function parseRedisReplayGuardResult(raw) {
-	const text = String(raw ?? "").trim();
-	if (text === "ok") return { ok: true };
-	if (text === "duplicate") return replayGuardDuplicate();
-	if (text === "expired") return replayGuardExpired();
-	return failure("internal", "Redis replay guard returned invalid response");
-}
-function parseRedisConsumeOnceResult(raw) {
-	const text = String(raw ?? "").trim();
-	if (text.startsWith("ok:")) {
-		const remainingUses = Number(text.slice(3));
-		if (!Number.isFinite(remainingUses)) return failure("internal", "Redis consume-once returned invalid uses");
-		return {
-			ok: true,
-			remainingUses
-		};
-	}
-	if (text === "wallet_session_missing") return failure("wallet_session_missing", "Wallet Session is missing");
-	if (text === "wallet_budget_exhausted") return failure("wallet_budget_exhausted", "Wallet Session signing budget is exhausted");
-	return failure("internal", "Redis consume-once returned invalid response");
-}
-function parseRedisConsumedUseResult(raw) {
-	const value = typeof raw === "number" ? raw : Number(String(raw ?? "").trim());
-	if (!Number.isFinite(value)) return failure("internal", "Redis consumed-use check returned invalid response");
-	return {
-		ok: true,
-		consumed: value > 0
-	};
-}
-function redisRawValue(resp) {
-	if (resp.type === "integer") return String(resp.value);
-	return resp.value;
-}
-const CONSUME_ONCE_EXISTS_LUA = `
-local marker_key = KEYS[1]
-return redis.call('EXISTS', marker_key)
-`;
-const CONSUME_USE_COUNT_LUA = `
-local uses_key = KEYS[1]
-local current = tonumber(redis.call('GET', uses_key) or '')
-if current == nil then
-  return 'wallet_session_missing'
-end
-if current <= 0 then
-  return 'wallet_budget_exhausted'
-end
-return 'ok:' .. tostring(redis.call('INCRBY', uses_key, -1))
-`;
-const CONSUME_ONCE_LUA = `
-local uses_key = KEYS[1]
-local marker_key = KEYS[2]
-if redis.call('EXISTS', marker_key) == 1 then
-  local current = redis.call('GET', uses_key)
-  if not current then
-    return 'wallet_session_missing'
-  end
-  return 'ok:' .. tostring(current)
-end
-local current = tonumber(redis.call('GET', uses_key) or '')
-if current == nil then
-  return 'wallet_session_missing'
-end
-if current <= 0 then
-  return 'wallet_budget_exhausted'
-end
-local remaining = redis.call('INCRBY', uses_key, -1)
-local ttl = redis.call('TTL', uses_key)
-if ttl and ttl > 0 then
-  redis.call('SET', marker_key, '1', 'EX', ttl)
-else
-  redis.call('SET', marker_key, '1', 'EX', 60)
-end
-return 'ok:' .. tostring(remaining)
-`;
-const REPLAY_GUARD_LUA = `
-local key = KEYS[1]
-local ttl_seconds = tonumber(ARGV[1] or '')
-if ttl_seconds == nil or ttl_seconds <= 0 then
-  return 'expired'
-end
-if redis.call('EXISTS', key) == 1 then
-  return 'duplicate'
-end
-redis.call('SET', key, '1', 'EX', ttl_seconds)
-return 'ok'
-`;
-var UpstashRedisRestWalletSessionStore = class {
-	constructor(input) {
-		const url = normalizeOptionalTrimmedString(input.url);
-		const token = normalizeOptionalTrimmedString(input.token);
-		if (!url) throw new Error("Upstash wallet session store missing url");
-		if (!token) throw new Error("Upstash wallet session store missing token");
-		this.client = new UpstashRedisRestClient({
-			url,
-			token
-		});
-		this.keys = new WalletSessionKeys(input.keyPrefix);
-		this.parseRecord = input.parseRecord;
-	}
-	async putSession(id, record, opts) {
-		const ttlMs = Math.max(0, Number(opts.ttlMs) || 0);
-		await this.client.setJson(this.keys.meta(id), record, ttlMs);
-		await this.client.setRaw(this.keys.uses(id), String(Math.max(0, Number(opts.remainingUses) || 0)), ttlMs);
-	}
-	async getSession(id) {
-		const raw = await this.client.getJson(this.keys.meta(id));
-		return this.parseRecord(raw);
-	}
-	async getSessionStatus(id) {
-		return readWalletSessionStatus({
-			readRecord: async () => this.parseRecord(await this.client.getJson(this.keys.meta(id))),
-			readRemainingUses: () => this.client.getRaw(this.keys.uses(id))
-		});
-	}
-	async consumeUseCount(id) {
-		try {
-			return parseRedisConsumeOnceResult(await this.client.eval(CONSUME_USE_COUNT_LUA, [this.keys.uses(id)], []));
-		} catch (e) {
-			return walletSessionStoreFailure(e, "Failed to consume threshold session");
-		}
-	}
-	async consumeUseCountOnce(id, idempotencyKey) {
-		try {
-			return parseRedisConsumeOnceResult(await this.client.eval(CONSUME_ONCE_LUA, [this.keys.uses(id), this.keys.consumeOnce(id, idempotencyKey)], []));
-		} catch (e) {
-			return walletSessionStoreFailure(e, "Failed to consume threshold session");
-		}
-	}
-	async hasConsumedUseCountOnce(id, idempotencyKey) {
-		const consumeKey = normalizeConsumeOnceKey(idempotencyKey);
-		if (!consumeKey) return {
-			ok: true,
-			consumed: false
-		};
-		try {
-			return parseRedisConsumedUseResult(await this.client.eval(CONSUME_ONCE_EXISTS_LUA, [this.keys.consumeOnce(id, consumeKey)], []));
-		} catch (e) {
-			return walletSessionStoreFailure(e, "Failed to check consumed threshold session operation");
-		}
-	}
-	async reserveReplayGuard(scopeId, replayKey, expiresAtMs) {
-		try {
-			const ttlMs = replayGuardTtlMs(expiresAtMs);
-			if (ttlMs <= 0) return replayGuardExpired();
-			return parseRedisReplayGuardResult(await this.client.eval(REPLAY_GUARD_LUA, [this.keys.replayGuard(scopeId, replayKey)], [String(Math.max(1, Math.ceil(ttlMs / 1e3)))]));
-		} catch (e) {
-			return walletSessionStoreFailure(e, "Failed to reserve replay guard");
-		}
-	}
-};
-var RedisTcpWalletSessionStore = class {
-	constructor(input) {
-		const url = normalizeOptionalTrimmedString(input.redisUrl);
-		if (!url) throw new Error("redis-tcp wallet session store missing redisUrl");
-		this.client = new RedisTcpClient(url);
-		this.keys = new WalletSessionKeys(input.keyPrefix);
-		this.parseRecord = input.parseRecord;
-	}
-	async putSession(id, record, opts) {
-		const ttlMs = Math.max(0, Number(opts.ttlMs) || 0);
-		await redisSetJson(this.client, this.keys.meta(id), record, ttlMs);
-		const ttlSeconds = Math.max(1, Math.ceil(ttlMs / 1e3));
-		const uses = String(Math.max(0, Number(opts.remainingUses) || 0));
-		const resp = await this.client.send([
-			"SET",
-			this.keys.uses(id),
-			uses,
-			"EX",
-			String(ttlSeconds)
-		]);
-		if (resp.type === "error") throw new Error(`Redis SET error: ${resp.value}`);
-	}
-	async getSession(id) {
-		const raw = await redisGetJson(this.client, this.keys.meta(id));
-		return this.parseRecord(raw);
-	}
-	async getSessionStatus(id) {
-		return readWalletSessionStatus({
-			readRecord: async () => this.parseRecord(await redisGetJson(this.client, this.keys.meta(id))),
-			readRemainingUses: async () => {
-				const usesResponse = await this.client.send(["GET", this.keys.uses(id)]);
-				return usesResponse.type === "error" ? void 0 : redisRawValue(usesResponse);
-			}
-		});
-	}
-	async consumeUseCount(id) {
-		try {
-			const resp = await this.client.send([
-				"EVAL",
-				CONSUME_USE_COUNT_LUA,
-				"1",
-				this.keys.uses(id)
-			]);
-			if (resp.type === "error") return failure("internal", `Redis EVAL error: ${resp.value}`);
-			return parseRedisConsumeOnceResult(redisRawValue(resp));
-		} catch (e) {
-			return walletSessionStoreFailure(e, "Failed to consume threshold session");
-		}
-	}
-	async consumeUseCountOnce(id, idempotencyKey) {
-		try {
-			const resp = await this.client.send([
-				"EVAL",
-				CONSUME_ONCE_LUA,
-				"2",
-				this.keys.uses(id),
-				this.keys.consumeOnce(id, idempotencyKey)
-			]);
-			if (resp.type === "error") return failure("internal", `Redis EVAL error: ${resp.value}`);
-			return parseRedisConsumeOnceResult(resp.type === "integer" ? String(resp.value) : resp.value);
-		} catch (e) {
-			return walletSessionStoreFailure(e, "Failed to consume threshold session");
-		}
-	}
-	async hasConsumedUseCountOnce(id, idempotencyKey) {
-		const consumeKey = normalizeConsumeOnceKey(idempotencyKey);
-		if (!consumeKey) return {
-			ok: true,
-			consumed: false
-		};
-		try {
-			const resp = await this.client.send(["EXISTS", this.keys.consumeOnce(id, consumeKey)]);
-			if (resp.type === "error") return failure("internal", `Redis EXISTS error: ${resp.value}`);
-			return parseRedisConsumedUseResult(resp.value);
-		} catch (e) {
-			return walletSessionStoreFailure(e, "Failed to check consumed threshold session operation");
-		}
-	}
-	async reserveReplayGuard(scopeId, replayKey, expiresAtMs) {
-		try {
-			const ttlMs = replayGuardTtlMs(expiresAtMs);
-			if (ttlMs <= 0) return replayGuardExpired();
-			const resp = await this.client.send([
-				"SET",
-				this.keys.replayGuard(scopeId, replayKey),
-				"1",
-				"NX",
-				"EX",
-				String(Math.max(1, Math.ceil(ttlMs / 1e3)))
-			]);
-			if (resp.type === "error") return failure("internal", `Redis SET error: ${resp.value}`);
-			if (resp.type === "bulk" && resp.value === null) return replayGuardDuplicate();
-			if (resp.type === "simple" && resp.value === "OK") return { ok: true };
-			return failure("internal", "Redis replay guard returned invalid response");
-		} catch (e) {
-			return walletSessionStoreFailure(e, "Failed to reserve replay guard");
-		}
-	}
-};
-/**
-* Selects a wallet session store: Durable Objects, else the config's explicit `kind`, else Upstash
-* or Redis from env-shaped config, else in memory where the runtime allows it.
-*/
-function createWalletSessionStore(input, spec) {
-	const durableObjectStore = spec.durableObjectStore(input);
-	if (durableObjectStore) return durableObjectStore;
-	const { tag, parseRecord } = spec;
-	const config = isPlainObject(input.config) ? input.config : {};
-	const allowInMemory = normalizeOptionalTrimmedString(config.THRESHOLD_ALLOW_IN_MEMORY_STORES) === "1";
-	const requirePersistent = !input.isNode && !allowInMemory;
-	const envPrefix = spec.envPrefix(config);
-	const inMemory = () => new InMemoryWalletSessionStore({ keyPrefix: envPrefix || void 0 });
-	const kind = readNonDurableObjectThresholdStoreKind(config, tag);
-	if (kind === "in-memory") {
-		if (requirePersistent) throw new Error(`[${tag}] In-memory wallet session store is not supported in this runtime; configure Upstash/Redis or Durable Objects`);
-		return inMemory();
-	}
-	if (kind === "upstash-redis-rest") return new UpstashRedisRestWalletSessionStore({
-		url: normalizeOptionalTrimmedString(config.url) || normalizeOptionalTrimmedString(config.UPSTASH_REDIS_REST_URL),
-		token: normalizeOptionalTrimmedString(config.token) || normalizeOptionalTrimmedString(config.UPSTASH_REDIS_REST_TOKEN),
-		keyPrefix: normalizeOptionalTrimmedString(config.keyPrefix) || envPrefix,
-		parseRecord
-	});
-	if (kind === "redis-tcp") {
-		if (!input.isNode) {
-			if (requirePersistent) throw new Error(`[${tag}] redis-tcp wallet session store is not supported in this runtime; configure Upstash/Redis REST or Durable Objects`);
-			input.logger.warn(`[${tag}] redis-tcp wallet session store is not supported in this runtime; falling back to in-memory`);
-			return inMemory();
-		}
-		return new RedisTcpWalletSessionStore({
-			redisUrl: normalizeOptionalTrimmedString(config.redisUrl) || normalizeOptionalTrimmedString(config.REDIS_URL),
-			keyPrefix: normalizeOptionalTrimmedString(config.keyPrefix) || envPrefix,
-			parseRecord
-		});
-	}
-	const upstashUrl = normalizeOptionalTrimmedString(config.UPSTASH_REDIS_REST_URL);
-	const upstashToken = normalizeOptionalTrimmedString(config.UPSTASH_REDIS_REST_TOKEN);
-	if (upstashUrl || upstashToken) {
-		if (!upstashUrl || !upstashToken) throw new Error("Upstash wallet session store enabled but UPSTASH_REDIS_REST_URL / UPSTASH_REDIS_REST_TOKEN are not both set");
-		input.logger.info(`[${tag}] Using Upstash REST store for Wallet Session records`);
-		return new UpstashRedisRestWalletSessionStore({
-			url: upstashUrl,
-			token: upstashToken,
-			keyPrefix: envPrefix || void 0,
-			parseRecord
-		});
-	}
-	const redisUrl = normalizeOptionalTrimmedString(config.REDIS_URL);
-	if (redisUrl) {
-		if (!input.isNode) {
-			if (requirePersistent) throw new Error(`[${tag}] REDIS_URL is set but TCP Redis is not supported in this runtime; use Upstash/Redis REST or Durable Objects`);
-			input.logger.warn(`[${tag}] REDIS_URL is set but TCP Redis is not supported in this runtime; falling back to in-memory`);
-			return inMemory();
-		}
-		input.logger.info(`[${tag}] Using redis-tcp store for Wallet Session records`);
-		return new RedisTcpWalletSessionStore({
-			redisUrl,
-			keyPrefix: envPrefix || void 0,
-			parseRecord
-		});
-	}
-	if (requirePersistent) throw new Error(`[${tag}] Wallet Session records require persistent storage in this runtime; configure UPSTASH_REDIS_REST_URL/UPSTASH_REDIS_REST_TOKEN or Durable Objects`);
-	input.logger.info(`[${tag}] Using in-memory Wallet Session store (non-persistent)`);
-	return inMemory();
-}
-function createEd25519WalletSessionStore(input) {
-	return createWalletSessionStore(input, {
-		tag: "threshold-ed25519",
-		durableObjectStore: ({ config, logger }) => createCloudflareDurableObjectThresholdEd25519Stores({
-			config,
-			logger
-		})?.walletSessionStore ?? null,
-		envPrefix: (config) => {
-			const basePrefix = normalizeOptionalTrimmedString(config.THRESHOLD_PREFIX);
-			return normalizeOptionalTrimmedString(config.THRESHOLD_ED25519_WALLET_SESSION_PREFIX) || toThresholdEd25519PrefixFromBase(basePrefix, "wallet-session") || "";
-		},
-		parseRecord: parseEd25519WalletSessionRecord
-	});
-}
-function createEcdsaWalletSessionStore(input) {
-	return createWalletSessionStore(input, {
-		tag: "threshold-ecdsa",
-		durableObjectStore: ({ config, logger }) => createCloudflareDurableObjectThresholdEcdsaStores({
-			config,
-			logger
-		})?.walletSessionStore ?? null,
-		envPrefix: (config) => {
-			const basePrefix = normalizeOptionalTrimmedString(config.THRESHOLD_PREFIX);
-			return toThresholdEcdsaWalletSessionPrefix(normalizeOptionalTrimmedString(config.THRESHOLD_ECDSA_WALLET_SESSION_PREFIX) || toThresholdEcdsaPrefixFromBase(basePrefix, "wallet-session"));
-		},
-		parseRecord: parseEcdsaWalletSessionRecord
-	});
-}
-//#endregion
-export { createEcdsaWalletSessionStore, createEd25519WalletSessionStore };
-
-//# sourceMappingURL=WalletSessionStore.js.map