@fased/fased 0.1.65 → 0.1.67

package/dist/utils.js

@@ -2,20 +2,20 @@ import { expandHomePrefix, resolveEffectiveHomeDir, resolveRequiredHomeDir } fro
 import { resolveOAuthDir } from "./config/paths.js";
 import { logVerbose, shouldLogVerbose } from "./globals.js";
 import { isPlainObject } from "./infra/plain-object.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
 //#region src/utils.ts
 async function ensureDir(dir) {
-	await syncFs.promises.mkdir(dir, { recursive: true });
+	await fs.promises.mkdir(dir, { recursive: true });
 }
 /**
 * Check if a file or directory exists at the given path.
 */
 async function pathExists(targetPath) {
 	try {
-		await syncFs.promises.access(targetPath);
+		await fs.promises.access(targetPath);
 		return true;
 	} catch {
 		return false;
@@ -129,7 +129,7 @@ function readLidReverseMapping(lid, opts) {
 	for (const dir of mappingDirs) {
 		const mappingPath = path.join(dir, mappingFilename);
 		try {
-			const data = syncFs.readFileSync(mappingPath, "utf8");
+			const data = fs.readFileSync(mappingPath, "utf8");
 			const phone = JSON.parse(data);
 			if (phone === null || phone === undefined) {
 				continue;
@@ -250,7 +250,7 @@ function resolveConfigDir(env = process.env, homedir = os.homedir) {
 	}
 	const newDir = path.join(resolveRequiredHomeDir(env, homedir), ".fased");
 	try {
-		const hasNew = syncFs.existsSync(newDir);
+		const hasNew = fs.existsSync(newDir);
 		if (hasNew) {
 			return newDir;
 		}

package/dist/wallet/external-submission-ledger.js

@@ -2,7 +2,7 @@ import { resolveProcessScopedMap } from "../shared/process-scoped-map.js";
 import { acquireFileLock, withFileLock } from "../plugin-sdk/file-lock.js";
 import "../infra/file-lock.js";
 import { ensureWalletStateDir } from "./wallet-runtime-config.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { createHash, randomBytes } from "node:crypto";
 
@@ -212,7 +212,7 @@ function validateEntry(value) {
 }
 function loadLedger(env) {
 	const filePath = ledgerPath(env);
-	if (!syncFs.existsSync(filePath)) {
+	if (!fs.existsSync(filePath)) {
 		return {
 			version: 1,
 			entries: []
@@ -220,7 +220,7 @@ function loadLedger(env) {
 	}
 	let parsed;
 	try {
-		parsed = JSON.parse(syncFs.readFileSync(filePath, "utf8"));
+		parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
 	} catch (error) {
 		throw new Error("external submission ledger is unreadable; refusing a potentially duplicate transaction", { cause: error });
 	}
@@ -241,19 +241,19 @@ function saveLedger(file, env) {
 	const temporary = `${filePath}.tmp-${process.pid}-${randomBytes(6).toString("hex")}`;
 	let descriptor;
 	try {
-		descriptor = syncFs.openSync(temporary, "wx", 384);
-		syncFs.writeFileSync(descriptor, `${JSON.stringify(file, null, 2)}\n`, "utf8");
-		syncFs.fsyncSync(descriptor);
-		syncFs.closeSync(descriptor);
+		descriptor = fs.openSync(temporary, "wx", 384);
+		fs.writeFileSync(descriptor, `${JSON.stringify(file, null, 2)}\n`, "utf8");
+		fs.fsyncSync(descriptor);
+		fs.closeSync(descriptor);
 		descriptor = undefined;
-		syncFs.renameSync(temporary, filePath);
-		syncFs.chmodSync(filePath, 384);
+		fs.renameSync(temporary, filePath);
+		fs.chmodSync(filePath, 384);
 		try {
-			const directory = syncFs.openSync(path.dirname(filePath), "r");
+			const directory = fs.openSync(path.dirname(filePath), "r");
 			try {
-				syncFs.fsyncSync(directory);
+				fs.fsyncSync(directory);
 			} finally {
-				syncFs.closeSync(directory);
+				fs.closeSync(directory);
 			}
 		} catch (error) {
 			const code = error.code;
@@ -263,10 +263,10 @@ function saveLedger(file, env) {
 		}
 	} finally {
 		if (descriptor !== undefined) {
-			syncFs.closeSync(descriptor);
+			fs.closeSync(descriptor);
 		}
 		try {
-			syncFs.unlinkSync(temporary);
+			fs.unlinkSync(temporary);
 		} catch {}
 	}
 }

package/dist/wallet/local-socket-signer-protocol.js

@@ -109,11 +109,14 @@ const SignerSatInstructionV2Schema = Type.Object({
 }, { additionalProperties: false });
 const SignerSatLookupTableV2Schema = Type.Object({
 	address: Type.String(),
+	cycleId: Type.String({ pattern: "^(0|[1-9][0-9]*)$" }),
+	pageIndex: Type.String({ pattern: "^(0|[1-9][0-9]*)$" }),
 	recentSlot: Type.Optional(Type.String({ pattern: "^(0|[1-9][0-9]*)$" })),
 	addresses: Type.Optional(Type.Array(Type.String(), {
 		minItems: 1,
 		maxItems: 20
-	}))
+	})),
+	parent: Type.Optional(SignerSatInstructionV2Schema)
 }, { additionalProperties: false });
 const SignerFederationBondChallengeV2Schema = Type.Object({
 	challengeId: Type.String({
@@ -180,6 +183,10 @@ const SignerIntentV2Schema = Type.Union([
 		instructions: Type.Optional(Type.Array(SignerSatInstructionV2Schema, {
 			minItems: 1,
 			maxItems: 6
+		})),
+		addressLookupTables: Type.Optional(Type.Array(Type.String(), {
+			minItems: 1,
+			maxItems: 1
 		}))
 	}, { additionalProperties: false }),
 	Type.Object({
@@ -264,6 +271,27 @@ const SignerWalletPolicyCreateV2Schema = Type.Object({
 	policy: SignerPolicyInputV2Schema
 }, { additionalProperties: false });
 const SignerOperationLookupV2Schema = Type.Object({ requestId: Type.String() }, { additionalProperties: false });
+const SignerSatLookupBindingRequestV2Schema = Type.Object({
+	cycleId: Type.String({ pattern: "^(0|[1-9][0-9]*)$" }),
+	pageIndex: Type.String({ pattern: "^(0|[1-9][0-9]*)$" })
+}, { additionalProperties: false });
+const LocalSocketSignerSatLookupBindingV2Schema = Type.Object({
+	cycleId: Type.String({ pattern: "^(0|[1-9][0-9]*)$" }),
+	pageIndex: Type.String({ pattern: "^(0|[1-9][0-9]*)$" }),
+	address: Type.Optional(Type.String({ minLength: 1 })),
+	bound: Type.Boolean(),
+	mutationRequestId: Type.Optional(Type.String({
+		minLength: 8,
+		maxLength: 128
+	})),
+	mutationState: Type.Optional(Type.Union([
+		Type.Literal("reserved"),
+		Type.Literal("broadcast"),
+		Type.Literal("confirmed"),
+		Type.Literal("failed"),
+		Type.Literal("unknown")
+	]))
+}, { additionalProperties: false });
 const LocalSocketSignerRequestSchema = Type.Union([
 	Type.Object({ op: Type.Literal("health") }, { additionalProperties: false }),
 	Type.Object({ op: Type.Literal("v2.capabilities") }, { additionalProperties: false }),
@@ -374,6 +402,11 @@ const LocalSocketSignerRequestSchema = Type.Union([
 		walletId: Type.String(),
 		request: SignerOperationLookupV2Schema
 	}, { additionalProperties: false }),
+	Type.Object({
+		op: Type.Literal("v2.satLookup.binding.get"),
+		walletId: Type.String(),
+		request: SignerSatLookupBindingRequestV2Schema
+	}, { additionalProperties: false }),
 	Type.Object({
 		op: Type.Literal("getAddresses"),
 		walletId: Type.String({ minLength: 1 })
@@ -643,6 +676,7 @@ function validateLocalSocketSignerResult(op, result) {
 		case "v2.execute":
 		case "v2.operation.get":
 		case "v2.operation.reconcile": return Value.Check(LocalSocketSignerOperationV2Schema, result);
+		case "v2.satLookup.binding.get": return Value.Check(LocalSocketSignerSatLookupBindingV2Schema, result);
 		case "v2.review.get":
 		case "v2.review.prepare": return Value.Check(LocalSocketSignerReviewV2Schema, result);
 		case "v2.review.execute": return Value.Check(LocalSocketSignerReviewExecutionV2Schema, result);

package/dist/wallet/providers/local-socket-signer-adapter.js

@@ -3,7 +3,7 @@ import { WalletProviderError } from "../wallet-provider-adapter.js";
 import { LOCAL_SIGNER_NATIVE_FEE_RESERVATION_LAMPORTS_V2, parseLocalSocketSignerRequest, parseLocalSocketSignerResponseEnvelope, validateLocalSocketSignerResult } from "../local-socket-signer-protocol.js";
 import { SIGNER_PROTOCOL_V2_REQUIRED_CLIENT_FEATURES } from "../signer-protocol-v2.generated.js";
 import { redactWalletDiagnosticText, walletDiagnosticErrorMessage, walletDiagnosticErrorString } from "../wallet-redaction.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import net from "node:net";
 
@@ -31,6 +31,7 @@ const SIGNER_SOCKET_TIMEOUT_MS = {
 	"v2.review.authorization.finish": 3e4,
 	"v2.operation.get": 5e3,
 	"v2.operation.reconcile": 2e4,
+	"v2.satLookup.binding.get": 5e3,
 	getAddresses: 1e4,
 	getBalance: 15e3
 };
@@ -40,7 +41,7 @@ function signerTimeoutFor(payload) {
 function assertSecureLocalSignerSocket(socketPath) {
 	let stat;
 	try {
-		stat = syncFs.lstatSync(socketPath);
+		stat = fs.lstatSync(socketPath);
 	} catch (err) {
 		throw new WalletProviderError({
 			code: "wallet_provider_unavailable",

package/dist/wallet/signer-network-admin.js

@@ -106,11 +106,16 @@ function configureSignerOwnedWalletNetwork(params) {
 	const env = params.env ?? process.env;
 	const walletId = canonicalSignerWalletId(params.walletId);
 	const primaryRpcUrl = params.primaryRpcUrl.trim();
-	const fallbackRpcUrl = params.fallbackRpcUrl?.trim() || "";
+	const executionFallbackRpcUrl = params.executionFallbackRpcUrl?.trim() || "";
+	const verificationRpcUrl = params.verificationRpcUrl?.trim() || "";
 	if (!primaryRpcUrl) {
 		throw new Error("signer-owned wallet network requires a primary RPC URL");
 	}
-	const secrets = [primaryRpcUrl, fallbackRpcUrl];
+	const secrets = [
+		primaryRpcUrl,
+		executionFallbackRpcUrl,
+		verificationRpcUrl
+	];
 	const hosting = String(env.FASED_HOST_PROFILE ?? "").trim().toLowerCase() === "hosting";
 	if (hosting) {
 		return {
@@ -145,7 +150,8 @@ function configureSignerOwnedWalletNetwork(params) {
 	const input = `${JSON.stringify({
 		expectedVersion: current.version,
 		primaryRpcUrl,
-		...fallbackRpcUrl ? { fallbackRpcUrl } : {}
+		...executionFallbackRpcUrl ? { executionFallbackRpcUrl } : {},
+		...verificationRpcUrl ? { verificationRpcUrl } : {}
 	})}\n`;
 	const updated = parseSignerNetworkSummary(runSignerAdmin({
 		command: signerBinPath,

package/dist/wallet/solana-network-discovery.js

@@ -0,0 +1,113 @@
+//#region src/wallet/solana-network-discovery.ts
+const OFFICIAL_SOLANA_RPC_URLS = {
+	"mainnet-beta": "https://api.mainnet-beta.solana.com",
+	devnet: "https://api.devnet.solana.com",
+	testnet: "https://api.testnet.solana.com"
+};
+function parseRpcUrl(raw) {
+	try {
+		return new URL(raw.trim());
+	} catch {
+		throw new Error("Solana RPC URL is invalid");
+	}
+}
+function isLoopbackRpc(url) {
+	const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+	return hostname === "localhost" || hostname === "localnet" || hostname === "127.0.0.1" || hostname === "::1";
+}
+function officialNetworkFor(url) {
+	const normalized = `${url.protocol}//${url.host}${url.pathname.replace(/\/+$/, "")}`;
+	return Object.entries(OFFICIAL_SOLANA_RPC_URLS).find(([, rpcUrl]) => normalized === rpcUrl)?.[0];
+}
+async function fetchGenesisHash(params) {
+	const controller = new AbortController();
+	let timeout;
+	try {
+		return await Promise.race([(async () => {
+			const response = await params.fetchImpl(params.rpcUrl, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					jsonrpc: "2.0",
+					id: 1,
+					method: "getGenesisHash",
+					params: []
+				}),
+				signal: controller.signal
+			});
+			if (!response.ok) {
+				throw new Error("RPC request failed");
+			}
+			const declaredLength = Number(response.headers.get("content-length") ?? "0");
+			if (Number.isFinite(declaredLength) && declaredLength > 16 * 1024) {
+				throw new Error("RPC response is too large");
+			}
+			const body = await response.text();
+			if (body.length > 16 * 1024) {
+				throw new Error("RPC response is too large");
+			}
+			const payload = JSON.parse(body);
+			if (payload.error || typeof payload.result !== "string" || !payload.result.trim()) {
+				throw new Error("RPC returned an invalid genesis hash");
+			}
+			return payload.result.trim();
+		})(), new Promise((_resolve, reject) => {
+			timeout = setTimeout(() => {
+				controller.abort();
+				reject(new Error("RPC genesis verification timed out"));
+			}, params.timeoutMs);
+		})]);
+	} finally {
+		if (timeout) {
+			clearTimeout(timeout);
+		}
+	}
+}
+/**
+* Infers the cluster without adding a network question to normal onboarding.
+* Opaque provider URLs are matched to live official cluster witnesses by genesis
+* hash; the public endpoints are never returned as execution fallbacks.
+*/
+async function discoverSolanaNetworkFromRpc(rpcUrl, options = {}) {
+	const parsed = parseRpcUrl(rpcUrl);
+	if (isLoopbackRpc(parsed)) {
+		return "local";
+	}
+	const official = officialNetworkFor(parsed);
+	if (official === "mainnet-beta" || official === "devnet") {
+		return official;
+	}
+	if (official === "testnet") {
+		throw new Error("Solana testnet is not supported for SAT Mining");
+	}
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const timeoutMs = Math.max(250, Math.min(options.timeoutMs ?? 8e3, 3e4));
+	const targets = [
+		rpcUrl.trim(),
+		OFFICIAL_SOLANA_RPC_URLS["mainnet-beta"],
+		OFFICIAL_SOLANA_RPC_URLS.devnet,
+		OFFICIAL_SOLANA_RPC_URLS.testnet
+	];
+	const results = await Promise.allSettled(targets.map((target) => fetchGenesisHash({
+		rpcUrl: target,
+		fetchImpl,
+		timeoutMs
+	})));
+	const primary = results[0];
+	if (primary.status !== "fulfilled") {
+		throw new Error("Unable to verify the Solana RPC cluster by genesis hash");
+	}
+	if (results[1]?.status === "fulfilled" && results[1].value === primary.value) {
+		return "mainnet-beta";
+	}
+	if (results[2]?.status === "fulfilled" && results[2].value === primary.value) {
+		return "devnet";
+	}
+	if (results[3]?.status === "fulfilled" && results[3].value === primary.value) {
+		throw new Error("Solana testnet is not supported for SAT Mining");
+	}
+	throw new Error("The Solana RPC cluster is unsupported or could not be independently verified");
+}
+
+//#endregion
+export { discoverSolanaNetworkFromRpc };

package/dist/wallet/turnkey-reviewed-state.js

@@ -3,7 +3,7 @@ import "../infra/file-lock.js";
 import { ensureWalletStateDir } from "./wallet-runtime-config.js";
 import { WalletProviderError } from "./wallet-provider-adapter.js";
 import { broadcastReviewedSolanaTransaction, buildReviewedSolanaTransaction, computeReviewedSolanaRequestDigest, reconcileReviewedSolanaTransaction, validateReviewedSolanaSignedTransaction } from "./solana-reviewed-transaction.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 
@@ -30,14 +30,14 @@ function statePath(env) {
 }
 function readFile(env) {
 	const filePath = statePath(env);
-	if (!syncFs.existsSync(filePath)) {
+	if (!fs.existsSync(filePath)) {
 		return {
 			version: 1,
 			reviews: []
 		};
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(filePath, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
 		if (parsed.version === 1 && Array.isArray(parsed.reviews)) {
 			return parsed;
 		}
@@ -53,29 +53,29 @@ function saveFile(file, env) {
 	const temporary = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
 	let descriptor;
 	try {
-		descriptor = syncFs.openSync(temporary, "wx", STATE_FILE_MODE);
-		syncFs.writeFileSync(descriptor, `${JSON.stringify(file, null, 2)}\n`, "utf8");
-		syncFs.fsyncSync(descriptor);
-		syncFs.closeSync(descriptor);
+		descriptor = fs.openSync(temporary, "wx", STATE_FILE_MODE);
+		fs.writeFileSync(descriptor, `${JSON.stringify(file, null, 2)}\n`, "utf8");
+		fs.fsyncSync(descriptor);
+		fs.closeSync(descriptor);
 		descriptor = undefined;
-		syncFs.renameSync(temporary, filePath);
+		fs.renameSync(temporary, filePath);
 		try {
-			syncFs.chmodSync(filePath, STATE_FILE_MODE);
+			fs.chmodSync(filePath, STATE_FILE_MODE);
 		} catch {}
 		try {
-			const directory = syncFs.openSync(path.dirname(filePath), "r");
+			const directory = fs.openSync(path.dirname(filePath), "r");
 			try {
-				syncFs.fsyncSync(directory);
+				fs.fsyncSync(directory);
 			} finally {
-				syncFs.closeSync(directory);
+				fs.closeSync(directory);
 			}
 		} catch {}
 	} catch (error) {
 		if (descriptor !== undefined) {
-			syncFs.closeSync(descriptor);
+			fs.closeSync(descriptor);
 		}
 		try {
-			syncFs.unlinkSync(temporary);
+			fs.unlinkSync(temporary);
 		} catch {}
 		throw error;
 	}

package/dist/wallet/wallet-approval-auth.js

@@ -1,6 +1,6 @@
 import { ensureWalletStateDir } from "./wallet-runtime-config.js";
 import { serializeWalletState, writeWalletStateFileAtomically } from "./wallet-atomic-state.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { createHash, createPublicKey, randomBytes, timingSafeEqual, verify } from "node:crypto";
 
@@ -163,7 +163,7 @@ function normalizeState(input) {
 }
 function loadState(env = process.env) {
 	const statePath = resolveStatePath(env);
-	if (!syncFs.existsSync(statePath)) {
+	if (!fs.existsSync(statePath)) {
 		return {
 			version: 2,
 			passkeys: [],
@@ -172,7 +172,7 @@ function loadState(env = process.env) {
 		};
 	}
 	try {
-		const raw = syncFs.readFileSync(statePath, "utf8");
+		const raw = fs.readFileSync(statePath, "utf8");
 		return normalizeState(JSON.parse(raw));
 	} catch (error) {
 		throw new Error("wallet approval auth state is unreadable; refusing to reset credentials", { cause: error });

package/dist/wallet/wallet-atomic-state.js

@@ -1,4 +1,4 @@
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
 
@@ -15,31 +15,31 @@ function writeWalletStateFileAtomically(filePath, contents) {
 	let descriptor;
 	let renamed = false;
 	try {
-		descriptor = syncFs.openSync(temporaryPath, "wx", WALLET_STATE_FILE_MODE);
-		syncFs.writeFileSync(descriptor, contents, { encoding: "utf8" });
-		syncFs.fsyncSync(descriptor);
-		syncFs.closeSync(descriptor);
+		descriptor = fs.openSync(temporaryPath, "wx", WALLET_STATE_FILE_MODE);
+		fs.writeFileSync(descriptor, contents, { encoding: "utf8" });
+		fs.fsyncSync(descriptor);
+		fs.closeSync(descriptor);
 		descriptor = undefined;
-		syncFs.renameSync(temporaryPath, filePath);
+		fs.renameSync(temporaryPath, filePath);
 		renamed = true;
 		try {
-			syncFs.chmodSync(filePath, WALLET_STATE_FILE_MODE);
+			fs.chmodSync(filePath, WALLET_STATE_FILE_MODE);
 		} catch {}
-		const directoryDescriptor = syncFs.openSync(directoryPath, "r");
+		const directoryDescriptor = fs.openSync(directoryPath, "r");
 		try {
-			syncFs.fsyncSync(directoryDescriptor);
+			fs.fsyncSync(directoryDescriptor);
 		} finally {
-			syncFs.closeSync(directoryDescriptor);
+			fs.closeSync(directoryDescriptor);
 		}
 	} catch (error) {
 		if (descriptor !== undefined) {
 			try {
-				syncFs.closeSync(descriptor);
+				fs.closeSync(descriptor);
 			} catch {}
 		}
 		if (!renamed) {
 			try {
-				syncFs.unlinkSync(temporaryPath);
+				fs.unlinkSync(temporaryPath);
 			} catch {}
 		}
 		throw error;

package/dist/wallet/wallet-audit-log.js

@@ -1,5 +1,5 @@
 import { ensureWalletStateDir } from "./wallet-runtime-config.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import { randomBytes } from "node:crypto";
 
 //#region src/wallet/wallet-audit-log.ts
@@ -15,22 +15,22 @@ function appendWalletAuditEntry(params) {
 		actor: params.actor?.trim() || "system",
 		details: params.details ?? {}
 	};
-	syncFs.appendFileSync(paths.auditLogPath, `${JSON.stringify(entry)}\n`, {
+	fs.appendFileSync(paths.auditLogPath, `${JSON.stringify(entry)}\n`, {
 		encoding: "utf8",
 		mode: 384
 	});
 	try {
-		syncFs.chmodSync(paths.auditLogPath, 384);
+		fs.chmodSync(paths.auditLogPath, 384);
 	} catch {}
 	return entry;
 }
 function readWalletAuditEntries(params) {
 	const paths = ensureWalletStateDir(params?.env ?? process.env);
-	if (!syncFs.existsSync(paths.auditLogPath)) {
+	if (!fs.existsSync(paths.auditLogPath)) {
 		return [];
 	}
 	const limit = Math.max(1, Math.min(500, params?.limit ?? 100));
-	const raw = syncFs.readFileSync(paths.auditLogPath, "utf8");
+	const raw = fs.readFileSync(paths.auditLogPath, "utf8");
 	const lines = raw.split("\n").map((line) => line.trim()).filter(Boolean);
 	const out = [];
 	for (let i = lines.length - 1; i >= 0; i -= 1) {

package/dist/wallet/wallet-inbound-events.js

@@ -5,7 +5,7 @@ import { buildWalletProviderCapabilityMatrix, providerSupportsChainOperation } f
 import { walletDiagnosticErrorString } from "./wallet-redaction.js";
 import { createWalletProviderAdapter, resolveWalletProviderId } from "./wallet-provider-resolver.js";
 import { appendWalletAuditEntry, readWalletAuditEntries } from "./wallet-audit-log.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 import { randomBytes } from "node:crypto";
 
@@ -185,11 +185,11 @@ function normalizeLedger(raw) {
 }
 function readLedger(env = process.env) {
 	const filePath = inboundLedgerPath(env);
-	if (!syncFs.existsSync(filePath)) {
+	if (!fs.existsSync(filePath)) {
 		return defaultLedger();
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(filePath, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
 		return normalizeLedger(parsed);
 	} catch (error) {
 		throw new Error("wallet inbound ledger is unreadable; refusing to reset event history", { cause: error });

package/dist/wallet/wallet-observability.js

@@ -1,5 +1,5 @@
 import { ensureWalletStateDir } from "./wallet-runtime-config.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 
 //#region src/wallet/wallet-observability.ts
 const OBSERVABILITY_FILENAME = "observability.v1.json";
@@ -37,11 +37,11 @@ function sanitizeBucket(input) {
 }
 function readSnapshot(env) {
 	const file = observabilityPath(env);
-	if (!syncFs.existsSync(file)) {
+	if (!fs.existsSync(file)) {
 		return makeDefaultSnapshot();
 	}
 	try {
-		const parsed = JSON.parse(syncFs.readFileSync(file, "utf8"));
+		const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
 		if (parsed?.version !== 1) {
 			return makeDefaultSnapshot();
 		}
@@ -60,12 +60,12 @@ function readSnapshot(env) {
 }
 function writeSnapshot(env, snapshot) {
 	const file = observabilityPath(env);
-	syncFs.writeFileSync(file, `${JSON.stringify(snapshot, null, 2)}\n`, {
+	fs.writeFileSync(file, `${JSON.stringify(snapshot, null, 2)}\n`, {
 		mode: 384,
 		encoding: "utf8"
 	});
 	try {
-		syncFs.chmodSync(file, 384);
+		fs.chmodSync(file, 384);
 	} catch {}
 }
 function incrementWalletObservabilityCounter(params) {

package/dist/wallet/wallet-policy.js

@@ -3,7 +3,7 @@ import { readWalletProviderRegistry, resolveWalletUserRole } from "./wallet-prov
 import { assertValidSolanaAddress } from "./solana-address.js";
 import { tryResolveSatRuntimeIds } from "../config/sat-runtime-ids.js";
 import { serializeWalletState, writeWalletStateFileAtomically } from "./wallet-atomic-state.js";
-import syncFs from "node:fs";
+import fs from "node:fs";
 import path from "node:path";
 
 //#region src/wallet/wallet-policy.ts
@@ -70,11 +70,11 @@ function isNonNegativeIntegerString(value) {
 }
 function loadLedger(paths) {
 	const fallback = defaultWalletUsageLedger();
-	if (!syncFs.existsSync(paths.dailyUsagePath)) {
+	if (!fs.existsSync(paths.dailyUsagePath)) {
 		return fallback;
 	}
 	try {
-		const raw = syncFs.readFileSync(paths.dailyUsagePath, "utf8");
+		const raw = fs.readFileSync(paths.dailyUsagePath, "utf8");
 		const parsed = JSON.parse(raw);
 		if (parsed && parsed.version === 2 && typeof parsed.date === "string") {
 			if (!parsed.wallets || typeof parsed.wallets !== "object" || Array.isArray(parsed.wallets)) {
@@ -372,11 +372,11 @@ function readWalletPolicyState(env = process.env) {
 		updatedAt: nowIso(),
 		wallets: {}
 	};
-	if (!syncFs.existsSync(statePath)) {
+	if (!fs.existsSync(statePath)) {
 		return fallback;
 	}
 	try {
-		const raw = syncFs.readFileSync(statePath, "utf8");
+		const raw = fs.readFileSync(statePath, "utf8");
 		const parsed = JSON.parse(raw);
 		if (parsed.version !== 1) {
 			throw new Error("wallet policy state version is unsupported");