@fased/fased 0.1.62 → 0.1.65

package/dist/extensions/sat-mining/src/rpc-read.js

@@ -1,4 +1,5 @@
 import { loadConfig } from "../../../config/io.js";
+import { fetchWithSsrFGuard } from "../../../infra/net/fetch-guard.js";
 import { redactSensitiveUrlLikeString } from "../../../shared/net/redact-sensitive-url.js";
 import { readWalletProviderRegistry } from "../../../wallet/wallet-provider-registry.js";
 import { resolveSatBondProgramIdFromEnv, resolveSatMintAddressFromEnv, resolveSatProgramIdFromEnv } from "../../../config/sat-runtime-ids.js";
@@ -6,6 +7,7 @@ import { loadWalletProviderSecret } from "../../../wallet/wallet-secrets-store.j
 import { resolveWalletProviderId } from "../../../wallet/wallet-provider-resolver.js";
 import "../../../plugin-sdk/index.js";
 import "../../../plugin-sdk/sat-runtime.js";
+import { SAT_PROTOCOL_CONSTANTS, resolveSatGenesisProfileContract } from "./protocol-contract.js";
 import { loadSatBondLayout, loadSatBondPolicyLayout, loadSatBondStakingDistributorLayout, loadSatBondStakingPositionLayout } from "./sat-bond-layout.js";
 import { createRequire } from "node:module";
 import { createHash } from "node:crypto";
