@capxul/sdk 1.0.0-alpha.9 → 1.2.0

package/dist/testing/index.mjs

@@ -0,0 +1,1068 @@
+import { C as convexCallErrorFromCapxul, D as bootstrapErrorFromCapxul, H as deriveCapxulSafeAddress, O as authClientPortFromPromiseAdapter, _ as identityErrorFromCapxul, c as smartAccountErrorFromCapxul, d as fromWei, h as wireChainId, i as redactTelemetryEvent, m as toWei, p as accountReadErrorFromCapxul, t as assembleCapxulClient, u as subAccountErrorFromCapxul } from "../create-capxul-client-DiqVIxsV.mjs";
+import { C as toJwtToken, E as toPublishableKey, N as Errors, O as toSessionToken, S as toEpochSeconds, _ as toCountryCode, b as toEmail, d as toAccountId, f as toAddress, g as toChainId, h as toAuthUserId, j as CapxulError, k as toSubAccountId, m as toAppId, p as toAllowedOrigin, t as InMemoryAuthCacheAdapter, v as toCurrencyCode, w as toKycTier, x as toEpochMs, y as toDurationMs } from "../InMemoryAuthCacheAdapter-Dr1sEd9y.mjs";
+import { keccak256 } from "viem";
+import { Effect, Result, Semaphore } from "effect";
+import { getFunctionName } from "convex/server";
+//#region src/testing/account/InMemoryAccountReadAdapter.ts
+var InMemoryAccountReadAdapter = class {
+	#deps;
+	#rawBalance;
+	constructor(deps = {}) {
+		this.#deps = deps;
+		this.#rawBalance = deps.rawBalance ?? "0";
+	}
+	readBalance(_input) {
+		const scriptedFailure = this.#deps.failures?.readBalance;
+		if (scriptedFailure !== void 0) return Effect.fail(accountReadErrorFromCapxul("readBalance", scriptedFailure));
+		if (this.#deps.account !== void 0) return Effect.succeed(cloneAccount(this.#deps.account));
+		const decimals = this.#deps.decimals ?? 6;
+		const currency = this.#deps.currency ?? "USD";
+		const money = fromWei(this.#rawBalance, decimals, currency);
+		return Effect.succeed({
+			id: toAccountId(this.#deps.accountId ?? "account_01TEST000000000000000000"),
+			balance: money,
+			available: money
+		});
+	}
+	fundFromFaucet(input) {
+		const scriptedFailure = this.#deps.failures?.fundFromFaucet;
+		if (scriptedFailure !== void 0) return Effect.fail(accountReadErrorFromCapxul("fundFromFaucet", scriptedFailure));
+		const expectedDecimals = this.#deps.decimals ?? 6;
+		const expectedCurrency = this.#deps.currency ?? "USD";
+		if (input.amount.decimals !== expectedDecimals || String(input.amount.currency) !== expectedCurrency) return Effect.fail(accountReadErrorFromCapxul("fundFromFaucet", Errors.invalidInput("amount", "decimals/currency must match adapter config")));
+		const minted = BigInt(toWei(input.amount));
+		this.#rawBalance = (BigInt(this.#rawBalance) + minted).toString();
+		return Effect.succeed({ txHash: "0x" + "f".repeat(64) });
+	}
+};
+function cloneAccount(account) {
+	return {
+		id: account.id,
+		balance: { ...account.balance },
+		available: { ...account.available }
+	};
+}
+//#endregion
+//#region src/adapters/_shared/clock.ts
+async function readClockNow(clock) {
+	try {
+		const result = await Effect.runPromise(Effect.result(clock.now));
+		if (Result.isFailure(result)) return {
+			ok: false,
+			error: Errors.providerError("clock", "now", result.failure)
+		};
+		return {
+			ok: true,
+			value: result.success
+		};
+	} catch (cause) {
+		return {
+			ok: false,
+			error: Errors.providerError("clock", "now", cause)
+		};
+	}
+}
+//#endregion
+//#region src/testing/clock/ManualClockAdapter.ts
+/**
+* Event-discipline test clock. Time moves only when a release primitive is
+* invoked. `tickOne()` releases EXACTLY ONE pending sleep (the earliest
+* deadline, FIFO at ties) and snaps `now()` to that deadline. `advance(ms)`
+* composes repeated `tickOne()` calls over the resulting window — used to
+* keep the cross-adapter conformance harness uniform with the distance model
+* of `VirtualClockAdapter`. See `packages/sdk/docs/architecture.md` and the
+* slice spec `docs/slices/clock-adapters.md`.
+*/
+var ManualClockAdapter = class ManualClockAdapter {
+	currentTime = 0;
+	queue = [];
+	seqCounter = 0;
+	constructor(deps) {}
+	now = Effect.sync(() => toEpochMs(this.currentTime));
+	sleep(duration) {
+		return Effect.promise(() => new Promise((resolve) => {
+			this.queue.push({
+				deadline: this.currentTime + duration,
+				resolve,
+				seq: this.seqCounter++
+			});
+		}));
+	}
+	/**
+	* Release exactly one pending sleep — the earliest deadline, FIFO at ties.
+	* Snaps `now()` forward to that sleep's deadline. No-op if the queue is
+	* empty (preserves the empty-tick safety property).
+	*/
+	tickOne() {
+		return Effect.runPromise(this.tickOneEffect());
+	}
+	tickOneEffect() {
+		const self = this;
+		return Effect.gen(function* () {
+			if (self.queue.length === 0) return;
+			const nextIndex = self.findEarliestIndex();
+			const next = self.queue.splice(nextIndex, 1)[0];
+			if (next.deadline > self.currentTime) self.currentTime = next.deadline;
+			next.resolve();
+			yield* Effect.yieldNow;
+		});
+	}
+	/**
+	* Cross-adapter harness affordance. Releases every sleep whose deadline
+	* falls inside `[currentTime, currentTime + ms]` via repeated `tickOne()`,
+	* then snaps `now()` to `currentTime + ms`. The composition is the seam
+	* that lets the harness drive Manual and Virtual identically.
+	*/
+	advance(ms) {
+		return Effect.runPromise(this.advanceEffect(toDurationMs(ms)));
+	}
+	advanceEffect(duration) {
+		const self = this;
+		return Effect.gen(function* () {
+			yield* Effect.yieldNow;
+			const target = self.currentTime + duration;
+			while (self.queue.length > 0 && self.earliestDeadline() <= target) yield* self.tickOneEffect();
+			self.currentTime = target;
+		});
+	}
+	findEarliestIndex() {
+		let bestIndex = 0;
+		let best = this.queue[0];
+		for (let i = 1; i < this.queue.length; i++) {
+			const candidate = this.queue[i];
+			if (candidate.deadline < best.deadline || candidate.deadline === best.deadline && candidate.seq < best.seq) {
+				best = candidate;
+				bestIndex = i;
+			}
+		}
+		return bestIndex;
+	}
+	earliestDeadline() {
+		return this.queue[this.findEarliestIndex()].deadline;
+	}
+	static forConformance() {
+		return new ManualClockUnderTest(new ManualClockAdapter({}));
+	}
+};
+var ManualClockUnderTest = class {
+	clock;
+	constructor(clock) {
+		this.clock = clock;
+	}
+	advance(ms) {
+		return this.clock.advance(ms);
+	}
+};
+//#endregion
+//#region src/testing/auth-client/InMemoryAuthClientAdapter.ts
+const DEFAULT_OTP_TTL_MS = toDurationMs(300 * 1e3);
+const DEFAULT_SESSION_TTL_MS = toDurationMs(1440 * 60 * 1e3);
+const DEFAULT_JWT_TTL_MS = toDurationMs(900 * 1e3);
+/**
+* Hermetic OTP + session state machine implementing `AuthClientPort`. Wires
+* through `AuthCachePort` for persistence (clause A11) and `ClockPort`
+* for TTL + expiry math. OTPs are deterministic per-email counters (`"000000"`,
+* `"000001"`, …) so test assertions remain stable. Session tokens are
+* deterministic per-adapter counters (`"tok_0"`, `"tok_1"`, …). Returning users
+* (same email post-signOut) get the same `AuthUserId`.
+*
+* Never throws — every failure path returns `{ ok: false, error: CapxulError }`.
+* Honors `options.signal` via a pre-check (clause A10): an aborted controller
+* before method entry yields `{ ok: false, error: Errors.cancelled({ operation }) }`
+* without any state change.
+*/
+var InMemoryAuthClientAdapter = class {
+	#pendingOtps = /* @__PURE__ */ new Map();
+	#otpCountersByEmail = /* @__PURE__ */ new Map();
+	#authUserIdByEmail = /* @__PURE__ */ new Map();
+	#allocatedAuthUserIds = /* @__PURE__ */ new Set();
+	#authCache;
+	#clock;
+	#otpTtlMs;
+	#failures;
+	#authUserIdCounter = 0;
+	#tokenCounter = 0;
+	#jwtCounter = 0;
+	constructor(deps) {
+		this.#authCache = deps.authCache;
+		this.#clock = deps.clock;
+		this.#otpTtlMs = deps.otpTtlMs ?? DEFAULT_OTP_TTL_MS;
+		this.#failures = deps.failures ?? {};
+	}
+	/** Test affordance: peek the OTP for an email, simulating "user reads email." */
+	peekOtpForTesting(email) {
+		return this.#pendingOtps.get(email)?.otp;
+	}
+	/** Test affordance: make a seeded identity own the session minted for its email. */
+	bindAuthUserIdForTesting(email, authUserId) {
+		this.#authUserIdByEmail.set(email, authUserId);
+		this.#allocatedAuthUserIds.add(authUserId);
+	}
+	async canSendOtp(input, options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "canSendOtp" })
+		};
+		if (this.#failures.canSendOtp !== void 0) return {
+			ok: false,
+			error: this.#failures.canSendOtp
+		};
+		const pending = this.#pendingOtps.get(input.email);
+		if (pending === void 0) return {
+			ok: true,
+			value: {
+				allowed: true,
+				cooldownMs: toDurationMs(0)
+			}
+		};
+		const nowResult = await readClockNow(this.#clock);
+		if (!nowResult.ok) return nowResult;
+		const elapsedMs = nowResult.value - pending.issuedAt;
+		const cooldownMs = Math.max(0, this.#otpTtlMs - elapsedMs);
+		if (cooldownMs === 0) {
+			this.#pendingOtps.delete(input.email);
+			return {
+				ok: true,
+				value: {
+					allowed: true,
+					cooldownMs: toDurationMs(0)
+				}
+			};
+		}
+		return {
+			ok: true,
+			value: {
+				allowed: false,
+				cooldownMs: toDurationMs(cooldownMs)
+			}
+		};
+	}
+	async sendOtp(input, options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "sendOtp" })
+		};
+		if (this.#failures.sendOtp !== void 0) return {
+			ok: false,
+			error: this.#failures.sendOtp
+		};
+		const issuedAt = await readClockNow(this.#clock);
+		if (!issuedAt.ok) return issuedAt;
+		const counter = this.#otpCountersByEmail.get(input.email) ?? 0;
+		this.#otpCountersByEmail.set(input.email, counter + 1);
+		const otp = counter.toString().padStart(6, "0");
+		this.#pendingOtps.set(input.email, {
+			otp,
+			issuedAt: issuedAt.value
+		});
+		return {
+			ok: true,
+			value: void 0
+		};
+	}
+	async verifyOtp(input, options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "verifyOtp" })
+		};
+		if (this.#failures.verifyOtp !== void 0) return {
+			ok: false,
+			error: this.#failures.verifyOtp
+		};
+		const pending = this.#pendingOtps.get(input.email);
+		if (pending === void 0) return {
+			ok: false,
+			error: Errors.invalidInput("email", "no OTP issued for this email")
+		};
+		const nowResult = await readClockNow(this.#clock);
+		if (!nowResult.ok) return nowResult;
+		const now = nowResult.value;
+		if (now - pending.issuedAt > this.#otpTtlMs) {
+			this.#pendingOtps.delete(input.email);
+			return {
+				ok: false,
+				error: Errors.otpExpired()
+			};
+		}
+		if (input.otp !== pending.otp) return {
+			ok: false,
+			error: Errors.invalidInput("otp", "incorrect OTP")
+		};
+		const authUserId = this.#getOrIssueAuthUserId(input.email);
+		const token = toSessionToken(`tok_${this.#tokenCounter++}`);
+		const expiresAt = toEpochMs(now + DEFAULT_SESSION_TTL_MS);
+		const session = {
+			authUserId,
+			email: input.email,
+			token,
+			expiresAt
+		};
+		const cacheWrite = await runAuthCacheEffect(this.#authCache.setSession(session), "setSession");
+		if (!cacheWrite.ok) return cacheWrite;
+		this.#pendingOtps.delete(input.email);
+		return {
+			ok: true,
+			value: session
+		};
+	}
+	async getSession(options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "getSession" })
+		};
+		if (this.#failures.getSession !== void 0) return {
+			ok: false,
+			error: this.#failures.getSession
+		};
+		const cacheRead = await runAuthCacheEffect(this.#authCache.getSession, "getSession");
+		if (!cacheRead.ok) return cacheRead;
+		const persisted = cacheRead.value;
+		if (persisted === null) return {
+			ok: true,
+			value: null
+		};
+		const nowResult = await readClockNow(this.#clock);
+		if (!nowResult.ok) return nowResult;
+		const now = nowResult.value;
+		if (persisted.expiresAt <= now) {
+			const cacheClear = await runAuthCacheEffect(this.#authCache.clearSession, "clearSession");
+			if (!cacheClear.ok) return cacheClear;
+			return {
+				ok: true,
+				value: null
+			};
+		}
+		return {
+			ok: true,
+			value: persisted
+		};
+	}
+	async signOut(options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "signOut" })
+		};
+		if (this.#failures.signOut !== void 0) return {
+			ok: false,
+			error: this.#failures.signOut
+		};
+		return runAuthCacheEffect(this.#authCache.clearSession, "clearSession");
+	}
+	async getConvexJwt(options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "getConvexJwt" })
+		};
+		if (this.#failures.getConvexJwt !== void 0) return {
+			ok: false,
+			error: this.#failures.getConvexJwt
+		};
+		if (options?.forceRefresh !== true) {
+			const cacheRead = await runAuthCacheEffect(this.#authCache.getJwt, "getJwt");
+			if (!cacheRead.ok) return cacheRead;
+			if (cacheRead.value !== null) return {
+				ok: true,
+				value: cacheRead.value
+			};
+		}
+		const now = await readClockNow(this.#clock);
+		if (!now.ok) return now;
+		const jwt = {
+			token: toJwtToken(`in-memory-jwt-${this.#jwtCounter++}`),
+			expEpochSeconds: toEpochSeconds(Math.floor(now.value / 1e3 + DEFAULT_JWT_TTL_MS / 1e3))
+		};
+		const cacheWrite = await runAuthCacheEffect(this.#authCache.setJwt(jwt), "setJwt");
+		if (!cacheWrite.ok) return cacheWrite;
+		return {
+			ok: true,
+			value: jwt
+		};
+	}
+	#getOrIssueAuthUserId(email) {
+		const existing = this.#authUserIdByEmail.get(email);
+		if (existing !== void 0) return existing;
+		let fresh;
+		do
+			fresh = toAuthUserId(`user_${this.#authUserIdCounter++}`);
+		while (this.#allocatedAuthUserIds.has(fresh));
+		this.#authUserIdByEmail.set(email, fresh);
+		this.#allocatedAuthUserIds.add(fresh);
+		return fresh;
+	}
+};
+async function runAuthCacheEffect(effect, operation) {
+	const result = await Effect.runPromise(Effect.result(effect));
+	if (Result.isFailure(result)) return {
+		ok: false,
+		error: Errors.providerError("auth-cache", operation, result.failure)
+	};
+	return {
+		ok: true,
+		value: result.success
+	};
+}
+//#endregion
+//#region src/testing/bootstrap/BootstrapStubAdapter.ts
+var BootstrapStubAdapter = class {
+	#script;
+	constructor(deps) {
+		this.#script = deps.script;
+	}
+	resolve(input) {
+		const key = bootstrapStubScriptKey(input);
+		const failure = this.#script.failures?.get(key);
+		if (failure !== void 0) return fail$2(kindFromCapxulError(failure), failure);
+		const resolution = this.#script.resolutions?.get(key);
+		if (resolution !== void 0) return Effect.succeed(resolution);
+		const defaultFailure = this.#script.defaultFailure ?? Errors.notAuthenticated();
+		return fail$2(kindFromCapxulError(defaultFailure), defaultFailure);
+	}
+};
+function bootstrapStubScriptKey(input) {
+	return `${String(input.publishableKey)}::${input.origin ?? ""}`;
+}
+function kindFromCapxulError(error) {
+	if (error.code === "NOT_AUTHENTICATED") return "notAuthenticated";
+	if (error.code === "NETWORK_ERROR") return "network";
+	if (error.code === "RATE_LIMITED") return "rateLimited";
+	if (error.code === "INVALID_INPUT") return "invalidInput";
+	return "provider";
+}
+function fail$2(kind, error) {
+	return Effect.fail(bootstrapErrorFromCapxul(kind, error));
+}
+//#endregion
+//#region src/testing/convex-call/ConvexCallStubAdapter.ts
+var ConvexCallStubAdapter = class {
+	#script;
+	#subscribers = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.#script = deps.script;
+	}
+	query(fn, _args) {
+		return this.#resolve(getFunctionName(fn));
+	}
+	mutation(fn, _args) {
+		return this.#resolve(getFunctionName(fn));
+	}
+	action(fn, _args) {
+		return this.#resolve(getFunctionName(fn));
+	}
+	subscribe(fn, _args, callback) {
+		return Effect.sync(() => {
+			const path = getFunctionName(fn);
+			const cb = callback;
+			cb({ status: "loading" });
+			const sequence = this.#script.subscriptions?.get(path);
+			const subscriber = {
+				callback: cb,
+				cursor: 0
+			};
+			let subs = this.#subscribers.get(path);
+			if (subs === void 0) {
+				subs = /* @__PURE__ */ new Set();
+				this.#subscribers.set(path, subs);
+			}
+			subs.add(subscriber);
+			if (sequence !== void 0 && sequence.length > 0) {
+				cb(sequence[0]);
+				subscriber.cursor = 1;
+			}
+			let active = true;
+			return () => {
+				if (!active) return;
+				active = false;
+				const liveSubs = this.#subscribers.get(path);
+				if (liveSubs === void 0) return;
+				liveSubs.delete(subscriber);
+				if (liveSubs.size === 0) this.#subscribers.delete(path);
+			};
+		});
+	}
+	advanceSubscription(path) {
+		const sequence = this.#script.subscriptions?.get(path);
+		if (sequence === void 0) return;
+		const subs = this.#subscribers.get(path);
+		if (subs === void 0) return;
+		for (const sub of subs) {
+			if (sub.cursor >= sequence.length) continue;
+			const next = sequence[sub.cursor];
+			sub.cursor += 1;
+			sub.callback(next);
+		}
+	}
+	#resolve(path) {
+		const failure = this.#script.failures?.get(path);
+		if (failure !== void 0) return Effect.fail(mapFailure(path, failure));
+		if (this.#script.responses?.has(path)) return Effect.succeed(this.#script.responses.get(path));
+		return Effect.fail(convexCallErrorFromCapxul(path, Errors.providerError("convex", path, "unknown function")));
+	}
+};
+function mapFailure(operation, failure) {
+	if (failure instanceof CapxulError) return convexCallErrorFromCapxul(operation, failure);
+	if (failure instanceof Error) return convexCallErrorFromCapxul(operation, Errors.providerError("convex", operation, failure));
+	return convexCallErrorFromCapxul(operation, Errors.providerError("convex", operation, new Error(String(failure))));
+}
+//#endregion
+//#region src/testing/identity/InMemoryIdentityAdapter.ts
+var InMemoryIdentityAdapter = class {
+	#identities = /* @__PURE__ */ new Map();
+	#clock;
+	constructor(deps) {
+		this.#clock = deps.clock;
+	}
+	loadByAuthUserId(authUserId) {
+		return Effect.sync(() => cloneProfileOrNull(this.#identities.get(authUserId) ?? null));
+	}
+	create(input) {
+		const self = this;
+		return Effect.gen(function* () {
+			if (self.#identities.has(input.authUserId)) return yield* fail$1("create", Errors.invalidInput("authUserId", "already exists"));
+			const now = yield* self.#now("create.clock");
+			const profile = {
+				authUserId: input.authUserId,
+				email: input.email,
+				displayName: input.displayName ?? null,
+				country: input.country ?? null,
+				onboarded: false,
+				withdrawalAddress: null,
+				username: null,
+				imageUrl: null,
+				kycTier: toKycTier(0),
+				createdAt: now,
+				updatedAt: now
+			};
+			self.#identities.set(input.authUserId, cloneProfile(profile));
+			return cloneProfile(profile);
+		});
+	}
+	update(input) {
+		const self = this;
+		return Effect.gen(function* () {
+			const existing = self.#identities.get(input.authUserId);
+			if (existing === void 0) return yield* fail$1("update", Errors.profileNotFound(input.authUserId));
+			const now = yield* self.#now("update.clock");
+			const updated = {
+				authUserId: existing.authUserId,
+				email: existing.email,
+				kycTier: existing.kycTier,
+				createdAt: existing.createdAt,
+				displayName: input.displayName !== void 0 ? input.displayName : existing.displayName,
+				country: input.country !== void 0 ? input.country : existing.country,
+				onboarded: existing.onboarded,
+				withdrawalAddress: existing.withdrawalAddress,
+				username: existing.username,
+				imageUrl: existing.imageUrl,
+				updatedAt: now
+			};
+			self.#identities.set(input.authUserId, cloneProfile(updated));
+			return cloneProfile(updated);
+		});
+	}
+	completeOnboarding(input) {
+		const self = this;
+		return Effect.gen(function* () {
+			const now = yield* self.#now("completeOnboarding.clock");
+			const existing = self.#identities.get(input.authUserId);
+			const profile = {
+				authUserId: input.authUserId,
+				email: existing?.email ?? input.email,
+				displayName: input.displayName,
+				country: input.country,
+				onboarded: true,
+				withdrawalAddress: input.withdrawalAddress ?? existing?.withdrawalAddress ?? null,
+				username: existing?.username ?? null,
+				imageUrl: existing?.imageUrl ?? null,
+				kycTier: existing?.kycTier ?? toKycTier(0),
+				createdAt: existing?.createdAt ?? now,
+				updatedAt: now
+			};
+			self.#identities.set(input.authUserId, cloneProfile(profile));
+			return cloneProfile(profile);
+		});
+	}
+	#now(operation) {
+		return this.#clock.now.pipe(Effect.mapError((cause) => identityErrorFromCapxul(operation, Errors.providerError("clock", "now", cause), cause)));
+	}
+};
+function fail$1(operation, error) {
+	return Effect.fail(identityErrorFromCapxul(operation, error));
+}
+function cloneProfile(profile) {
+	return {
+		authUserId: profile.authUserId,
+		email: profile.email,
+		displayName: profile.displayName,
+		country: profile.country,
+		onboarded: profile.onboarded,
+		withdrawalAddress: profile.withdrawalAddress,
+		username: profile.username,
+		imageUrl: profile.imageUrl,
+		kycTier: profile.kycTier,
+		createdAt: profile.createdAt,
+		updatedAt: profile.updatedAt
+	};
+}
+function cloneProfileOrNull(profile) {
+	return profile === null ? null : cloneProfile(profile);
+}
+//#endregion
+//#region src/testing/smart-account/smart-account-derivation.ts
+const SUPPORTED_CHAIN_IDS = new Set([84532, 8453]);
+toAddress("0xa6b71e26c5e0845f74c812102ca7114b6a896ab2");
+keccak256("0x");
+function isSupportedSmartAccountChain(chainId) {
+	return SUPPORTED_CHAIN_IDS.has(wireChainId(chainId));
+}
+//#endregion
+//#region src/testing/smart-account/InMemorySmartAccountAdapter.ts
+/**
+* Hermetic backend stand-in (PRD #462 / derivation v2): `provision` derives
+* the Safe from the identity email alone via the REAL canonical derivation
+* (`deriveCapxulSafeAddress({ email })` — owner is the pinned bootstrap
+* constant). No signer exists at provision; `claim` installs the signer and
+* marks the row deployed, mirroring the backend's one-userOp claim lane.
+*/
+var InMemorySmartAccountAdapter = class {
+	#accounts = /* @__PURE__ */ new Map();
+	#clock;
+	#identity;
+	#failures;
+	#provisionMutex = Semaphore.makeUnsafe(1);
+	constructor(deps) {
+		this.#clock = deps.clock;
+		this.#identity = deps.identity;
+		this.#failures = deps.failures;
+	}
+	loadByAuthUserId(authUserId) {
+		const scriptedFailure = this.#failures?.loadByAuthUserId;
+		if (scriptedFailure !== void 0) return fail("loadByAuthUserId", scriptedFailure);
+		return Effect.sync(() => cloneSmartAccountOrNull(this.#accounts.get(authUserId) ?? null));
+	}
+	loadBySmartAccountAddress(address) {
+		const scriptedFailure = this.#failures?.loadBySmartAccountAddress;
+		if (scriptedFailure !== void 0) return fail("loadBySmartAccountAddress", scriptedFailure);
+		return Effect.sync(() => {
+			const needle = toAddress(address);
+			for (const account of this.#accounts.values()) if (account.smartAccountAddress === needle) return cloneSmartAccount(account);
+			return null;
+		});
+	}
+	provision(input) {
+		const scriptedFailure = this.#failures?.provision;
+		if (scriptedFailure !== void 0) return fail("provision", scriptedFailure);
+		const self = this;
+		return Effect.gen(function* () {
+			if (!isSupportedSmartAccountChain(input.chainId)) return yield* fail("provision", Errors.invalidInput("chainId", `unsupported chainId ${String(input.chainId)}`));
+			const identity = yield* self.#identity.loadByAuthUserId(input.authUserId).pipe(Effect.mapError((error) => smartAccountErrorFromCapxul("provision.identity", error.publicError, error)));
+			if (identity === null) return yield* fail("provision", Errors.profileNotFound(String(input.authUserId)));
+			const existing = self.#accounts.get(input.authUserId);
+			if (existing !== void 0) return cloneSmartAccount(existing);
+			const now = yield* self.#now("provision.clock");
+			const account = {
+				authUserId: input.authUserId,
+				signerAddress: null,
+				smartAccountAddress: toAddress(deriveCapxulSafeAddress({ email: identity.email })),
+				chainId: input.chainId,
+				deployedAt: null,
+				claimedAt: null,
+				createdAt: now
+			};
+			self.#accounts.set(input.authUserId, cloneSmartAccount(account));
+			return cloneSmartAccount(account);
+		}).pipe(self.#provisionMutex.withPermits(1));
+	}
+	promoteDeployedAt(authUserId, deployedAt) {
+		const existing = this.#accounts.get(authUserId);
+		if (existing === void 0) return;
+		if (existing.deployedAt !== null) return;
+		this.#accounts.set(authUserId, {
+			...existing,
+			deployedAt
+		});
+	}
+	confirmDeployment(input) {
+		const self = this;
+		return Effect.gen(function* () {
+			const existing = self.#accounts.get(input.authUserId);
+			if (existing === void 0) return yield* fail("confirmDeployment", Errors.profileNotFound(String(input.authUserId)));
+			if (existing.smartAccountAddress !== toAddress(input.safeAddress)) return yield* fail("confirmDeployment", Errors.invalidInput("safeAddress", "does not match backend smart-account row"));
+			if (existing.deployedAt !== null) return cloneSmartAccount(existing);
+			const now = yield* self.#now("confirmDeployment.clock");
+			const updated = {
+				...existing,
+				deployedAt: now
+			};
+			self.#accounts.set(input.authUserId, cloneSmartAccount(updated));
+			return cloneSmartAccount(updated);
+		}).pipe(self.#provisionMutex.withPermits(1));
+	}
+	claim(input) {
+		const scriptedFailure = this.#failures?.claim;
+		if (scriptedFailure !== void 0) return fail("claim", scriptedFailure);
+		const self = this;
+		return Effect.gen(function* () {
+			const existing = self.#accounts.get(input.authUserId);
+			if (existing === void 0) return yield* fail("claim", Errors.invalidInput("account", "no provisioned smart account for this user"));
+			if (existing.chainId !== input.chainId) return yield* fail("claim", Errors.invalidInput("chainId", "does not match backend smart-account row"));
+			const newOwner = toAddress(input.signerAddress);
+			if (existing.claimedAt !== null) {
+				if (existing.signerAddress !== newOwner) return yield* fail("claim", Errors.invalidInput("signerAddress", "account already claimed by a different signer"));
+				return cloneSmartAccount(existing);
+			}
+			const now = yield* self.#now("claim.clock");
+			const updated = {
+				...existing,
+				signerAddress: newOwner,
+				claimedAt: now,
+				deployedAt: existing.deployedAt ?? now
+			};
+			self.#accounts.set(input.authUserId, cloneSmartAccount(updated));
+			return cloneSmartAccount(updated);
+		}).pipe(self.#provisionMutex.withPermits(1));
+	}
+	#now(operation) {
+		return this.#clock.now.pipe(Effect.mapError((cause) => smartAccountErrorFromCapxul(operation, Errors.providerError("clock", "now", cause), cause)));
+	}
+};
+function fail(operation, error) {
+	return Effect.fail(smartAccountErrorFromCapxul(operation, error));
+}
+function cloneSmartAccount(account) {
+	return {
+		authUserId: account.authUserId,
+		signerAddress: account.signerAddress,
+		smartAccountAddress: account.smartAccountAddress,
+		chainId: account.chainId,
+		deployedAt: account.deployedAt,
+		claimedAt: account.claimedAt,
+		createdAt: account.createdAt
+	};
+}
+function cloneSmartAccountOrNull(account) {
+	return account === null ? null : cloneSmartAccount(account);
+}
+//#endregion
+//#region src/testing/sub-account/InMemorySubAccountAdapter.ts
+var InMemorySubAccountAdapter = class {
+	#rows = /* @__PURE__ */ new Map();
+	#failures;
+	#balanceOfRaw;
+	#created;
+	constructor(deps = {}) {
+		this.#failures = deps.failures ?? {};
+		this.#balanceOfRaw = deps.balanceOfRaw ?? "0";
+		for (const row of deps.seed ?? []) this.#rows.set(row.id, row);
+		this.#created = this.#rows.size;
+	}
+	create(input) {
+		const failure = this.#failures.create;
+		if (failure !== void 0) return Effect.fail(subAccountErrorFromCapxul("create", failure));
+		this.#created += 1;
+		const id = toSubAccountId(`subaccount_test${String(this.#created)}`);
+		const row = {
+			id,
+			accountId: input.accountId,
+			name: input.name,
+			balance: {
+				currency: toCurrencyCode("USD"),
+				value: "0",
+				decimals: 6
+			},
+			createdAt: toEpochMs(Date.now())
+		};
+		this.#rows.set(id, row);
+		return Effect.succeed(row);
+	}
+	get(input) {
+		return Effect.succeed(this.#rows.get(input.subAccountId) ?? null);
+	}
+	list(input) {
+		const accountId = input.accountId;
+		return Effect.succeed([...this.#rows.values()].filter((row) => row.accountId === accountId));
+	}
+	rename(input) {
+		const existing = this.#rows.get(input.subAccountId);
+		if (existing === void 0) return Effect.fail(subAccountErrorFromCapxul("rename", Errors.accountNotFound(input.subAccountId)));
+		const next = {
+			...existing,
+			name: input.name
+		};
+		this.#rows.set(input.subAccountId, next);
+		return Effect.succeed(next);
+	}
+	delete(input) {
+		const existing = this.#rows.get(input.subAccountId);
+		if (existing === void 0) return Effect.fail(subAccountErrorFromCapxul("delete", Errors.accountNotFound(input.subAccountId)));
+		if (Number(existing.balance.value) !== 0) return Effect.fail(subAccountErrorFromCapxul("delete", Errors.invalidInput("subAccountId", "delete requires zero balance")));
+		this.#rows.delete(input.subAccountId);
+		return Effect.succeed(void 0);
+	}
+	transfer(input) {
+		const decimals = input.amount.decimals;
+		const invalid = (field, reason) => Effect.fail(subAccountErrorFromCapxul("transfer", Errors.invalidInput(field, reason)));
+		let rawAmount;
+		try {
+			rawAmount = BigInt(toWei(input.amount));
+		} catch {
+			return invalid("amount", "must be a decimal money string");
+		}
+		if (rawAmount <= 0n) return invalid("amount", "must be positive");
+		if (input.from === input.to) return invalid("transfer", "from and to must differ");
+		const fromRow = input.from === "main" ? null : this.#rows.get(input.from) ?? "missing";
+		if (fromRow === "missing") return invalid("subAccountId", "unknown sub-account");
+		const toRow = input.to === "main" ? null : this.#rows.get(input.to) ?? "missing";
+		if (toRow === "missing") return invalid("subAccountId", "unknown sub-account");
+		const safeRaw = BigInt(this.#balanceOfRaw);
+		const subTotalRaw = this.#sumSubAccountRaws(decimals);
+		if (input.from === "main") {
+			const availableRaw = safeRaw - subTotalRaw;
+			if (availableRaw < rawAmount) return Effect.fail(subAccountErrorFromCapxul("transfer", Errors.insufficientBalance("main", maxRaw(availableRaw), rawAmount.toString(10))));
+		} else if (fromRow !== null) {
+			const fromRaw = BigInt(toWei({
+				value: fromRow.balance.value,
+				decimals
+			}));
+			if (fromRaw < rawAmount) return Effect.fail(subAccountErrorFromCapxul("transfer", Errors.insufficientBalance(fromRow.name, fromRaw.toString(10), rawAmount.toString(10))));
+		}
+		let nextFrom = null;
+		let nextTo = null;
+		if (fromRow !== null) {
+			const fromRaw = BigInt(toWei({
+				value: fromRow.balance.value,
+				decimals
+			}));
+			nextFrom = this.#patchBalance(fromRow, (fromRaw - rawAmount).toString(10), decimals);
+		}
+		if (toRow !== null) {
+			const toRaw = BigInt(toWei({
+				value: toRow.balance.value,
+				decimals
+			}));
+			nextTo = this.#patchBalance(toRow, (toRaw + rawAmount).toString(10), decimals);
+		}
+		const available = fromWei(maxRaw(safeRaw - this.#sumSubAccountRaws(decimals)), decimals, input.amount.currency);
+		return Effect.succeed({
+			available,
+			from: nextFrom,
+			to: nextTo
+		});
+	}
+	#sumSubAccountRaws(decimals) {
+		let total = 0n;
+		for (const row of this.#rows.values()) total += BigInt(toWei({
+			value: row.balance.value,
+			decimals
+		}));
+		return total;
+	}
+	#patchBalance(row, rawBalance, decimals) {
+		const balance = fromWei(rawBalance, decimals, row.balance.currency);
+		const next = {
+			...row,
+			balance
+		};
+		this.#rows.set(row.id, next);
+		return next;
+	}
+};
+/** Floor a (possibly negative) base-unit raw to a non-negative base-10 string. */
+function maxRaw(raw) {
+	return (raw < 0n ? 0n : raw).toString(10);
+}
+//#endregion
+//#region src/testing/telemetry/RecordingTelemetryAdapter.ts
+var RecordingTelemetryAdapter = class {
+	#events = [];
+	#operations = [];
+	#rawMode;
+	constructor(options = {}) {
+		this.#rawMode = options.rawMode === true;
+	}
+	get events() {
+		return this.#events.map(cloneEvent);
+	}
+	get operations() {
+		return this.#operations.map(cloneOperation);
+	}
+	emit(event) {
+		return Effect.sync(() => {
+			const recorded = redactTelemetryEvent(event, { rawMode: this.#rawMode });
+			this.#events.push(recorded);
+			this.#operations.push({
+				type: "emit",
+				event: cloneEvent(recorded)
+			});
+		});
+	}
+	identify(input) {
+		return Effect.sync(() => {
+			this.#operations.push({
+				type: "identify",
+				input: cloneIdentifyInput(input)
+			});
+		});
+	}
+	group(input) {
+		return Effect.sync(() => {
+			this.#operations.push({
+				type: "group",
+				input: cloneGroupInput(input)
+			});
+		});
+	}
+	reset() {
+		return Effect.sync(() => {
+			this.#operations.push({ type: "reset" });
+		});
+	}
+	clear() {
+		this.#events.length = 0;
+		this.#operations.length = 0;
+	}
+};
+function cloneEvent(event) {
+	return event.props === void 0 ? { name: event.name } : {
+		name: event.name,
+		props: cloneProps(event.props)
+	};
+}
+function cloneOperation(operation) {
+	switch (operation.type) {
+		case "emit": return {
+			type: "emit",
+			event: cloneEvent(operation.event)
+		};
+		case "identify": return {
+			type: "identify",
+			input: cloneIdentifyInput(operation.input)
+		};
+		case "group": return {
+			type: "group",
+			input: cloneGroupInput(operation.input)
+		};
+		case "reset": return { type: "reset" };
+	}
+}
+function cloneIdentifyInput(input) {
+	return {
+		distinctId: input.distinctId,
+		...input.anonDistinctId === void 0 ? {} : { anonDistinctId: input.anonDistinctId },
+		...input.traits === void 0 ? {} : { traits: cloneProps(input.traits) },
+		...input.properties === void 0 ? {} : { properties: cloneProps(input.properties) }
+	};
+}
+function cloneGroupInput(input) {
+	return input.properties === void 0 ? {
+		groupType: input.groupType,
+		groupKey: input.groupKey
+	} : {
+		groupType: input.groupType,
+		groupKey: input.groupKey,
+		properties: cloneProps(input.properties)
+	};
+}
+function cloneProps(props) {
+	const cloned = {};
+	for (const [key, value] of Object.entries(props)) cloned[key] = cloneTelemetryValue(value);
+	return cloned;
+}
+function cloneTelemetryValue(value) {
+	if (Array.isArray(value)) return value.map(cloneTelemetryValue);
+	if (value === null || typeof value !== "object") return value;
+	if (Object.getPrototypeOf(value) !== Object.prototype) return value;
+	const cloned = {};
+	for (const [key, nested] of Object.entries(value)) cloned[key] = cloneTelemetryValue(nested);
+	return cloned;
+}
+//#endregion
+//#region src/testing/index.ts
+const TEST_BOOTSTRAP = {
+	applicationId: toAppId("app_01HX0000000000000000000000"),
+	chainId: toChainId(84532),
+	sessionToken: toSessionToken("bootstrap-test-token"),
+	issuedAt: toEpochMs(0),
+	expiresIn: toDurationMs(6e4),
+	authBaseUrl: "https://auth.example.test",
+	convexUrl: "https://convex.example.test",
+	siteBaseUrl: "https://example.test",
+	openfortPublishableKey: "pk_test_openfort_fixture",
+	shieldPublishableKey: "shield_pk_test_fixture"
+};
+/**
+* Assemble the real public client over deterministic in-memory ports.
+* Unconfigured backend calls fail locally; no adapter owns a network exit.
+*/
+function createCapxulTestClient(options = {}) {
+	const clock = new ManualClockAdapter({});
+	const authCache = new InMemoryAuthCacheAdapter();
+	const authClient = new InMemoryAuthClientAdapter({
+		authCache,
+		clock
+	});
+	const identity = new InMemoryIdentityAdapter({ clock });
+	const telemetry = new RecordingTelemetryAdapter();
+	const client = assembleCapxulClient({
+		ports: {
+			authClient: authClientPortFromPromiseAdapter(authClient),
+			authCache,
+			identity,
+			smartAccount: new InMemorySmartAccountAdapter({
+				clock,
+				identity
+			}),
+			accountRead: new InMemoryAccountReadAdapter({ rawBalance: "0" }),
+			subAccount: new InMemorySubAccountAdapter(),
+			bootstrap: new BootstrapStubAdapter({ script: { resolutions: new Map([[`${toPublishableKey("cap_pk_test_0123456789ABCDEFGHJKMNPQRSTVWXYZ")}::${toAllowedOrigin("https://example.test")}`, TEST_BOOTSTRAP]]) } }),
+			clock,
+			telemetry,
+			convexCall: new ConvexCallStubAdapter({ script: {} })
+		},
+		bootstrap: TEST_BOOTSTRAP,
+		authCache,
+		requirement: options.requirement ?? "none"
+	});
+	const transitions = [];
+	const unsubscribe = client._internal.identity.subscribeTransitions((record) => {
+		transitions.push(record);
+	});
+	let closed = false;
+	return {
+		client,
+		clock: Object.freeze({ advance: (ms) => clock.advance(ms) }),
+		observation: {
+			emit: (event) => Effect.runPromise(telemetry.emit(event)),
+			identify: (input) => Effect.runPromise(telemetry.identify(input)),
+			group: (input) => Effect.runPromise(telemetry.group(input)),
+			reset: () => Effect.runPromise(telemetry.reset())
+		},
+		get transitions() {
+			return transitions.slice();
+		},
+		get observations() {
+			return telemetry.operations;
+		},
+		peekOtp: (email) => authClient.peekOtpForTesting(toEmail(email)),
+		seedIdentity: async (input) => {
+			const authUserId = toAuthUserId(input.authUserId);
+			const email = toEmail(input.email);
+			await Effect.runPromise(identity.create({
+				authUserId,
+				email,
+				...input.displayName === void 0 ? {} : { displayName: input.displayName },
+				...input.country === void 0 ? {} : { country: toCountryCode(input.country) }
+			}));
+			authClient.bindAuthUserIdForTesting(email, authUserId);
+		},
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			unsubscribe();
+			await client._internal.close?.();
+		}
+	};
+}
+//#endregion
+export { createCapxulTestClient };
+
+//# sourceMappingURL=index.mjs.map