@@ -23,6 +25,7 @@ const SAT_DISPUTE_SEED = "sat_dispute";
 const MINING_STAKE_SEED = "mining_stake";
 const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const ADDRESS_LOOKUP_TABLE_PROGRAM_ID = "AddressLookupTab1e1111111111111111111111111";
 function assertDedicatedBondProgramConfigured(env = process.env) {
 	const resolved = resolveSatBondProgramIdFromEnv(env);
 	if (!resolved.trim()) {
@@ -311,15 +314,19 @@ function decodeSatGlobalState(data, address) {
 }
 function decodeSatCycle(data, address) {
 	const body = expectAccountData(data, ACCOUNT_DISCRIMINATOR.satCycleState, "SAT cycle state");
+	const validMinerCount = readU64String(body, 192);
+	const cycleSeed = readHash32(body, 40);
 	return {
 		address,
 		cycleId: readU64Number(body, 0),
 		openTs: readI64Number(body, 8),
 		closeTs: readI64Number(body, 16),
 		status: body.readUInt8(24),
+		cycleSeed,
+		entropyUnavailable: cycleSeed === SAT_PROTOCOL_CONSTANTS.entropyUnavailableSeedHex,
 		unlockTargetLamports: readU64String(body, 176),
 		totalCommittedLamports: readU64String(body, 184),
-		validMinerCount: readU64String(body, 192),
+		validMinerCount,
 		unlockRatioFp: readU64String(body, 200),
 		issuedCycleMinerSatRaw: readU64String(body, 208),
 		unissuedCycleMinerSatRaw: readU64String(body, 216),
@@ -328,7 +335,22 @@ function decodeSatCycle(data, address) {
 		performanceRebatePoolLamports: readU64String(body, 240),
 		treasurySolLamports: readU64String(body, 248),
 		submittedSolErosionPoolLamports: readU64String(body, 256),
-		keeperBountyPaidLamports: readU64String(body, 264)
+		keeperBountyPaidLamports: readU64String(body, 264),
+		commitDeadlineTs: readI64Number(body, 272),
+		revealDeadlineTs: readI64Number(body, 280),
+		entropyTargetSlot: readU64Number(body, 288),
+		committedMinerCount: readU64String(body, 296),
+		revealedMinerCount: validMinerCount,
+		resolvedCommitCount: readU64String(body, 304),
+		entropySealedSlot: readU64Number(body, 312),
+		...body.length >= 368 ? {
+			openSlot: readU64Number(body, 320),
+			commitDeadlineSlot: readU64Number(body, 328),
+			revealDeadlineSlot: readU64Number(body, 336),
+			entropyHashCount: readU64Number(body, 344),
+			unlockIntervalStartCycleId: readU64Number(body, 352),
+			releasedCommitCount: readU64String(body, 360)
+		} : {}
 	};
 }
 function decodeSatMinerCycle(data, address) {
@@ -351,7 +373,13 @@ function decodeSatMinerCycle(data, address) {
 		claimedDetRebateLamports: readU64String(body, 160),
 		claimedPerfRebateLamports: readU64String(body, 168),
 		validParticipation: body.readUInt8(176) === 1,
-		capitalLockReleased: body.readUInt8(177) === 1
+		capitalLockReleased: body.readUInt8(177) === 1,
+		...body.length >= 336 ? {
+			commitment: readHash32(body, 184),
+			commitSlot: readU64Number(body, 216),
+			revealSlot: readU64Number(body, 224)
+		} : {},
+		...body.length >= 344 ? { lockedCollateralLamports: readU64String(body, 232) } : {}
 	};
 }
 function decodeSatMinerCapital(data, address) {
@@ -476,6 +504,8 @@ function decodeSatBondStakingDistributor(data, address) {
 		totalActiveStakeRaw: readU64String(body, layout.offsets.totalActiveStakeRaw),
 		rewardIndexFp: readU128String(body, layout.offsets.rewardIndexFp),
 		observedRewardVaultRaw: readU64String(body, layout.offsets.observedRewardVaultRaw),
+		unallocatedRewardRaw: readU64String(body, layout.offsets.unallocatedRewardRaw),
+		fractionalRemainderFp: readU64String(body, layout.offsets.fractionalRemainderFp),
 		lastSyncedSlot: readU64Number(body, layout.offsets.lastSyncedSlot),
 		mintMatchesRuntime: rewardMint === SAT_MINT_ADDRESS(),
 		vaultMatchesExpected: rewardVault === expectedRewardVault
@@ -497,6 +527,7 @@ function decodeSatBondStakingPosition(data, address) {
 		activeStakeRaw: readU64String(body, layout.offsets.activeStakeRaw),
 		claimableRewardRaw: readU64String(body, layout.offsets.claimableRewardRaw),
 		rewardDebtFp: readU128String(body, layout.offsets.rewardDebtFp),
+		fractionalRemainderFp: readU64String(body, layout.offsets.fractionalRemainderFp),
 		lastSyncedSlot: readU64Number(body, layout.offsets.lastSyncedSlot)
 	};
 }
@@ -548,7 +579,8 @@ function decodeSatCycleSettlementProgressV2(data, address) {
 		finalizeExclusiveUntilSlot: readU64Number(body, 984),
 		scoreExclusiveUntilSlot: readU64Number(body, 992),
 		distributeExclusiveUntilSlot: readU64Number(body, 1e3),
-		keeperBountyPaidLamports: readU64String(body, 1008)
+		keeperBountyPaidLamports: readU64String(body, 1008),
+		keeperBountyUnpaidLamports: readU64String(body, 1016)
 	};
 }
 function decodeSatTreasuryState(data, address) {
@@ -723,6 +755,7 @@ const satReadRpcRuntimeState = {
 	lastRpcUrl: null,
 	quotaLikely: false
 };
+const satReadRpcEndpointStates = new Map();
 function readPositiveIntEnv(name, fallback) {
 	const value = Number.parseInt(String(process.env[name] ?? ""), 10);
 	return Number.isFinite(value) && value > 0 ? value : fallback;
@@ -736,6 +769,13 @@ const SAT_RPC_RENT_EXEMPTION_CACHE_TTL_MS = 5 * 6e4;
 const SAT_RPC_METHOD_METRIC_BUCKET_MS = 60 * 6e4;
 const SAT_RPC_METHOD_METRIC_RETENTION_MS = 24 * 60 * 6e4;
 const SAT_RPC_QUOTA_BACKOFF_MS = 3e4;
+const SAT_RPC_FAILURE_BACKOFF_THRESHOLD = 2;
+const SAT_RPC_FAILURE_BACKOFF_BASE_MS = 5e3;
+const SAT_RPC_FAILURE_BACKOFF_MAX_MS = 3e4;
+const SAT_RPC_MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+function satRpcRequestTimeoutMs() {
+	return readPositiveIntEnv("FASED_SAT_RPC_REQUEST_TIMEOUT_MS", 1e4);
+}
 const satRpcReadCache = new Map();
 const satRpcReadInFlight = new Map();
 const satRpcMethodMetrics = new Map();
@@ -894,36 +934,75 @@ function looksLikeRpcQuotaFailure(value) {
 	}
 	return message.includes("429") || message.includes("rate limit") || message.includes("too many requests") || message.includes("quota") || message.includes("credit") || message.includes("credits exhausted") || message.includes("resource exhausted");
 }
-function currentReadRpcQuotaBackoffMs(nowMs = Date.now()) {
-	if (!satReadRpcRuntimeState.quotaLikely || !satReadRpcRuntimeState.lastFailureAt) {
-		return 0;
+function getOrCreateReadRpcEndpointState(rpcUrl) {
+	const key = normalizeRpcUrlForComparison(rpcUrl);
+	const existing = satReadRpcEndpointStates.get(key);
+	if (existing) {
+		return existing;
 	}
-	const failedAtMs = Date.parse(satReadRpcRuntimeState.lastFailureAt);
-	if (!Number.isFinite(failedAtMs)) {
+	const created = {
+		consecutiveFailures: 0,
+		backoffUntilMs: 0,
+		quotaLikely: false,
+		lastError: null,
+		lastFailureAt: null,
+		lastSuccessAt: null
+	};
+	satReadRpcEndpointStates.set(key, created);
+	return created;
+}
+function currentReadRpcBackoffMs(rpcUrl, nowMs = Date.now()) {
+	const state = satReadRpcEndpointStates.get(normalizeRpcUrlForComparison(rpcUrl));
+	if (!state) {
 		return 0;
 	}
-	const remainingMs = SAT_RPC_QUOTA_BACKOFF_MS - (nowMs - failedAtMs);
-	return remainingMs > 0 ? remainingMs : 0;
+	return Math.max(0, state.backoffUntilMs - nowMs);
+}
+function makeReadRpcBackoffError(method, remainingMs) {
+	return new Error(`rpc ${method} skipped during endpoint circuit backoff; retry in ${Math.ceil(remainingMs / 1e3)}s`);
 }
-function makeReadRpcQuotaBackoffError(method, remainingMs) {
-	return new Error(`rpc ${method} skipped during provider quota backoff; retry in ${Math.ceil(remainingMs / 1e3)}s`);
+function markReadRpcEndpointSuccess(rpcUrl) {
+	const state = getOrCreateReadRpcEndpointState(rpcUrl);
+	state.consecutiveFailures = 0;
+	state.backoffUntilMs = 0;
+	state.quotaLikely = false;
+	state.lastError = null;
+	state.lastSuccessAt = new Date().toISOString();
+}
+function markReadRpcEndpointFailure(rpcUrl, error) {
+	const state = getOrCreateReadRpcEndpointState(rpcUrl);
+	const message = error instanceof Error ? error.message : String(error);
+	const quotaLikely = looksLikeRpcQuotaFailure(message);
+	state.consecutiveFailures += 1;
+	state.quotaLikely = quotaLikely;
+	state.lastError = message;
+	state.lastFailureAt = new Date().toISOString();
+	if (quotaLikely) {
+		state.backoffUntilMs = Date.now() + SAT_RPC_QUOTA_BACKOFF_MS;
+	} else if (state.consecutiveFailures >= SAT_RPC_FAILURE_BACKOFF_THRESHOLD) {
+		const exponent = state.consecutiveFailures - SAT_RPC_FAILURE_BACKOFF_THRESHOLD;
+		state.backoffUntilMs = Date.now() + Math.min(SAT_RPC_FAILURE_BACKOFF_MAX_MS, SAT_RPC_FAILURE_BACKOFF_BASE_MS * 2 ** exponent);
+	}
 }
 function markReadRpcSuccess(mode, rpcUrl) {
+	markReadRpcEndpointSuccess(rpcUrl);
 	satReadRpcRuntimeState.lastMode = mode;
 	satReadRpcRuntimeState.lastRpcUrl = rpcUrl;
-	satReadRpcRuntimeState.lastError = null;
 	satReadRpcRuntimeState.lastSuccessAt = new Date().toISOString();
-	satReadRpcRuntimeState.quotaLikely = false;
-	if (mode === "fallback") {
+	if (mode === "primary") {
+		satReadRpcRuntimeState.lastError = null;
+		satReadRpcRuntimeState.quotaLikely = false;
+	} else {
 		satReadRpcRuntimeState.fallbackCount += 1;
 	}
 }
-function markReadRpcFailure(error) {
+function markReadRpcFailure(error, rpcUrl) {
 	const message = error instanceof Error ? error.message : String(error);
+	markReadRpcEndpointFailure(rpcUrl, error);
 	satReadRpcRuntimeState.lastMode = "unavailable";
 	satReadRpcRuntimeState.lastError = message;
 	satReadRpcRuntimeState.lastFailureAt = new Date().toISOString();
-	satReadRpcRuntimeState.quotaLikely = looksLikeRpcQuotaFailure(message);
+	satReadRpcRuntimeState.quotaLikely = satReadRpcRuntimeState.quotaLikely || looksLikeRpcQuotaFailure(message);
 }
 function firstNonEmpty(...values) {
 	for (const value of values) {
@@ -1044,9 +1123,9 @@ function resolveReadRpcConfig(cfg, env) {
 	const walletId = typeof satMiningConfig.walletId === "string" ? String(satMiningConfig.walletId).trim() : undefined;
 	const registryProviderId = walletId ? readWalletProviderRegistry(env).wallets.find((wallet) => wallet.id === walletId)?.providerId : undefined;
 	const providerId = registryProviderId || resolveWalletProviderId(cfg, env);
-	const walletReadRpcUrl = walletEnvValue(env, "FASED_WALLET_SOLANA_READ_RPC_URL", walletId) || walletEnvValue(env, "FASED_WALLET_EMBEDDED_KEYSTORE_READ_RPC_URL", walletId);
-	const walletRpcUrl = walletEnvValue(env, "FASED_WALLET_SOLANA_RPC_URL", walletId) || walletEnvValue(env, "FASED_WALLET_EMBEDDED_KEYSTORE_RPC_URL", walletId);
-	const walletReadRpcFallbackUrl = walletEnvValue(env, "FASED_WALLET_SOLANA_READ_RPC_FALLBACK_URL", walletId) || walletEnvValue(env, "FASED_WALLET_SOLANA_RPC_FALLBACK_URL", walletId) || walletEnvValue(env, "FASED_WALLET_EMBEDDED_KEYSTORE_READ_RPC_FALLBACK_URL", walletId) || walletEnvValue(env, "FASED_WALLET_EMBEDDED_KEYSTORE_RPC_FALLBACK_URL", walletId);
+	const walletReadRpcUrl = walletEnvValue(env, "FASED_WALLET_SOLANA_READ_RPC_URL", walletId);
+	const walletRpcUrl = walletEnvValue(env, "FASED_WALLET_SOLANA_RPC_URL", walletId);
+	const walletReadRpcFallbackUrl = walletEnvValue(env, "FASED_WALLET_SOLANA_READ_RPC_FALLBACK_URL", walletId) || walletEnvValue(env, "FASED_WALLET_SOLANA_RPC_FALLBACK_URL", walletId);
 	if (providerId === "local-socket-signer") {
 		const primaryUrl = firstNonEmpty(walletReadRpcUrl, walletRpcUrl);
 		if (!primaryUrl) {
@@ -1101,50 +1180,98 @@ function resolveEffectiveReadRpcConfig() {
 	};
 	return resolveReadRpcConfig(cfg, mergedEnv);
 }
+function createAbortableReadRpcFetch() {
+	return (async (input, init) => {
+		const timeoutMs = satRpcRequestTimeoutMs();
+		const requestUrl = typeof input === "string" || input instanceof URL ? input.toString() : input.url;
+		let guardedFetch;
+		try {
+			guardedFetch = await fetchWithSsrFGuard({
+				url: requestUrl,
+				init,
+				timeoutMs,
+				signal: init?.signal ?? (input instanceof Request ? input.signal : undefined),
+				policy: { allowPrivateNetwork: true },
+				auditContext: "sat-mining-read-rpc"
+			});
+		} catch (error) {
+			const reason = redactSensitiveUrlLikeString(error instanceof Error ? `${error.name}: ${error.message}` : String(error));
+			throw new Error(`rpc fetch failed after at most ${timeoutMs}ms (${redactSensitiveUrlLikeString(requestUrl)}): ${reason}`);
+		}
+		const { response, release } = guardedFetch;
+		try {
+			const body = await response.arrayBuffer();
+			return new Response(body, {
+				headers: response.headers,
+				status: response.status,
+				statusText: response.statusText
+			});
+		} finally {
+			await release();
+		}
+	});
+}
+async function withReadRpcTimeout(task, method, rpcUrl) {
+	const timeoutMs = satRpcRequestTimeoutMs();
+	let timer;
+	try {
+		return await Promise.race([task, new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(new Error(`rpc ${method} timed out after ${timeoutMs}ms (${redactSensitiveUrlLikeString(rpcUrl)})`)), timeoutMs);
+			timer.unref?.();
+		})]);
+	} finally {
+		if (timer) {
+			clearTimeout(timer);
+		}
+	}
+}
 function createReadConnection(solana, rpc) {
-	const primary = new solana.Connection(rpc.primaryUrl);
-	const secondary = rpc.secondaryUrl ? new solana.Connection(rpc.secondaryUrl) : null;
+	const primary = new solana.Connection(rpc.primaryUrl, {
+		disableRetryOnRateLimit: true,
+		fetch: createAbortableReadRpcFetch()
+	});
+	const secondary = rpc.secondaryUrl ? new solana.Connection(rpc.secondaryUrl, {
+		disableRetryOnRateLimit: true,
+		fetch: createAbortableReadRpcFetch()
+	}) : null;
 	const withFallback = (method) => {
 		return (async (...args) => {
-			const quotaBackoffMs = currentReadRpcQuotaBackoffMs();
-			if (quotaBackoffMs > 0) {
-				if (!secondary) {
-					throw makeReadRpcQuotaBackoffError(method, quotaBackoffMs);
-				}
+			const primaryBackoffMs = currentReadRpcBackoffMs(rpc.primaryUrl);
+			const secondaryBackoffMs = rpc.secondaryUrl ? currentReadRpcBackoffMs(rpc.secondaryUrl) : 0;
+			const callEndpoint = async (connection, mode, rpcUrl) => {
+				updateSatRpcMethodMetric(method, "request");
 				try {
-					updateSatRpcMethodMetric(method, "request");
-					const result = await secondary[method](...args);
+					const task = connection[method](...args);
+					const result = await withReadRpcTimeout(task, method, rpcUrl);
 					updateSatRpcMethodMetric(method, "success");
-					markReadRpcSuccess("fallback", rpc.secondaryUrl ?? rpc.primaryUrl);
+					markReadRpcSuccess(mode, rpcUrl);
 					return result;
-				} catch (secondaryError) {
+				} catch (error) {
 					updateSatRpcMethodMetric(method, "failure");
-					markReadRpcFailure(secondaryError);
-					throw secondaryError;
+					markReadRpcFailure(error, rpcUrl);
+					throw error;
 				}
+			};
+			if (primaryBackoffMs > 0) {
+				if (!secondary || !rpc.secondaryUrl || secondaryBackoffMs > 0) {
+					throw makeReadRpcBackoffError(method, Math.min(primaryBackoffMs, secondaryBackoffMs > 0 ? secondaryBackoffMs : primaryBackoffMs));
+				}
+				return await callEndpoint(secondary, "fallback", rpc.secondaryUrl);
 			}
 			try {
-				updateSatRpcMethodMetric(method, "request");
-				const result = await primary[method](...args);
-				updateSatRpcMethodMetric(method, "success");
-				markReadRpcSuccess("primary", rpc.primaryUrl);
-				return result;
+				return await callEndpoint(primary, "primary", rpc.primaryUrl);
 			} catch (primaryError) {
-				updateSatRpcMethodMetric(method, "failure");
-				if (!secondary) {
-					markReadRpcFailure(primaryError);
+				if (!secondary || !rpc.secondaryUrl) {
 					throw primaryError;
 				}
+				const fallbackBackoffMs = currentReadRpcBackoffMs(rpc.secondaryUrl);
+				if (fallbackBackoffMs > 0) {
+					throw makeReadRpcBackoffError(method, fallbackBackoffMs);
+				}
 				try {
-					updateSatRpcMethodMetric(method, "request");
-					const result = await secondary[method](...args);
-					updateSatRpcMethodMetric(method, "success");
-					markReadRpcSuccess("fallback", rpc.secondaryUrl ?? rpc.primaryUrl);
-					return result;
+					return await callEndpoint(secondary, "fallback", rpc.secondaryUrl);
 				} catch (secondaryError) {
-					updateSatRpcMethodMetric(method, "failure");
-					markReadRpcFailure(new Error(`${String(primaryError instanceof Error ? primaryError.message : primaryError)}; ${String(secondaryError instanceof Error ? secondaryError.message : secondaryError)}`));
-					throw secondaryError;
+					throw new Error(`rpc ${method} failed on primary (${String(redactSensitiveUrlLikeString(primaryError instanceof Error ? primaryError.message : String(primaryError)))}) and fallback (${String(redactSensitiveUrlLikeString(secondaryError instanceof Error ? secondaryError.message : String(secondaryError)))})`);
 				}
 			}
 		});
@@ -1187,13 +1314,18 @@ async function resolveBondProgramContext(env) {
 		programId: new solana.PublicKey(SAT_BOND_PROGRAM_ID())
 	};
 }
-const SAT_REGISTRY_RESERVE_TARGET_LAMPORTS = 2e8;
-const SAT_PROTOCOL_VAULT_ACCOUNT_SPACE = 0;
-const SAT_CYCLE_STATE_ACCOUNT_SPACE = 336;
-const SAT_CYCLE_REGISTRY_META_ACCOUNT_SPACE = 88;
-const SAT_CYCLE_REGISTRY_PAGE_ACCOUNT_SPACE = 2072;
-const SAT_CYCLE_SETTLEMENT_PROGRESS_V2_ACCOUNT_SPACE = 1048;
-const SAT_MINER_CYCLE_ACCOUNT_SPACE = 296;
+const SAT_RENT_ACCOUNT_SPACES = {
+	protocolVault: 0,
+	cycleState: 376,
+	cycleRegistryMeta: 88,
+	cycleRegistryPage: 2072,
+	cycleSettlementProgressV2: 1048,
+	minerCycle: 352,
+	unlockInterval: 80
+};
+function calculateSatRevealSharedRentLamports(params) {
+	return params.cycleSettlementProgressLamports + params.cycleRegistryPageLamports + params.unlockIntervalLamports;
+}
 function normalizeReadRpcConfig(rpc) {
 	return typeof rpc === "string" ? {
 		primaryUrl: rpc,
@@ -1212,6 +1344,14 @@ async function rpcRequestOnce(rpcUrl, method, params) {
 		const target = new URL(rpcUrl);
 		const transport = target.protocol === "https:" ? https : http;
 		const payload = await new Promise((resolve, reject) => {
+			let settled = false;
+			const finishReject = (error) => {
+				if (settled) {
+					return;
+				}
+				settled = true;
+				reject(error);
+			};
 			const req = transport.request(target, {
 				method: "POST",
 				headers: {
@@ -1220,17 +1360,33 @@ async function rpcRequestOnce(rpcUrl, method, params) {
 				}
 			}, (res) => {
 				const chunks = [];
-				res.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+				let responseBytes = 0;
+				res.on("data", (chunk) => {
+					const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+					responseBytes += buffer.length;
+					if (responseBytes > SAT_RPC_MAX_RESPONSE_BYTES) {
+						req.destroy(new Error(`rpc ${method} response exceeded size limit`));
+						return;
+					}
+					chunks.push(buffer);
+				});
 				res.on("end", () => {
+					if (settled) {
+						return;
+					}
 					const text = Buffer.concat(chunks).toString("utf8");
 					if ((res.statusCode ?? 500) >= 400) {
-						reject(new Error(text || `rpc ${method} failed`));
+						finishReject(new Error(text || `rpc ${method} failed`));
 						return;
 					}
+					settled = true;
 					resolve(text);
 				});
 			});
-			req.on("error", reject);
+			req.setTimeout(satRpcRequestTimeoutMs(), () => {
+				req.destroy(new Error(`rpc ${method} timed out after ${satRpcRequestTimeoutMs()}ms (${redactSensitiveUrlLikeString(rpcUrl)})`));
+			});
+			req.on("error", (error) => finishReject(error));
 			req.write(body);
 			req.end();
 		});
@@ -1247,29 +1403,35 @@ async function rpcRequestOnce(rpcUrl, method, params) {
 }
 async function rpcRequest(rpc, method, params) {
 	const normalized = normalizeReadRpcConfig(rpc);
-	const quotaBackoffMs = currentReadRpcQuotaBackoffMs();
-	if (quotaBackoffMs > 0 && !normalized.secondaryUrl) {
-		throw makeReadRpcQuotaBackoffError(method, quotaBackoffMs);
+	const primaryBackoffMs = currentReadRpcBackoffMs(normalized.primaryUrl);
+	const secondaryBackoffMs = normalized.secondaryUrl ? currentReadRpcBackoffMs(normalized.secondaryUrl) : 0;
+	if (primaryBackoffMs > 0 && (!normalized.secondaryUrl || secondaryBackoffMs > 0)) {
+		throw makeReadRpcBackoffError(method, Math.min(primaryBackoffMs, secondaryBackoffMs > 0 ? secondaryBackoffMs : primaryBackoffMs));
 	}
-	const useFallbackDueToQuota = quotaBackoffMs > 0 && Boolean(normalized.secondaryUrl);
+	const useFallbackDueToBackoff = primaryBackoffMs > 0 && Boolean(normalized.secondaryUrl);
 	try {
-		const rpcUrl = useFallbackDueToQuota && normalized.secondaryUrl ? normalized.secondaryUrl : normalized.primaryUrl;
+		const rpcUrl = useFallbackDueToBackoff && normalized.secondaryUrl ? normalized.secondaryUrl : normalized.primaryUrl;
 		const result = await rpcRequestOnce(rpcUrl, method, params);
-		markReadRpcSuccess(useFallbackDueToQuota && normalized.secondaryUrl ? "fallback" : "primary", rpcUrl);
+		markReadRpcSuccess(useFallbackDueToBackoff && normalized.secondaryUrl ? "fallback" : "primary", rpcUrl);
 		return result;
 	} catch (primaryError) {
-		if (!normalized.secondaryUrl || useFallbackDueToQuota) {
-			markReadRpcFailure(primaryError);
+		const failedRpcUrl = useFallbackDueToBackoff && normalized.secondaryUrl ? normalized.secondaryUrl : normalized.primaryUrl;
+		markReadRpcFailure(primaryError, failedRpcUrl);
+		if (!normalized.secondaryUrl || useFallbackDueToBackoff) {
 			throw primaryError;
 		}
+		const fallbackBackoffMs = currentReadRpcBackoffMs(normalized.secondaryUrl);
+		if (fallbackBackoffMs > 0) {
+			throw makeReadRpcBackoffError(method, fallbackBackoffMs);
+		}
 		try {
 			const result = await rpcRequestOnce(normalized.secondaryUrl, method, params);
 			markReadRpcSuccess("fallback", normalized.secondaryUrl);
 			return result;
 		} catch (secondaryError) {
-			const primaryMessage = primaryError instanceof Error ? primaryError.message : String(primaryError);
-			const secondaryMessage = secondaryError instanceof Error ? secondaryError.message : String(secondaryError);
-			markReadRpcFailure(new Error(`rpc ${method} failed on primary (${primaryMessage}) and fallback (${secondaryMessage})`));
+			markReadRpcFailure(secondaryError, normalized.secondaryUrl);
+			const primaryMessage = redactSensitiveUrlLikeString(primaryError instanceof Error ? primaryError.message : String(primaryError));
+			const secondaryMessage = redactSensitiveUrlLikeString(secondaryError instanceof Error ? secondaryError.message : String(secondaryError));
 			throw new Error(`rpc ${method} failed on primary (${primaryMessage}) and fallback (${secondaryMessage})`);
 		}
 	}
@@ -1415,6 +1577,25 @@ async function inspectSatChainSlot(_config) {
 	const rpc = resolveEffectiveReadRpcConfig();
 	return await rpcRequest(rpc, "getSlot", []);
 }
+async function inspectSatAddressLookupTable(_config, params) {
+	const { solana, connection } = await resolveConnection(process.env);
+	const address = new solana.PublicKey(params.address);
+	const account = await connection.getAccountInfo(address, "confirmed");
+	if (!account) {
+		return null;
+	}
+	if (!account.owner.equals(new solana.PublicKey(ADDRESS_LOOKUP_TABLE_PROGRAM_ID))) {
+		throw new Error("SAT distribution lookup table has the wrong program owner");
+	}
+	const state = solana.AddressLookupTableAccount.deserialize(account.data);
+	return {
+		address: address.toBase58(),
+		authority: state.authority?.toBase58() ?? null,
+		addresses: state.addresses.map((entry) => entry.toBase58()),
+		active: state.deactivationSlot === 18446744073709551615n,
+		lastExtendedSlot: state.lastExtendedSlot
+	};
+}
 async function inspectSatLamportBalance(_config, params) {
 	const rpc = resolveEffectiveReadRpcConfig();
 	return await fetchLamportBalanceRaw(rpc, params.address);
@@ -1574,6 +1755,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	const mint = new solana.PublicKey(SAT_MINT_ADDRESS());
 	const [globalAddress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_global_state")], programId);
 	const [currentCycleAddress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_cycle_state"), encodeU64(currentCycleId)], programId);
+	const [currentSettlementProgressAddress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_cycle_settlement_progress_v2"), encodeU64(currentCycleId)], programId);
 	const [treasuryStateAddress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_treasury_state")], programId);
 	const [treasury] = solana.PublicKey.findProgramAddressSync([Buffer.from("treasury")], programId);
 	const currentMinerCycleAddress = owner ? solana.PublicKey.findProgramAddressSync([
@@ -1591,6 +1773,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	const treasuryAta = deriveAssociatedTokenAddress(solana, treasury, mint);
 	const coreEntries = [
 		["currentCycle", currentCycleAddress],
+		["currentSettlementProgress", currentSettlementProgressAddress],
 		["currentMinerCycle", currentMinerCycleAddress],
 		["claimMinerCycle", claimMinerCycleAddress],
 		["minerCapital", minerCapitalAddress],
@@ -1614,6 +1797,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	const recordFor = (address) => address ? byAddress.get(address.toBase58()) ?? null : null;
 	const globalRecord = recordFor(globalAddress);
 	const currentCycleRecord = recordFor(currentCycleAddress);
+	const currentSettlementProgressRecord = recordFor(currentSettlementProgressAddress);
 	const currentMinerCycleRecord = recordFor(currentMinerCycleAddress);
 	const claimMinerCycleRecord = recordFor(claimMinerCycleAddress);
 	const minerCapitalRecord = recordFor(minerCapitalAddress);
@@ -1622,6 +1806,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	const treasuryAtaRecord = recordFor(treasuryAta);
 	const globalState = globalRecord?.data ? decodeSatGlobalState(globalRecord.data, globalAddress.toBase58()) : null;
 	const currentCycle = currentCycleRecord?.data ? decodeSatCycle(currentCycleRecord.data, currentCycleAddress.toBase58()) : null;
+	const currentSettlementProgress = currentSettlementProgressRecord?.data ? decodeSatCycleSettlementProgressV2(currentSettlementProgressRecord.data, currentSettlementProgressAddress.toBase58()) : null;
 	const currentMinerCycle = currentMinerCycleRecord?.data ? decodeSatMinerCycle(currentMinerCycleRecord.data, currentMinerCycleAddress?.toBase58() ?? "") : null;
 	const claimMinerCycle = claimMinerCycleRecord?.data ? decodeSatMinerCycle(claimMinerCycleRecord.data, claimMinerCycleAddress?.toBase58() ?? "") : null;
 	const minerCapital = minerCapitalRecord?.data ? decodeSatMinerCapital(minerCapitalRecord.data, minerCapitalAddress?.toBase58() ?? "") : null;
@@ -1637,6 +1822,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	} : null;
 	writeRpcCacheValue(`view:global-state:${rpcCacheScope(rpc)}:${globalAddress.toBase58()}`, SAT_RPC_STABLE_VIEW_CACHE_TTL_MS, globalState);
 	writeRpcCacheValue(`view:cycle:${rpcCacheScope(rpc)}:${currentCycleId}`, SAT_RPC_LIVE_VIEW_CACHE_TTL_MS, currentCycle);
+	writeRpcCacheValue(`view:settlement-progress:${rpcCacheScope(rpc)}:${currentCycleId}`, SAT_RPC_LIVE_VIEW_CACHE_TTL_MS, currentSettlementProgress);
 	if (owner && currentMinerCycleAddress) {
 		writeRpcCacheValue(`view:miner-cycle:${rpcCacheScope(rpc)}:${authority}:${currentCycleId}`, SAT_RPC_LIVE_VIEW_CACHE_TTL_MS, currentMinerCycle);
 	}
@@ -1653,6 +1839,7 @@ async function inspectSatMiningStatusAccounts(_config, params) {
 	return {
 		globalState,
 		currentCycle,
+		currentSettlementProgress,
 		currentMinerCycle,
 		claimMinerCycle,
 		minerCapital,
@@ -2013,28 +2200,35 @@ async function inspectSatTreasuryVaultLamports(_config) {
 		lamports: await fetchLamportBalanceRaw(rpc, address.toBase58())
 	};
 }
-async function inspectSatRentExemptionLamports(_config) {
+async function inspectSatRentExemptionLamports(config) {
 	const { connection } = await resolveConnection(process.env);
 	const rpc = resolveEffectiveReadRpcConfig();
-	return await getOrLoadRpcCacheValue(`view:rent-exemption:${rpcCacheScope(rpc)}`, SAT_RPC_RENT_EXEMPTION_CACHE_TTL_MS, async () => {
-		const [protocolVaultLamports, cycleStateLamports, cycleRegistryMetaLamports, cycleRegistryPageLamports, cycleSettlementProgressLamports, minerCycleLamports] = await Promise.all([
-			connection.getMinimumBalanceForRentExemption(SAT_PROTOCOL_VAULT_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_CYCLE_STATE_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_CYCLE_REGISTRY_META_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_CYCLE_REGISTRY_PAGE_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_CYCLE_SETTLEMENT_PROGRESS_V2_ACCOUNT_SPACE),
-			connection.getMinimumBalanceForRentExemption(SAT_MINER_CYCLE_ACCOUNT_SPACE)
+	const registryReserveTargetLamports = resolveSatGenesisProfileContract(config.network).registryReserveTargetLamports;
+	return await getOrLoadRpcCacheValue(`view:rent-exemption:${rpcCacheScope(rpc)}:${registryReserveTargetLamports}`, SAT_RPC_RENT_EXEMPTION_CACHE_TTL_MS, async () => {
+		const [protocolVaultLamports, cycleStateLamports, cycleRegistryMetaLamports, cycleRegistryPageLamports, cycleSettlementProgressLamports, minerCycleLamports, unlockIntervalLamports] = await Promise.all([
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.protocolVault),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.cycleState),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.cycleRegistryMeta),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.cycleRegistryPage),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.cycleSettlementProgressV2),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.minerCycle),
+			connection.getMinimumBalanceForRentExemption(SAT_RENT_ACCOUNT_SPACES.unlockInterval)
 		]);
 		const openCycleLamports = cycleStateLamports + cycleRegistryMetaLamports;
-		const submitCycleSharedLamports = cycleSettlementProgressLamports + cycleRegistryPageLamports;
+		const submitCycleSharedLamports = calculateSatRevealSharedRentLamports({
+			cycleSettlementProgressLamports,
+			cycleRegistryPageLamports,
+			unlockIntervalLamports
+		});
 		return {
-			registryReserveTargetLamports: String(SAT_REGISTRY_RESERVE_TARGET_LAMPORTS),
+			registryReserveTargetLamports: String(registryReserveTargetLamports),
 			protocolVaultLamports: String(protocolVaultLamports),
 			cycleStateLamports: String(cycleStateLamports),
 			cycleRegistryMetaLamports: String(cycleRegistryMetaLamports),
 			cycleRegistryPageLamports: String(cycleRegistryPageLamports),
 			cycleSettlementProgressLamports: String(cycleSettlementProgressLamports),
 			minerCycleLamports: String(minerCycleLamports),
+			unlockIntervalLamports: String(unlockIntervalLamports),
 			openCycleLamports: String(openCycleLamports),
 			submitCycleSharedLamports: String(submitCycleSharedLamports),
 			submitCycleSignerLamports: String(minerCycleLamports)
@@ -2158,6 +2352,18 @@ async function inspectSatRoundState(_config, params) {
 }
 function inspectSatConnectionDetails() {
 	const rpc = resolveEffectiveReadRpcConfig();
+	const endpointStates = [rpc.primaryUrl, rpc.secondaryUrl].filter((rpcUrl) => Boolean(rpcUrl)).map((rpcUrl) => {
+		const state = satReadRpcEndpointStates.get(normalizeRpcUrlForComparison(rpcUrl));
+		return {
+			rpcUrl: redactSensitiveUrlLikeString(rpcUrl),
+			consecutiveFailures: state?.consecutiveFailures ?? 0,
+			backoffRemainingMs: currentReadRpcBackoffMs(rpcUrl),
+			quotaLikely: state?.quotaLikely ?? false,
+			lastError: state?.lastError ? redactSensitiveUrlLikeString(state.lastError) : null,
+			lastFailureAt: state?.lastFailureAt ?? null,
+			lastSuccessAt: state?.lastSuccessAt ?? null
+		};
+	});
 	return {
 		programId: SAT_PROGRAM_ID(),
 		bondProgramId: SAT_BOND_PROGRAM_ID(),
@@ -2167,7 +2373,8 @@ function inspectSatConnectionDetails() {
 			...satReadRpcRuntimeState,
 			lastError: satReadRpcRuntimeState.lastError ? redactSensitiveUrlLikeString(satReadRpcRuntimeState.lastError) : null,
 			lastRpcUrl: satReadRpcRuntimeState.lastRpcUrl ? redactSensitiveUrlLikeString(satReadRpcRuntimeState.lastRpcUrl) : null,
-			quotaLikely: satReadRpcRuntimeState.quotaLikely || looksLikeRpcQuotaFailure(satReadRpcRuntimeState.lastError)
+			quotaLikely: satReadRpcRuntimeState.quotaLikely || looksLikeRpcQuotaFailure(satReadRpcRuntimeState.lastError),
+			endpoints: endpointStates
 		},
 		rpcMetrics: summarizeSatRpcMethodMetrics()
 	};
@@ -2286,4 +2493,4 @@ function sortableValue(row, sortBy) {
 }
 
 //#endregion
-export { inspectSatBondPosition, inspectSatBondStakingDistributor, inspectSatBondStakingPosition, inspectSatBondTierPolicy, inspectSatChainSlot, inspectSatCycleRegistryMeta, inspectSatMinerCyclesByAddress, invalidateSatReadCaches };
+export { inspectSatAddressLookupTable, inspectSatBondPosition, inspectSatBondStakingDistributor, inspectSatBondStakingPosition, inspectSatChainSlot, inspectSatCycle, inspectSatCycleRegistryMeta, inspectSatMinerCyclesByAddress, invalidateSatReadCaches };

package/dist/extensions/sat-mining/src/sat-bond-layout.js

@@ -122,7 +122,9 @@ const DEDICATED_FALLBACK_STAKING_DISTRIBUTOR_LAYOUT = {
 		totalActiveStakeRaw: 120,
 		rewardIndexFp: 128,
 		observedRewardVaultRaw: 144,
-		lastSyncedSlot: 152
+		lastSyncedSlot: 152,
+		unallocatedRewardRaw: 160,
+		fractionalRemainderFp: 168
 	}
 };
 const DEDICATED_FALLBACK_STAKING_POSITION_LAYOUT = {
@@ -142,7 +144,8 @@ const DEDICATED_FALLBACK_STAKING_POSITION_LAYOUT = {
 		activeStakeRaw: 80,
 		claimableRewardRaw: 88,
 		rewardDebtFp: 96,
-		lastSyncedSlot: 112
+		lastSyncedSlot: 112,
+		fractionalRemainderFp: 120
 	}
 };
 function hasDedicatedBondProgram(env = process.env) {