@fased/fased 0.1.62 → 0.1.65

package/dist/extensions/sat-mining/src/solana-submit.js

@@ -1,15 +1,20 @@
 import { loadConfig } from "../../../config/io.js";
-import { resolveWalletRuntimeConfig } from "../../../wallet/wallet-runtime-config.js";
+import { LEGACY_EMBEDDED_KEYSTORE_MIGRATION_MESSAGE } from "../../../wallet/legacy-embedded-keystore.js";
 import { readWalletProviderRegistry } from "../../../wallet/wallet-provider-registry.js";
 import { resolveSatBondProgramIdFromEnv, resolveSatMintAddressFromEnv, resolveSatMintProgramIdFromEnv, resolveSatProgramIdFromEnv } from "../../../config/sat-runtime-ids.js";
 import { callLocalSocketSigner, requireLocalSocketSignerPath } from "../../../wallet/providers/local-socket-signer-adapter.js";
 import { resolveWalletProviderId } from "../../../wallet/wallet-provider-resolver.js";
-import { enforceWalletCustodyForAutonomousSend } from "../../../wallet/wallet-custody.js";
+import { createSignerReviewApprovalRequest } from "../../../wallet/wallet-send-approvals.js";
 import "../../../plugin-sdk/sat-runtime.js";
-import { inspectSatCycleRegistryMeta, inspectSatMinerCyclesByAddress } from "./rpc-read.js";
+import { SAT_BOND_INSTRUCTION_DISCRIMINATORS, SAT_INSTRUCTION_DISCRIMINATORS, SAT_PROTOCOL_CONSTANTS, resolveSatGenesisProfileContract } from "./protocol-contract.js";
+import { inspectSatAddressLookupTable, inspectSatChainSlot, inspectSatCycle, inspectSatCycleRegistryMeta, inspectSatMinerCyclesByAddress } from "./rpc-read.js";
 import { decodeHash32 } from "./hash-spec.js";
-import { SAT_BOND_INSTRUCTION_DISCRIMINATORS, SAT_INSTRUCTION_DISCRIMINATORS } from "./protocol-contract.js";
+import { resolveSatSignerCodec } from "./signer-codec-manifest.js";
+import { buildSatSubmissionOperationKey, claimSatSubmission, digestSatSubmissionIntent, updateSatSubmission, waitForSatSubmissionLease } from "./submission-ledger.js";
 import { createRequire } from "node:module";
+import { isDeepStrictEqual } from "node:util";
+import { createHash } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region extensions/sat-mining/src/solana-submit.ts
 const require = createRequire(import.meta.url);
@@ -37,13 +42,37 @@ const SAT_TREASURY_STATE_SEED = "sat_treasury_state";
 const SAT_REGISTRY_RESERVE_SEED = "sat_registry_reserve";
 const SAT_REBATE_VAULT_SEED = "sat_rebate_vault";
 const SAT_TREASURY_VAULT_SEED = "sat_treasury_vault";
+const SAT_UNLOCK_INTERVAL_STATE_SEED = "sat_unlock_interval_state";
 const SAT_CYCLE_REGISTRY_PAGE_CAPACITY = 64;
 const MINING_POOL_SEED = "mining_pool";
 const MINING_STAKE_SEED = "mining_stake";
 const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const SLOT_HASHES_SYSVAR_ID = "SysvarS1otHashes111111111111111111111111111";
+const SAT_DISTRIBUTION_LOOKUP_MIN_MINERS = 16;
+const SAT_LOOKUP_TABLE_EXTEND_CHUNK_SIZE = 20;
 const IX = SAT_INSTRUCTION_DISCRIMINATORS;
 const BOND_IX = SAT_BOND_INSTRUCTION_DISCRIMINATORS;
+const VAULT_BOND_ACTIONS = new Set([
+	"updateBondTierPolicy",
+	"openBondPosition",
+	"increaseBondPosition",
+	"requestBondUnlock",
+	"cancelBondUnlock",
+	"finalizeBondUnlock",
+	"syncBondStakingRewards",
+	"syncBondStakingPosition",
+	"claimBondStakingRewards",
+	"claimUnallocatedStakingRewards"
+]);
+const satSubmissionWorkflowStorage = new AsyncLocalStorage();
+async function runWithSatSubmissionWorkflow(workflowId, task) {
+	const normalized = workflowId.trim();
+	if (!normalized || normalized.length > 240 || /[\u0000-\u001f\u007f]/u.test(normalized)) {
+		throw new Error("SAT submission idempotency key must contain 1-240 printable characters");
+	}
+	return await satSubmissionWorkflowStorage.run(normalized, task);
+}
 function satSubmitDebug(message) {
 	if (String(process.env.FASED_SAT_SUBMIT_DEBUG ?? "").trim() === "1") {
 		console.error(message);
@@ -84,6 +113,10 @@ function resolveSatWalletId(cfg) {
 	const value = cfg.plugins?.entries?.["sat-mining"]?.config?.walletId;
 	return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function resolveSatCluster(cfg) {
+	const value = cfg.plugins?.entries?.["sat-mining"]?.config?.network;
+	return value === "local" || value === "mainnet-beta" || value === "devnet" ? value : "devnet";
+}
 function resolveSatEffectiveEnv(cfg, env) {
 	return {
 		...env,
@@ -93,68 +126,46 @@ function resolveSatEffectiveEnv(cfg, env) {
 function resolveSatProviderId(cfg, env) {
 	const effectiveEnv = resolveSatEffectiveEnv(cfg, env);
 	const walletId = resolveSatWalletId(cfg);
+	const signerSocket = String(effectiveEnv.FASED_WALLET_LOCAL_SIGNER_SOCKET ?? "").trim();
 	if (walletId) {
-		const hasSelfHostedSignerMaterial = String(effectiveEnv.FASED_WALLET_LOCAL_SIGNER_SOCKET ?? "").trim() || String(effectiveEnv.FASED_WALLET_LOCAL_SIGNER_BACKEND_SOCKET ?? "").trim() || String(walletEnvValue(effectiveEnv, "FASED_WALLET_SOLANA_KEYSTORE_PATH", walletId) ?? "").trim();
-		try {
-			const wallet = readWalletProviderRegistry(effectiveEnv).wallets.find((entry) => entry.id === walletId);
-			if (wallet?.providerId === "local-socket-signer") {
-				return wallet.providerId;
-			}
-			if (hasSelfHostedSignerMaterial) {
-				return "local-socket-signer";
-			}
-			if (wallet?.providerId) {
-				return wallet.providerId;
-			}
-		} catch {}
-		if (hasSelfHostedSignerMaterial) {
-			return "local-socket-signer";
+		const wallet = readWalletProviderRegistry(effectiveEnv).wallets.find((entry) => entry.id === walletId);
+		if (wallet?.providerId === "embedded-keystore") {
+			throw new Error(LEGACY_EMBEDDED_KEYSTORE_MIGRATION_MESSAGE);
+		}
+		if (wallet?.providerId && wallet.providerId !== "local-socket-signer") {
+			return wallet.providerId;
+		}
+		if (wallet?.providerId === "local-socket-signer" && !signerSocket) {
+			throw new Error("SAT mining requires the actual protocol-v2 fased-signerd application socket; legacy keystore paths and backend sockets are not signer capability.");
+		}
+		if (wallet?.providerId === "local-socket-signer") {
+			return wallet.providerId;
 		}
 	}
-	return resolveWalletProviderId(cfg, effectiveEnv);
-}
-async function enforceSatCustodyAutonomousSigning(cfg, env) {
-	const effectiveEnv = resolveSatEffectiveEnv(cfg, env);
-	const walletCfg = resolveWalletRuntimeConfig(cfg, effectiveEnv);
-	const walletId = resolveSatWalletId(cfg);
-	if (walletCfg.execution.mode !== "autonomous") {
-		return;
-	}
-	const custodyGate = await enforceWalletCustodyForAutonomousSend({
-		wallet: walletCfg,
-		env: effectiveEnv,
-		cfg,
-		walletId,
-		approvalHost: String(effectiveEnv.FASED_WALLET_CUSTODY_ACTIVE_HOST ?? effectiveEnv.FASED_A2A_ORIGIN ?? "127.0.0.1")
-	});
-	if (!custodyGate.ok) {
-		throw new Error(custodyGate.message);
+	const providerId = resolveWalletProviderId(cfg, effectiveEnv);
+	if (providerId === "local-socket-signer" && !signerSocket) {
+		throw new Error("SAT mining requires the actual protocol-v2 fased-signerd application socket; configure FASED_WALLET_LOCAL_SIGNER_SOCKET.");
 	}
+	return providerId;
 }
-function resolveSatRegistrySolanaAddress(cfg, env) {
+async function resolveSatLocalSignerAddress(cfg, env, errorMessage, verifyCapabilities = true) {
 	const effectiveEnv = resolveSatEffectiveEnv(cfg, env);
 	const walletId = resolveSatWalletId(cfg);
 	if (!walletId) {
-		return "";
+		throw new Error("SAT mining local signer address lookup requires an attached walletId");
 	}
-	const wallet = readWalletProviderRegistry(effectiveEnv).wallets.find((entry) => entry.id === walletId);
-	return typeof wallet?.addresses?.solana === "string" ? wallet.addresses.solana.trim() : "";
-}
-async function resolveSatLocalSignerAddress(cfg, env, errorMessage) {
-	const effectiveEnv = resolveSatEffectiveEnv(cfg, env);
-	const walletId = resolveSatWalletId(cfg);
-	const result = await callLocalSocketSigner(requireLocalSocketSignerPath(effectiveEnv), {
-		op: "getAddresses",
-		...walletId ? { walletId } : {}
+	const socketPath = requireLocalSocketSignerPath(effectiveEnv);
+	if (verifyCapabilities) {
+		await requireTypedSatSignerCapabilities(socketPath, "solana.satAction");
+	}
+	const result = await callLocalSocketSigner(socketPath, {
+		op: "v2.wallet.get",
+		walletId
 	});
-	const signer = String(result.solana ?? "").trim();
+	const signer = String(result.publicKey ?? "").trim();
 	if (signer) {
 		return signer;
 	}
-	const fallback = resolveSatRegistrySolanaAddress(cfg, env);
-	if (fallback) {
-		return fallback;
-	}
 	throw new Error(errorMessage);
 }
 function encodeU64(value) {
@@ -203,7 +214,6 @@ function assertDedicatedBondProgram(env) {
 async function resolveSatValidatorAuthority(_config) {
 	const cfg = loadConfigForSatRuntime(_config);
 	const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
-	await enforceSatCustodyAutonomousSigning(cfg, effectiveEnv);
 	if (resolveSatProviderId(cfg, effectiveEnv) !== "local-socket-signer") {
 		throw new Error("SAT mining unattended signing currently requires local-socket-signer for validator authority resolution");
 	}
@@ -214,7 +224,7 @@ async function prepareLocalSignerSubmitContext(cfg, env) {
 	const solana = await loadSolanaWeb3();
 	const walletId = resolveSatWalletId(cfg);
 	const socketPath = requireLocalSocketSignerPath(effectiveEnv);
-	const signerAddress = await resolveSatLocalSignerAddress(cfg, effectiveEnv, "local-socket-signer returned no Solana address for SAT mining wallet");
+	const signerAddress = await resolveSatLocalSignerAddress(cfg, effectiveEnv, "local-socket-signer returned no Solana address for SAT mining wallet", false);
 	const signer = new solana.PublicKey(signerAddress);
 	return {
 		effectiveEnv,
@@ -226,39 +236,645 @@ async function prepareLocalSignerSubmitContext(cfg, env) {
 	};
 }
 async function buildLocalSignerInstructionRequest(params) {
-	const keys = await params.spec.accountResolver(params.solana, params.signer);
-	satSubmitDebug(`[sat-submit-debug] data_len=${params.spec.data.length} disc=${params.spec.data[0] ?? -1} keys=${keys.length}`);
+	const resolved = await params.spec.accountResolver(params.solana, params.signer);
+	const keys = Array.isArray(resolved) ? resolved : resolved.keys;
+	const context = Array.isArray(resolved) ? undefined : resolved.context;
+	const programId = params.spec.programId ?? resolveSatProgramIdFromEnv(params.env);
+	const mainProgramId = resolveSatProgramIdFromEnv(params.env);
+	const bondProgramId = resolveSatBondProgramIdFromEnv(params.env).trim() || undefined;
+	const codec = resolveSatSignerCodec({
+		programId,
+		mainProgramId,
+		bondProgramId,
+		data: params.spec.data
+	});
+	satSubmitDebug(`[sat-submit-debug] action=${codec.action} data_len=${params.spec.data.length} disc=${params.spec.data[0] ?? -1} keys=${keys.length}`);
 	return {
-		...params.walletId ? { walletId: params.walletId } : {},
-		programId: params.spec.programId ?? SAT_PROGRAM_ID(),
+		action: codec.action,
+		programId,
 		dataBase64: params.spec.data.toString("base64"),
 		keys: keys.map((key) => ({
 			pubkey: key.pubkey.toBase58(),
 			isSigner: key.isSigner,
 			isWritable: key.isWritable
-		}))
+		})),
+		...params.spec.addressLookupTables?.length ? { addressLookupTables: params.spec.addressLookupTables } : {},
+		...context ? { context } : {}
+	};
+}
+const REQUIRED_SAT_SIGNER_FEATURES = [
+	"failClosedPolicies",
+	"policyHashes",
+	"durableCaps",
+	"atomicIdempotency",
+	"ambiguousBroadcastReconciliation",
+	"signerOwnedKeys",
+	"typedSolanaTransactions",
+	"typedSATActions"
+];
+async function requireTypedSatSignerCapabilities(socketPath, intentType) {
+	const result = await callLocalSocketSigner(socketPath, { op: "v2.capabilities" });
+	const capabilities = result.capabilities;
+	const protocol = capabilities?.protocol;
+	const features = new Set(capabilities?.features ?? []);
+	const states = new Set(capabilities?.operationStates ?? []);
+	const missingFeatures = REQUIRED_SAT_SIGNER_FEATURES.filter((feature) => !features.has(feature));
+	const missingStates = [
+		"reserved",
+		"broadcast",
+		"confirmed",
+		"failed",
+		"unknown"
+	].filter((state) => !states.has(state));
+	const missingVaultReviewFeatures = intentType === "solana.vaultBondAction" ? [
+		"signerOwnedReviewPrepareExecute",
+		"exactPreparedTransactions",
+		"reviewedVaultBondActions",
+		"signerOwnedStateRecheck",
+		"durableReviewAuthorization"
+	].filter((feature) => !features.has(feature)) : [];
+	const missingLookupFeatures = intentType === "solana.satLookupTable" && !features.has("typedSATAddressLookupTables") ? ["typedSATAddressLookupTables"] : [];
+	if (result.ready !== true || protocol?.current !== 2 || typeof protocol.min !== "number" || protocol.min > 2 || typeof protocol.max !== "number" || protocol.max < 2 || !capabilities?.intentTypes?.includes(intentType) || missingFeatures.length > 0 || missingLookupFeatures.length > 0 || intentType === "solana.vaultBondAction" && !features.has("typedVaultBondActions") || missingVaultReviewFeatures.length > 0 || missingStates.length > 0) {
+		throw new Error(`local-socket-signer does not support the required typed SAT protocol-v2 contract${missingFeatures.length > 0 ? `; missing features: ${missingFeatures.join(", ")}` : ""}${missingVaultReviewFeatures.length > 0 ? `; missing reviewed Vault features: ${missingVaultReviewFeatures.join(", ")}` : ""}${missingLookupFeatures.length > 0 ? `; missing SAT lookup features: ${missingLookupFeatures.join(", ")}` : ""}${missingStates.length > 0 ? `; missing states: ${missingStates.join(", ")}` : ""}`);
+	}
+}
+async function reconcileTypedSatOperation(params) {
+	let operation = params.operation ?? await callLocalSocketSigner(params.socketPath, {
+		op: "v2.operation.get",
+		walletId: params.walletId,
+		request: { requestId: params.requestId }
+	});
+	if (operation.state === "broadcast" || operation.state === "unknown") {
+		try {
+			operation = await callLocalSocketSigner(params.socketPath, {
+				op: "v2.operation.reconcile",
+				walletId: params.walletId,
+				request: { requestId: params.requestId }
+			});
+		} catch {}
+	}
+	return operation;
+}
+function assertSatSignerOperationIdentity(operation, requestId) {
+	if (operation.requestId !== requestId) {
+		throw new Error(`SAT signer returned request ${operation.requestId || "<empty>"} while reconciling ${requestId}`);
+	}
+	return operation;
+}
+function signerStateForLedger(state) {
+	return state;
+}
+function assertSatLookupTableAction(value) {
+	if (value !== "create" && value !== "extend" && value !== "deactivate" && value !== "close") {
+		throw new Error(`unsupported SAT lookup-table action ${value}`);
+	}
+}
+var SatSubmissionUnresolvedError = class extends Error {
+	constructor(params) {
+		super(`SAT signer operation ${params.requestId} remains ${params.state}${params.signature ? ` with signature ${params.signature}` : ""}; it is unresolved and must be reconciled with the same idempotency key before any new submission${params.detail ? ` (${params.detail})` : ""}`);
+		this.name = "SatSubmissionUnresolvedError";
+		this.requestId = params.requestId;
+		this.signature = params.signature;
+	}
+};
+async function executeTypedSatIntent(params) {
+	const isLookupTable = params.lookupTable != null;
+	const isVaultBond = !isLookupTable && params.action !== "cleanupBatch" && VAULT_BOND_ACTIONS.has(params.action);
+	const intentType = isLookupTable ? "solana.satLookupTable" : isVaultBond ? "solana.vaultBondAction" : "solana.satAction";
+	await requireTypedSatSignerCapabilities(params.socketPath, intentType);
+	const intent = isLookupTable ? (() => {
+		if (params.instruction || params.instructions || !params.lookupTable) {
+			throw new Error("typed SAT lookup-table execution accepts only semantic lookup details");
+		}
+		const action = params.action;
+		assertSatLookupTableAction(action);
+		return {
+			type: "solana.satLookupTable",
+			action,
+			lookupTable: params.lookupTable
+		};
+	})() : isVaultBond ? (() => {
+		if (!params.instruction || params.instructions) {
+			throw new Error("typed Vault bond execution requires exactly one semantic instruction");
+		}
+		return {
+			type: "solana.vaultBondAction",
+			cluster: params.cluster,
+			...params.instruction
+		};
+	})() : {
+		type: "solana.satAction",
+		action: params.action,
+		...params.instruction ?? {},
+		...params.instructions ? { instructions: params.instructions } : {}
+	};
+	const policy = await callLocalSocketSigner(params.socketPath, {
+		op: "v2.policy.get",
+		walletId: params.walletId
+	});
+	const intentDigest = digestSatSubmissionIntent({
+		walletId: params.walletId,
+		policyHash: policy.hash,
+		intent
+	});
+	const operationKey = buildSatSubmissionOperationKey(intent);
+	const workflowId = satSubmissionWorkflowStorage.getStore() ?? `derived:${operationKey}:${intentDigest}`;
+	let claim = await claimSatSubmission({
+		walletId: params.walletId,
+		workflowId,
+		operationKey,
+		intentDigest,
+		action: params.action,
+		env: params.env
+	});
+	if (!claim.claimed) {
+		await waitForSatSubmissionLease({
+			walletId: params.walletId,
+			requestId: claim.record.requestId,
+			env: params.env
+		});
+		claim = await claimSatSubmission({
+			walletId: params.walletId,
+			workflowId,
+			operationKey,
+			intentDigest,
+			action: params.action,
+			env: params.env,
+			owner: claim.owner
+		});
+		if (!claim.claimed) {
+			throw new Error(`SAT submission ${claim.record.requestId} could not acquire its durable execution lease`);
+		}
+	}
+	const requestId = claim.record.requestId;
+	let resumedReviewedOperation;
+	if (intent.type === "solana.vaultBondAction") {
+		let reviewWasSigned = false;
+		try {
+			let review;
+			try {
+				review = await callLocalSocketSigner(params.socketPath, {
+					op: "v2.review.get",
+					walletId: params.walletId,
+					request: { requestId }
+				});
+			} catch (lookupError) {
+				if (!String(lookupError).includes("signer review not found")) {
+					throw lookupError;
+				}
+				review = await callLocalSocketSigner(params.socketPath, {
+					op: "v2.review.prepare",
+					walletId: params.walletId,
+					request: {
+						requestId,
+						policyHash: policy.hash,
+						mode: "reviewed",
+						intent
+					}
+				});
+			}
+			if (review.requestId !== requestId || review.policyHash !== policy.hash || review.mode !== "reviewed" || review.intentType !== intent.type || !isDeepStrictEqual(review.semanticIntent, intent)) {
+				throw new Error(`Vault bond review ${requestId} does not match the exact SAT intent`);
+			}
+			if (review.state === "prepared") {
+				const approval = createSignerReviewApprovalRequest({
+					review,
+					role: "vault",
+					walletId: params.walletId,
+					requestedBy: "sat-mining-vault",
+					assetSymbol: "SAT",
+					assetName: "SAT bond",
+					memo: `Reviewed Vault bond action: ${intent.action}`,
+					env: params.env
+				});
+				await updateSatSubmission({
+					walletId: params.walletId,
+					requestId,
+					intentDigest,
+					state: "reserved",
+					error: `review ${approval.id} pending`,
+					owner: claim.owner,
+					releaseLease: true,
+					env: params.env
+				});
+				throw new Error(`Vault bond review ${approval.id} is pending in Wallet Approvals for ${intent.action}; approve it there with the signer-owned passkey`);
+			}
+			reviewWasSigned = true;
+			resumedReviewedOperation = assertSatSignerOperationIdentity(await reconcileTypedSatOperation({
+				socketPath: params.socketPath,
+				walletId: params.walletId,
+				requestId
+			}), requestId);
+		} catch (error) {
+			await updateSatSubmission({
+				walletId: params.walletId,
+				requestId,
+				intentDigest,
+				state: reviewWasSigned ? "unknown" : "reserved",
+				error: error instanceof Error ? error.message : String(error),
+				owner: claim.owner,
+				releaseLease: true,
+				env: params.env
+			}).catch(() => undefined);
+			throw error;
+		}
+	}
+	const executeExactOrRecover = async () => {
+		try {
+			return await callLocalSocketSigner(params.socketPath, {
+				op: "v2.execute",
+				walletId: params.walletId,
+				request: {
+					requestId,
+					policyHash: policy.hash,
+					intent
+				}
+			});
+		} catch (executeError) {
+			try {
+				return await callLocalSocketSigner(params.socketPath, {
+					op: "v2.operation.get",
+					walletId: params.walletId,
+					request: { requestId }
+				});
+			} catch (lookupError) {
+				const detail = `${executeError instanceof Error ? executeError.message : String(executeError)}; ${lookupError instanceof Error ? lookupError.message : String(lookupError)}`;
+				await updateSatSubmission({
+					walletId: params.walletId,
+					requestId,
+					intentDigest,
+					state: claim.record.state === "confirmed" || claim.record.state === "failed" ? claim.record.state : "unknown",
+					...claim.record.signature ? { signature: claim.record.signature } : {},
+					error: detail,
+					owner: claim.owner,
+					releaseLease: true,
+					env: params.env
+				});
+				throw new SatSubmissionUnresolvedError({
+					requestId,
+					state: "unknown",
+					detail
+				});
+			}
+		}
+	};
+	let operation;
+	if (resumedReviewedOperation) {
+		operation = resumedReviewedOperation;
+	} else if (!claim.created) {
+		const callerStateWasAmbiguous = claim.record.state === "broadcast" || claim.record.state === "unknown";
+		try {
+			operation = assertSatSignerOperationIdentity(await callLocalSocketSigner(params.socketPath, {
+				op: "v2.operation.get",
+				walletId: params.walletId,
+				request: { requestId }
+			}), requestId);
+			operation = assertSatSignerOperationIdentity(await reconcileTypedSatOperation({
+				socketPath: params.socketPath,
+				walletId: params.walletId,
+				requestId,
+				operation
+			}), requestId);
+		} catch (lookupError) {
+			if (claim.record.signature) {
+				await updateSatSubmission({
+					walletId: params.walletId,
+					requestId,
+					intentDigest,
+					state: claim.record.state === "confirmed" ? "confirmed" : "unknown",
+					signature: claim.record.signature,
+					error: lookupError instanceof Error ? lookupError.message : String(lookupError),
+					owner: claim.owner,
+					releaseLease: true,
+					env: params.env
+				});
+				throw new SatSubmissionUnresolvedError({
+					requestId,
+					state: claim.record.state === "confirmed" ? "confirmed-but-unverified" : "unknown",
+					signature: claim.record.signature,
+					detail: lookupError instanceof Error ? lookupError.message : String(lookupError)
+				});
+			}
+			if (claim.record.state === "failed" || claim.record.state === "confirmed") {
+				const detail = lookupError instanceof Error ? lookupError.message : String(lookupError);
+				await updateSatSubmission({
+					walletId: params.walletId,
+					requestId,
+					intentDigest,
+					state: claim.record.state,
+					error: detail,
+					owner: claim.owner,
+					releaseLease: true,
+					env: params.env
+				});
+				if (claim.record.state === "failed") {
+					throw new Error(claim.record.error || `SAT signer operation ${requestId} failed`);
+				}
+				throw new SatSubmissionUnresolvedError({
+					requestId,
+					state: "confirmed-without-signature",
+					detail
+				});
+			}
+			operation = await executeExactOrRecover();
+		}
+		if (operation.state === "reserved" && !operation.signature) {
+			if (callerStateWasAmbiguous) {
+				const detail = `signer regressed to reserved after caller persisted ${claim.record.state}`;
+				await updateSatSubmission({
+					walletId: params.walletId,
+					requestId,
+					intentDigest,
+					state: "unknown",
+					...claim.record.signature ? { signature: claim.record.signature } : {},
+					error: detail,
+					owner: claim.owner,
+					releaseLease: true,
+					env: params.env
+				});
+				throw new SatSubmissionUnresolvedError({
+					requestId,
+					state: "unknown",
+					signature: claim.record.signature,
+					detail
+				});
+			}
+			operation = await executeExactOrRecover();
+		}
+	} else {
+		operation = await executeExactOrRecover();
+	}
+	try {
+		operation = assertSatSignerOperationIdentity(operation, requestId);
+		operation = assertSatSignerOperationIdentity(await reconcileTypedSatOperation({
+			socketPath: params.socketPath,
+			walletId: params.walletId,
+			requestId,
+			operation
+		}), requestId);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		await updateSatSubmission({
+			walletId: params.walletId,
+			requestId,
+			intentDigest,
+			state: claim.record.state === "confirmed" || claim.record.state === "failed" ? claim.record.state : "unknown",
+			...claim.record.signature ? { signature: claim.record.signature } : {},
+			error: detail,
+			owner: claim.owner,
+			releaseLease: true,
+			env: params.env
+		});
+		throw new SatSubmissionUnresolvedError({
+			requestId,
+			state: "unknown",
+			detail
+		});
+	}
+	await updateSatSubmission({
+		walletId: params.walletId,
+		requestId,
+		intentDigest,
+		state: signerStateForLedger(operation.state),
+		...operation.signature ? { signature: operation.signature } : {},
+		...operation.error ? { error: operation.error } : {},
+		owner: claim.owner,
+		releaseLease: true,
+		env: params.env
+	});
+	if (operation.state === "failed") {
+		throw new Error(operation.error || `SAT signer operation ${requestId} failed`);
+	}
+	if (operation.state !== "confirmed" || !operation.signature) {
+		throw new SatSubmissionUnresolvedError({
+			requestId,
+			state: operation.state,
+			signature: operation.signature,
+			detail: operation.error
+		});
+	}
+	return {
+		...operation,
+		signature: operation.signature
+	};
+}
+function assertSatLookupTableEnabled(env) {
+	if (String(env.FASED_SAT_ENABLE_ALT_V0 ?? "").trim() !== "1") {
+		throw new Error("SAT ALT/v0 support is disabled; set FASED_SAT_ENABLE_ALT_V0=1");
+	}
+}
+async function executeTypedSatLookupOperation(params) {
+	return await executeTypedSatIntent({
+		socketPath: params.context.socketPath,
+		walletId: params.context.walletId,
+		action: params.action,
+		lookupTable: {
+			address: params.address,
+			...params.recentSlot == null ? {} : { recentSlot: String(params.recentSlot) },
+			...params.addresses?.length ? { addresses: params.addresses } : {}
+		},
+		cluster: resolveSatCluster(params.cfg),
+		env: params.context.effectiveEnv
+	});
+}
+async function readValidatedSatLookupTable(params) {
+	const state = await inspectSatAddressLookupTable(params.config, { address: params.address });
+	if (!state) {
+		return null;
+	}
+	if (state.authority !== params.authority) {
+		throw new Error("SAT distribution lookup table is not controlled by the Mining signer");
+	}
+	if (!state.active) {
+		throw new Error("SAT distribution lookup table is not active");
+	}
+	return state;
+}
+async function waitForSatLookupTable(params) {
+	let lastError;
+	for (let attempt = 0; attempt < 24; attempt += 1) {
+		try {
+			const state = await readValidatedSatLookupTable(params);
+			if (state) {
+				const currentSlot = await inspectSatChainSlot(params.config);
+				if (!params.requireNextSlot || currentSlot > state.lastExtendedSlot) {
+					return state;
+				}
+			}
+		} catch (error) {
+			lastError = error;
+		}
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+	throw new Error(`SAT distribution lookup table did not become active for use within 6s${lastError instanceof Error ? `: ${lastError.message}` : ""}`);
+}
+async function ensureSatDistributionLookupTable(params) {
+	assertSatLookupTableEnabled(params.context.effectiveEnv);
+	const desiredAddresses = [...new Set(params.addresses.map((entry) => entry.trim()))].filter(Boolean);
+	if (desiredAddresses.length === 0 || desiredAddresses.length > 256) {
+		throw new Error("SAT distribution lookup table requires 1-256 exact account addresses");
+	}
+	let lookupTable = params.lookupTableAddress?.trim() ?? "";
+	let state = lookupTable ? await readValidatedSatLookupTable({
+		config: params.config,
+		address: lookupTable,
+		authority: params.context.signerAddress
+	}) : null;
+	let created = false;
+	const transactionHashes = [];
+	if (!lookupTable) {
+		const currentSlot = await inspectSatChainSlot(params.config);
+		const recentSlot = Math.max(0, currentSlot - 1);
+		const [, derivedAddress] = params.context.solana.AddressLookupTableProgram.createLookupTable({
+			authority: params.context.signer,
+			payer: params.context.signer,
+			recentSlot
+		});
+		lookupTable = derivedAddress.toBase58();
+		state = await readValidatedSatLookupTable({
+			config: params.config,
+			address: lookupTable,
+			authority: params.context.signerAddress
+		});
+		if (!state) {
+			try {
+				const submitted = await executeTypedSatLookupOperation({
+					context: params.context,
+					cfg: params.cfg,
+					action: "create",
+					address: lookupTable,
+					recentSlot
+				});
+				transactionHashes.push(submitted.signature);
+				created = true;
+			} catch (error) {
+				if (error instanceof SatSubmissionUnresolvedError) {
+					throw error;
+				}
+				try {
+					state = await waitForSatLookupTable({
+						config: params.config,
+						address: lookupTable,
+						authority: params.context.signerAddress,
+						requireNextSlot: false
+					});
+				} catch {
+					throw error;
+				}
+			}
+			state ??= await waitForSatLookupTable({
+				config: params.config,
+				address: lookupTable,
+				authority: params.context.signerAddress,
+				requireNextSlot: false
+			});
+		}
+	}
+	if (!state) {
+		throw new Error("SAT distribution lookup table was not found at the confirmed commitment");
+	}
+	const existing = new Set(state.addresses);
+	const missing = desiredAddresses.filter((entry) => !existing.has(entry));
+	for (let offset = 0; offset < missing.length; offset += SAT_LOOKUP_TABLE_EXTEND_CHUNK_SIZE) {
+		const addresses = missing.slice(offset, offset + SAT_LOOKUP_TABLE_EXTEND_CHUNK_SIZE);
+		try {
+			const submitted = await executeTypedSatLookupOperation({
+				context: params.context,
+				cfg: params.cfg,
+				action: "extend",
+				address: lookupTable,
+				addresses
+			});
+			transactionHashes.push(submitted.signature);
+		} catch (error) {
+			if (error instanceof SatSubmissionUnresolvedError) {
+				throw error;
+			}
+			const concurrentState = await waitForSatLookupTable({
+				config: params.config,
+				address: lookupTable,
+				authority: params.context.signerAddress,
+				requireNextSlot: false
+			}).catch(() => null);
+			if (!concurrentState || addresses.some((address) => !concurrentState.addresses.includes(address))) {
+				throw error;
+			}
+		}
+	}
+	const ready = await waitForSatLookupTable({
+		config: params.config,
+		address: lookupTable,
+		authority: params.context.signerAddress,
+		requireNextSlot: true
+	});
+	for (const address of desiredAddresses) {
+		if (!ready.addresses.includes(address)) {
+			throw new Error(`SAT distribution lookup table did not persist required account ${address}`);
+		}
+	}
+	return {
+		lookupTable,
+		created,
+		extended: missing.length > 0,
+		addressCount: ready.addresses.length,
+		transactionHashes
 	};
 }
 async function submitInstructionViaLocalSigner(params) {
 	const context = await prepareLocalSignerSubmitContext(params.cfg, params.env);
-	const request = await buildLocalSignerInstructionRequest({
+	const baseRequest = await buildLocalSignerInstructionRequest({
 		solana: context.solana,
 		signer: context.signer,
-		walletId: context.walletId,
+		env: context.effectiveEnv,
 		spec: params
 	});
-	const submitted = await callLocalSocketSigner(context.socketPath, {
-		op: "sendSolanaInstruction",
-		request
+	if (!context.walletId) {
+		throw new Error("typed SAT signing requires an explicit mining walletId");
+	}
+	let managedLookupTable;
+	if (params.manageAddressLookupTable) {
+		managedLookupTable = await ensureSatDistributionLookupTable({
+			context: {
+				...context,
+				walletId: context.walletId
+			},
+			cfg: params.cfg,
+			config: params.cfg,
+			lookupTableAddress: params.manageAddressLookupTable.lookupTableAddress,
+			addresses: baseRequest.keys.filter((key) => !key.isSigner).map((key) => key.pubkey)
+		});
+	}
+	const request = managedLookupTable ? {
+		...baseRequest,
+		addressLookupTables: [managedLookupTable.lookupTable]
+	} : baseRequest;
+	const submitted = await executeTypedSatIntent({
+		socketPath: context.socketPath,
+		walletId: context.walletId,
+		action: request.action,
+		instruction: request,
+		cluster: resolveSatCluster(params.cfg),
+		env: context.effectiveEnv
 	});
 	return {
-		txHash: submitted.txHash,
-		signer: submitted.signer ?? context.signerAddress
+		txHash: submitted.signature,
+		signer: context.signerAddress,
+		signerState: submitted.state,
+		requestId: submitted.requestId,
+		...request.addressLookupTables?.length ? {
+			transactionVersion: "v0",
+			lookupTableAddress: request.addressLookupTables[0]
+		} : { transactionVersion: "legacy" },
+		...managedLookupTable ? {
+			lookupTableCreated: managedLookupTable.created,
+			lookupTableExtended: managedLookupTable.extended,
+			lookupTableAddressCount: managedLookupTable.addressCount,
+			lookupTableTransactionHashes: managedLookupTable.transactionHashes
+		} : {}
 	};
 }
 async function submitInstruction(params) {
 	const effectiveEnv = resolveSatEffectiveEnv(params.cfg, params.env);
-	await enforceSatCustodyAutonomousSigning(params.cfg, effectiveEnv);
 	if (resolveSatProviderId(params.cfg, effectiveEnv) !== "local-socket-signer") {
 		throw new Error("SAT mining unattended submission currently requires local-socket-signer");
 	}
@@ -267,6 +883,8 @@ async function submitInstruction(params) {
 		env: effectiveEnv,
 		data: params.data,
 		programId: params.programId,
+		addressLookupTables: params.addressLookupTables,
+		manageAddressLookupTable: params.manageAddressLookupTable,
 		accountResolver: params.accountResolver
 	});
 }
@@ -278,7 +896,6 @@ async function submitInstructionBatch(params) {
 		throw new Error("SAT cleanup batch exceeds signer limit");
 	}
 	const effectiveEnv = resolveSatEffectiveEnv(params.cfg, params.env);
-	await enforceSatCustodyAutonomousSigning(params.cfg, effectiveEnv);
 	if (resolveSatProviderId(params.cfg, effectiveEnv) !== "local-socket-signer") {
 		throw new Error("SAT mining unattended batch submission currently requires local-socket-signer");
 	}
@@ -288,21 +905,26 @@ async function submitInstructionBatch(params) {
 		instructions.push(await buildLocalSignerInstructionRequest({
 			solana: context.solana,
 			signer: context.signer,
-			walletId: context.walletId,
+			env: context.effectiveEnv,
 			spec
 		}));
 	}
-	const submitted = await callLocalSocketSigner(context.socketPath, {
-		op: "sendSolanaInstructions",
-		request: {
-			...context.walletId ? { walletId: context.walletId } : {},
-			purpose: params.purpose,
-			instructions
-		}
+	if (!context.walletId) {
+		throw new Error("typed SAT cleanup signing requires an explicit mining walletId");
+	}
+	const submitted = await executeTypedSatIntent({
+		socketPath: context.socketPath,
+		walletId: context.walletId,
+		action: "cleanupBatch",
+		instructions,
+		cluster: resolveSatCluster(params.cfg),
+		env: context.effectiveEnv
 	});
 	return {
-		txHash: submitted.txHash,
-		signer: submitted.signer ?? context.signerAddress,
+		txHash: submitted.signature,
+		signer: context.signerAddress,
+		signerState: submitted.state,
+		requestId: submitted.requestId,
 		instructionCount: instructions.length
 	};
 }
@@ -390,12 +1012,8 @@ function buildClaimData(params) {
 function buildMiningCrankData() {
 	return Buffer.from([IX.miningCrank]);
 }
-function buildBootstrapData(params) {
-	return Buffer.concat([
-		Buffer.from([IX.bootstrap]),
-		encodePubkey(params.authority),
-		encodeU64(params.initialStake)
-	]);
+function buildTopUpRegistryReserveData(params) {
+	return Buffer.concat([Buffer.from([IX.topUpRegistryReserve]), encodeU64(params.targetBalanceLamports)]);
 }
 function buildOpenCycleData(params) {
 	return Buffer.concat([Buffer.from([IX.openCycle]), encodeU64(params.cycleId)]);
@@ -412,16 +1030,6 @@ function buildWithdrawMinerCapitalData(params) {
 function buildSetActiveCommitData(params) {
 	return Buffer.concat([Buffer.from([IX.setActiveCommit]), encodeU64(params.lamports)]);
 }
-function buildInitBondTierPolicyData(params) {
-	return Buffer.concat([
-		Buffer.from([BOND_IX.initTierPolicy]),
-		encodePubkey(params.updateAuthority),
-		encodeU64(params.basicMinRaw),
-		encodeU64(params.operatorMinRaw),
-		encodeU64(params.unlockDelaySlots),
-		encodeU64(params.scheduledEffectiveSlot ?? 0)
-	]);
-}
 function buildUpdateBondTierPolicyData(params) {
 	return Buffer.concat([
 		Buffer.from([BOND_IX.updateTierPolicy]),
@@ -452,14 +1060,6 @@ function buildFinalizeBondUnlockData(env = process.env) {
 	assertDedicatedBondProgram(env);
 	return Buffer.from([BOND_IX.finalizeBondUnlock]);
 }
-function buildInitBondStakingDistributorData(params, env = process.env) {
-	assertDedicatedBondProgram(env);
-	return Buffer.concat([
-		Buffer.from([BOND_IX.initStakingDistributor]),
-		encodePubkey(params.updateAuthority),
-		encodeU64(params.minStakeRaw)
-	]);
-}
 function buildSyncBondStakingRewardsData(env = process.env) {
 	assertDedicatedBondProgram(env);
 	return Buffer.from([BOND_IX.syncStakingRewards]);
@@ -472,22 +1072,75 @@ function buildClaimBondStakingRewardsData(env = process.env) {
 	assertDedicatedBondProgram(env);
 	return Buffer.from([BOND_IX.claimStakingRewards]);
 }
-function buildSubmitCycleData(params) {
-	if (params.allocationFp.length !== 25) {
-		throw new Error(`expected 25 allocation buckets, got ${params.allocationFp.length}`);
+function buildClaimUnallocatedStakingRewardsData(env = process.env) {
+	assertDedicatedBondProgram(env);
+	return Buffer.from([BOND_IX.claimUnallocatedStakingRewards]);
+}
+function encodeAllocationFp(allocationFp) {
+	if (allocationFp.length !== 25) {
+		throw new Error(`expected 25 allocation buckets, got ${allocationFp.length}`);
+	}
+	return Buffer.concat(allocationFp.map((value) => {
+		if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) {
+			throw new Error(`invalid allocation bucket value: ${value}`);
+		}
+		const out = Buffer.alloc(4);
+		out.writeUInt32LE(value);
+		return out;
+	}));
+}
+function buildSatCycleCommitment(params) {
+	if (params.nonce.length !== 32) {
+		throw new Error(`expected 32-byte cycle nonce, got ${params.nonce.length}`);
 	}
-	const body = Buffer.concat([
-		Buffer.from([IX.submitCycle]),
+	const allocation = encodeAllocationFp(params.allocationFp);
+	return createHash("sha256").update(Buffer.concat([
+		Buffer.from("sat-cycle-commit-v1"),
+		encodePubkey(params.programId ?? SAT_PROGRAM_ID()),
+		encodePubkey(params.authority),
 		encodeU64(params.cycleId),
-		Buffer.concat(params.allocationFp.map((value) => {
-			const out = Buffer.alloc(4);
-			out.writeUInt32LE(value);
-			return out;
-		})),
+		encodeU64(params.committedLamports),
+		params.nonce,
+		allocation
+	])).digest();
+}
+function buildCommitCycleData(params) {
+	if (params.commitment.length !== 32) {
+		throw new Error(`expected 32-byte cycle commitment, got ${params.commitment.length}`);
+	}
+	return Buffer.concat([
+		Buffer.from([IX.commitCycle]),
+		encodeU64(params.cycleId),
+		params.commitment
+	]);
+}
+function buildCloseCommitPhaseData(params) {
+	return Buffer.concat([Buffer.from([IX.closeCommitPhase]), encodeU64(params.cycleId)]);
+}
+function buildSealCycleEntropyData(params) {
+	return Buffer.concat([Buffer.from([IX.sealCycleEntropy]), encodeU64(params.cycleId)]);
+}
+function buildRevealCycleData(params) {
+	if (params.nonce.length !== 32) {
+		throw new Error(`expected 32-byte cycle nonce, got ${params.nonce.length}`);
+	}
+	return Buffer.concat([
+		Buffer.from([IX.revealCycle]),
+		encodeU64(params.cycleId),
+		params.nonce,
+		encodeAllocationFp(params.allocationFp),
 		Buffer.alloc(4)
 	]);
-	satSubmitDebug(`[sat-submit-build] allocs=${params.allocationFp.length} len=${body.length} cycle=${params.cycleId}`);
-	return body;
+}
+function buildReleaseUnrevealedCommitData(params) {
+	return Buffer.concat([
+		Buffer.from([IX.releaseUnrevealedCommit]),
+		encodeU64(params.cycleId),
+		encodePubkey(params.minerAuthority)
+	]);
+}
+function buildAbortEmptyCycleData(params) {
+	return Buffer.concat([Buffer.from([IX.abortEmptyCycle]), encodeU64(params.cycleId)]);
 }
 function buildClaimCycleRewardsData(params) {
 	return Buffer.concat([Buffer.from([IX.claimCycleRewards]), encodeU64(params.cycleId)]);
@@ -504,13 +1157,6 @@ function buildClaimCycleRewardsBatchData(params) {
 		...params.cycleIds.map((cycleId) => encodeU64(cycleId))
 	]);
 }
-function buildSetProtocolRecipientsData(params) {
-	return Buffer.concat([
-		Buffer.from([IX.setProtocolRecipients]),
-		encodePubkey(params.treasuryRecipient),
-		encodePubkey(params.distributorRecipient)
-	]);
-}
 function buildClaimProtocolTreasuryData() {
 	return Buffer.from([IX.claimProtocolTreasury]);
 }
@@ -644,33 +1290,36 @@ async function submitSatValidatorAttestation(_config, params) {
 				encodeU64(params.microRoundId)
 			], programId);
 			const [miningStake] = solana.PublicKey.findProgramAddressSync([Buffer.from(MINING_STAKE_SEED), targetAuthority.toBuffer()], programId);
-			return [
-				{
-					pubkey: signer,
-					isSigner: true,
-					isWritable: true
-				},
-				{
-					pubkey: satEpoch,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: satValidatorAttestation,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: miningStake,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: solana.SystemProgram.programId,
-					isSigner: false,
-					isWritable: false
-				}
-			];
+			return {
+				keys: [
+					{
+						pubkey: signer,
+						isSigner: true,
+						isWritable: true
+					},
+					{
+						pubkey: satEpoch,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satValidatorAttestation,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: miningStake,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: solana.SystemProgram.programId,
+						isSigner: false,
+						isWritable: false
+					}
+				],
+				context: { targetAuthority: targetAuthority.toBase58() }
+			};
 		}
 	});
 }
@@ -692,33 +1341,36 @@ async function submitSatOpenDispute(_config, params) {
 				encodeU64(params.microRoundId)
 			], programId);
 			const [miningStake] = solana.PublicKey.findProgramAddressSync([Buffer.from(MINING_STAKE_SEED), targetAuthority.toBuffer()], programId);
-			return [
-				{
-					pubkey: signer,
-					isSigner: true,
-					isWritable: true
-				},
-				{
-					pubkey: satEpoch,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: satDispute,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: miningStake,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: solana.SystemProgram.programId,
-					isSigner: false,
-					isWritable: false
-				}
-			];
+			return {
+				keys: [
+					{
+						pubkey: signer,
+						isSigner: true,
+						isWritable: true
+					},
+					{
+						pubkey: satEpoch,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satDispute,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: miningStake,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: solana.SystemProgram.programId,
+						isSigner: false,
+						isWritable: false
+					}
+				],
+				context: { targetAuthority: targetAuthority.toBase58() }
+			};
 		}
 	});
 }
@@ -741,28 +1393,31 @@ async function submitSatResolveDispute(_config, params) {
 				encodeU64(params.epochId),
 				encodeU64(params.microRoundId)
 			], programId);
-			return [
-				{
-					pubkey: signer,
-					isSigner: true,
-					isWritable: true
-				},
-				{
-					pubkey: miningPool,
-					isSigner: false,
-					isWritable: false
-				},
-				{
-					pubkey: satEpoch,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: satDispute,
-					isSigner: false,
-					isWritable: true
-				}
-			];
+			return {
+				keys: [
+					{
+						pubkey: signer,
+						isSigner: true,
+						isWritable: true
+					},
+					{
+						pubkey: miningPool,
+						isSigner: false,
+						isWritable: false
+					},
+					{
+						pubkey: satEpoch,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satDispute,
+						isSigner: false,
+						isWritable: true
+					}
+				],
+				context: { disputeAuthority: disputeAuthority.toBase58() }
+			};
 		}
 	});
 }
@@ -796,44 +1451,29 @@ async function submitSatRepublishEpochRoots(_config, params) {
 		}
 	});
 }
-async function submitSatBootstrap(_config, params = {}) {
+async function submitSatTopUpRegistryReserve(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
+	const targetBalanceLamports = Math.max(0, Math.floor(params.targetBalanceLamports));
+	if (!Number.isSafeInteger(targetBalanceLamports)) {
+		throw new Error("registry reserve target must be a safe integer lamport amount");
+	}
+	const profile = resolveSatGenesisProfileContract(_config.network);
+	if (BigInt(targetBalanceLamports) > profile.registryReserveMaxLamports) {
+		throw new Error(`registry reserve target exceeds ${profile.cluster} genesis maximum ${profile.registryReserveMaxLamports}`);
+	}
 	return submitInstruction({
 		cfg,
 		env: process.env,
-		data: buildBootstrapData({
-			authority: params.authority ?? "",
-			initialStake: Math.max(0, Math.floor(params.initialStake ?? 0))
-		}),
+		data: buildTopUpRegistryReserveData({ targetBalanceLamports }),
 		accountResolver: async (solana, signer) => {
 			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
-			const [satGlobalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_GLOBAL_STATE_SEED)], programId);
-			const [treasury] = solana.PublicKey.findProgramAddressSync([Buffer.from("treasury")], programId);
-			const [satTreasuryState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_TREASURY_STATE_SEED)], programId);
 			const [satRegistryReserve] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_REGISTRY_RESERVE_SEED)], programId);
-			const [satRebateVault] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_REBATE_VAULT_SEED)], programId);
-			const [satTreasuryVault] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_TREASURY_VAULT_SEED)], programId);
 			return [
 				{
 					pubkey: signer,
 					isSigner: true,
 					isWritable: true
 				},
-				{
-					pubkey: satGlobalState,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: treasury,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: satTreasuryState,
-					isSigner: false,
-					isWritable: true
-				},
 				{
 					pubkey: satRegistryReserve,
 					isSigner: false,
@@ -843,16 +1483,6 @@ async function submitSatBootstrap(_config, params = {}) {
 					pubkey: solana.SystemProgram.programId,
 					isSigner: false,
 					isWritable: false
-				},
-				{
-					pubkey: satRebateVault,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: satTreasuryVault,
-					isSigner: false,
-					isWritable: true
 				}
 			];
 		}
@@ -919,14 +1549,16 @@ async function submitSatOpenCycle(_config, params) {
 }
 async function submitSatInitMinerCapital(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
+	const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
+	const authority = params.authority?.trim() || await resolveSatLocalSignerAddress(cfg, effectiveEnv, "local-socket-signer returned no Solana address for SAT miner capital authority");
 	return submitInstruction({
 		cfg,
-		env: process.env,
-		data: buildInitMinerCapitalData({ authority: params.authority ?? "" }),
+		env: effectiveEnv,
+		data: buildInitMinerCapitalData({ authority }),
 		accountResolver: async (solana, signer) => {
 			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
-			const authority = params.authority?.trim() ? new solana.PublicKey(params.authority) : signer;
-			const [satMinerCapitalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_MINER_CAPITAL_STATE_SEED), authority.toBuffer()], programId);
+			const authorityKey = new solana.PublicKey(authority);
+			const [satMinerCapitalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_MINER_CAPITAL_STATE_SEED), authorityKey.toBuffer()], programId);
 			return [
 				{
 					pubkey: signer,
@@ -1049,50 +1681,13 @@ function resolveSatBondAccounts(solana, signer, env = process.env) {
 		dedicated: hasDedicatedBondProgram(env)
 	};
 }
-async function submitSatInitBondTierPolicy(_config, params) {
-	const cfg = loadConfigForSatRuntime(_config);
-	const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
-	if (!hasDedicatedBondProgram(effectiveEnv)) {
-		throw new Error("SAT bond tier policy init requires FASED_SAT_BOND_PROGRAM_ID");
-	}
-	const defaultUpdateAuthority = resolveSatRegistrySolanaAddress(cfg, effectiveEnv) || await resolveSatLocalSignerAddress(cfg, effectiveEnv, "local-socket-signer returned no Solana address for SAT bond policy authority");
-	return submitInstruction({
-		cfg,
-		env: effectiveEnv,
-		data: buildInitBondTierPolicyData({
-			...params,
-			updateAuthority: params.updateAuthority ?? defaultUpdateAuthority
-		}),
-		programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
-		accountResolver: async (solana, signer) => {
-			const { bondTierPolicy } = resolveSatBondAccounts(solana, signer, effectiveEnv);
-			return [
-				{
-					pubkey: signer,
-					isSigner: true,
-					isWritable: true
-				},
-				{
-					pubkey: bondTierPolicy,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: solana.SystemProgram.programId,
-					isSigner: false,
-					isWritable: false
-				}
-			];
-		}
-	});
-}
 async function submitSatUpdateBondTierPolicy(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
 	const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
 	if (!hasDedicatedBondProgram(effectiveEnv)) {
 		throw new Error("SAT bond tier policy update requires FASED_SAT_BOND_PROGRAM_ID");
 	}
-	const defaultUpdateAuthority = resolveSatRegistrySolanaAddress(cfg, effectiveEnv) || await resolveSatLocalSignerAddress(cfg, effectiveEnv, "local-socket-signer returned no Solana address for SAT bond policy authority");
+	const defaultUpdateAuthority = await resolveSatLocalSignerAddress(cfg, effectiveEnv, "local-socket-signer returned no Solana address for SAT bond policy authority");
 	return submitInstruction({
 		cfg,
 		env: effectiveEnv,
@@ -1231,7 +1826,7 @@ async function submitSatRequestBondUnlock(_config) {
 		data: buildRequestBondUnlockData(effectiveEnv),
 		programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
 		accountResolver: async (solana, signer) => {
-			const { bondTierPolicy, bondPosition } = resolveSatBondAccounts(solana, signer, effectiveEnv);
+			const { bondTierPolicy, bondPosition, bondStakingDistributor, bondStakingPosition } = resolveSatBondAccounts(solana, signer, effectiveEnv);
 			const accounts = [{
 				pubkey: signer,
 				isSigner: true,
@@ -1245,6 +1840,14 @@ async function submitSatRequestBondUnlock(_config) {
 				pubkey: bondPosition,
 				isSigner: false,
 				isWritable: true
+			}, {
+				pubkey: bondStakingDistributor,
+				isSigner: false,
+				isWritable: true
+			}, {
+				pubkey: bondStakingPosition,
+				isSigner: false,
+				isWritable: true
 			});
 			return accounts;
 		}
@@ -1260,7 +1863,7 @@ async function submitSatCancelBondUnlock(_config) {
 		data: buildCancelBondUnlockData(effectiveEnv),
 		programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
 		accountResolver: async (solana, signer) => {
-			const { bondTierPolicy, bondPosition } = resolveSatBondAccounts(solana, signer, effectiveEnv);
+			const { bondTierPolicy, bondPosition, bondStakingDistributor, bondStakingPosition } = resolveSatBondAccounts(solana, signer, effectiveEnv);
 			const accounts = [{
 				pubkey: signer,
 				isSigner: true,
@@ -1274,6 +1877,14 @@ async function submitSatCancelBondUnlock(_config) {
 				pubkey: bondPosition,
 				isSigner: false,
 				isWritable: true
+			}, {
+				pubkey: bondStakingDistributor,
+				isSigner: false,
+				isWritable: true
+			}, {
+				pubkey: bondStakingPosition,
+				isSigner: false,
+				isWritable: true
 			});
 			return accounts;
 		}
@@ -1289,7 +1900,7 @@ async function submitSatFinalizeBondUnlock(_config) {
 		data: buildFinalizeBondUnlockData(effectiveEnv),
 		programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
 		accountResolver: async (solana, signer) => {
-			const { bondTierPolicy, bondPosition, signerTokenAccount, bondVault, mint } = resolveSatBondAccounts(solana, signer, effectiveEnv);
+			const { bondTierPolicy, bondPosition, bondStakingDistributor, bondStakingPosition, signerTokenAccount, bondVault, mint } = resolveSatBondAccounts(solana, signer, effectiveEnv);
 			const accounts = [{
 				pubkey: signer,
 				isSigner: true,
@@ -1303,6 +1914,14 @@ async function submitSatFinalizeBondUnlock(_config) {
 				pubkey: bondPosition,
 				isSigner: false,
 				isWritable: true
+			}, {
+				pubkey: bondStakingDistributor,
+				isSigner: false,
+				isWritable: true
+			}, {
+				pubkey: bondStakingPosition,
+				isSigner: false,
+				isWritable: true
 			}, {
 				pubkey: bondVault,
 				isSigner: false,
@@ -1332,27 +1951,18 @@ async function submitSatFinalizeBondUnlock(_config) {
 		}
 	});
 }
-async function submitSatInitBondStakingDistributor(_config, params) {
+async function submitSatSyncBondStakingRewards(_config) {
 	const cfg = loadConfigForSatRuntime(_config);
 	const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
 	assertDedicatedBondProgram(effectiveEnv);
-	const defaultUpdateAuthority = await resolveSatLocalSignerAddress(cfg, effectiveEnv, "local-socket-signer returned no Solana address for SAT bond staking distributor authority");
 	return submitInstruction({
 		cfg,
 		env: effectiveEnv,
-		data: buildInitBondStakingDistributorData({
-			minStakeRaw: params.minStakeRaw,
-			updateAuthority: params.updateAuthority ?? defaultUpdateAuthority
-		}, effectiveEnv),
+		data: buildSyncBondStakingRewardsData(effectiveEnv),
 		programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
 		accountResolver: async (solana, signer) => {
 			const { bondStakingDistributor, bondStakingRewardVault, mint } = resolveSatBondAccounts(solana, signer, effectiveEnv);
 			return [
-				{
-					pubkey: signer,
-					isSigner: true,
-					isWritable: true
-				},
 				{
 					pubkey: bondStakingDistributor,
 					isSigner: false,
@@ -1361,25 +1971,10 @@ async function submitSatInitBondStakingDistributor(_config, params) {
 				{
 					pubkey: bondStakingRewardVault,
 					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: mint,
-					isSigner: false,
-					isWritable: true
-				},
-				{
-					pubkey: solana.SystemProgram.programId,
-					isSigner: false,
-					isWritable: false
-				},
-				{
-					pubkey: new solana.PublicKey(TOKEN_PROGRAM_ID),
-					isSigner: false,
 					isWritable: false
 				},
 				{
-					pubkey: new solana.PublicKey(ASSOCIATED_TOKEN_PROGRAM_ID),
+					pubkey: mint,
 					isSigner: false,
 					isWritable: false
 				}
@@ -1387,30 +1982,45 @@ async function submitSatInitBondStakingDistributor(_config, params) {
 		}
 	});
 }
-async function submitSatSyncBondStakingRewards(_config) {
+async function submitSatSyncBondStakingPosition(_config) {
 	const cfg = loadConfigForSatRuntime(_config);
 	const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
 	assertDedicatedBondProgram(effectiveEnv);
 	return submitInstruction({
 		cfg,
 		env: effectiveEnv,
-		data: buildSyncBondStakingRewardsData(effectiveEnv),
+		data: buildSyncBondStakingPositionData(effectiveEnv),
 		programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
 		accountResolver: async (solana, signer) => {
-			const { bondStakingDistributor, bondStakingRewardVault, mint } = resolveSatBondAccounts(solana, signer, effectiveEnv);
+			const { bondTierPolicy, bondStakingDistributor, bondStakingPosition, bondPosition } = resolveSatBondAccounts(solana, signer, effectiveEnv);
 			return [
+				{
+					pubkey: signer,
+					isSigner: true,
+					isWritable: true
+				},
+				{
+					pubkey: bondTierPolicy,
+					isSigner: false,
+					isWritable: false
+				},
 				{
 					pubkey: bondStakingDistributor,
 					isSigner: false,
 					isWritable: true
 				},
 				{
-					pubkey: bondStakingRewardVault,
+					pubkey: bondStakingPosition,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: bondPosition,
 					isSigner: false,
 					isWritable: false
 				},
 				{
-					pubkey: mint,
+					pubkey: solana.SystemProgram.programId,
 					isSigner: false,
 					isWritable: false
 				}
@@ -1418,17 +2028,17 @@ async function submitSatSyncBondStakingRewards(_config) {
 		}
 	});
 }
-async function submitSatSyncBondStakingPosition(_config) {
+async function submitSatClaimBondStakingRewards(_config) {
 	const cfg = loadConfigForSatRuntime(_config);
 	const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
 	assertDedicatedBondProgram(effectiveEnv);
 	return submitInstruction({
 		cfg,
 		env: effectiveEnv,
-		data: buildSyncBondStakingPositionData(effectiveEnv),
+		data: buildClaimBondStakingRewardsData(effectiveEnv),
 		programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
 		accountResolver: async (solana, signer) => {
-			const { bondTierPolicy, bondStakingDistributor, bondStakingPosition, bondPosition } = resolveSatBondAccounts(solana, signer, effectiveEnv);
+			const { bondTierPolicy, bondStakingDistributor, bondStakingPosition, bondPosition, bondStakingRewardVault, signerTokenAccount, mint } = resolveSatBondAccounts(solana, signer, effectiveEnv);
 			return [
 				{
 					pubkey: signer,
@@ -1455,61 +2065,78 @@ async function submitSatSyncBondStakingPosition(_config) {
 					isSigner: false,
 					isWritable: false
 				},
+				{
+					pubkey: bondStakingRewardVault,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: signerTokenAccount,
+					isSigner: false,
+					isWritable: true
+				},
+				{
+					pubkey: mint,
+					isSigner: false,
+					isWritable: true
+				},
 				{
 					pubkey: solana.SystemProgram.programId,
 					isSigner: false,
 					isWritable: false
+				},
+				{
+					pubkey: new solana.PublicKey(TOKEN_PROGRAM_ID),
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: new solana.PublicKey(ASSOCIATED_TOKEN_PROGRAM_ID),
+					isSigner: false,
+					isWritable: false
 				}
 			];
 		}
 	});
 }
-async function submitSatClaimBondStakingRewards(_config) {
+async function submitSatClaimUnallocatedStakingRewards(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
 	const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
 	assertDedicatedBondProgram(effectiveEnv);
 	return submitInstruction({
 		cfg,
 		env: effectiveEnv,
-		data: buildClaimBondStakingRewardsData(effectiveEnv),
+		data: buildClaimUnallocatedStakingRewardsData(effectiveEnv),
 		programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
 		accountResolver: async (solana, signer) => {
-			const { bondTierPolicy, bondStakingDistributor, bondStakingPosition, bondPosition, bondStakingRewardVault, signerTokenAccount, mint } = resolveSatBondAccounts(solana, signer, effectiveEnv);
+			const { bondStakingDistributor, bondStakingRewardVault, mint } = resolveSatBondAccounts(solana, signer, effectiveEnv);
+			const recipientOwner = new solana.PublicKey(params.recipientOwner);
+			const recipientTokenAccount = deriveAssociatedTokenAddress(solana, recipientOwner, mint);
 			return [
 				{
 					pubkey: signer,
 					isSigner: true,
 					isWritable: true
 				},
-				{
-					pubkey: bondTierPolicy,
-					isSigner: false,
-					isWritable: false
-				},
 				{
 					pubkey: bondStakingDistributor,
 					isSigner: false,
 					isWritable: true
 				},
 				{
-					pubkey: bondStakingPosition,
+					pubkey: bondStakingRewardVault,
 					isSigner: false,
 					isWritable: true
 				},
 				{
-					pubkey: bondPosition,
-					isSigner: false,
-					isWritable: false
-				},
-				{
-					pubkey: bondStakingRewardVault,
+					pubkey: recipientTokenAccount,
 					isSigner: false,
 					isWritable: true
 				},
 				{
-					pubkey: signerTokenAccount,
+					pubkey: recipientOwner,
 					isSigner: false,
-					isWritable: true
+					isWritable: false
 				},
 				{
 					pubkey: mint,
@@ -1535,34 +2162,25 @@ async function submitSatClaimBondStakingRewards(_config) {
 		}
 	});
 }
-async function submitSatCycle(_config, params) {
+async function submitSatCommitCycle(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
+	const commitment = Buffer.from(params.commitmentHex, "hex");
 	return submitInstruction({
 		cfg,
 		env: process.env,
-		data: buildSubmitCycleData(params),
+		data: buildCommitCycleData({
+			cycleId: params.cycleId,
+			commitment
+		}),
 		accountResolver: async (solana, signer) => {
 			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
-			const pageIndex = await resolveSatCycleRegistryPageIndex(_config, params.cycleId);
-			const [satGlobalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_GLOBAL_STATE_SEED)], programId);
 			const [satCycleState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_STATE_SEED), encodeU64(params.cycleId)], programId);
-			const [satCycleRegistryMeta] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_REGISTRY_META_SEED), encodeU64(params.cycleId)], programId);
-			const [satCycleRegistryPage] = solana.PublicKey.findProgramAddressSync([
-				Buffer.from(SAT_CYCLE_REGISTRY_PAGE_SEED),
-				encodeU64(params.cycleId),
-				encodeU64(pageIndex)
-			], programId);
-			const [satCycleSettlementProgress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_cycle_settlement_progress_v2"), encodeU64(params.cycleId)], programId);
 			const [satMinerCycleState] = solana.PublicKey.findProgramAddressSync([
 				Buffer.from(SAT_MINER_CYCLE_STATE_SEED),
 				signer.toBuffer(),
 				encodeU64(params.cycleId)
 			], programId);
 			const [satMinerCapitalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_MINER_CAPITAL_STATE_SEED), signer.toBuffer()], programId);
-			const [satRegistryReserve] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_REGISTRY_RESERVE_SEED)], programId);
-			const [satTreasuryState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_TREASURY_STATE_SEED)], programId);
-			const [satRebateVault] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_REBATE_VAULT_SEED)], programId);
-			const [satTreasuryVault] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_TREASURY_VAULT_SEED)], programId);
 			return [
 				{
 					pubkey: signer,
@@ -1570,27 +2188,112 @@ async function submitSatCycle(_config, params) {
 					isWritable: true
 				},
 				{
-					pubkey: satGlobalState,
+					pubkey: satCycleState,
 					isSigner: false,
 					isWritable: true
 				},
 				{
-					pubkey: satCycleState,
+					pubkey: satMinerCycleState,
 					isSigner: false,
 					isWritable: true
 				},
 				{
-					pubkey: satCycleRegistryMeta,
+					pubkey: satMinerCapitalState,
 					isSigner: false,
 					isWritable: true
 				},
 				{
-					pubkey: satCycleRegistryPage,
+					pubkey: solana.SystemProgram.programId,
+					isSigner: false,
+					isWritable: false
+				}
+			];
+		}
+	});
+}
+async function submitSatCyclePhaseInstruction(_config, params) {
+	const cfg = loadConfigForSatRuntime(_config);
+	return submitInstruction({
+		cfg,
+		env: process.env,
+		data: params.phase === "close" ? buildCloseCommitPhaseData(params) : buildSealCycleEntropyData(params),
+		accountResolver: async (solana, signer) => {
+			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
+			const [satCycleState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_STATE_SEED), encodeU64(params.cycleId)], programId);
+			const accounts = [{
+				pubkey: signer,
+				isSigner: true,
+				isWritable: false
+			}, {
+				pubkey: satCycleState,
+				isSigner: false,
+				isWritable: true
+			}];
+			let intervalStartCycleIdForSigner;
+			if (params.phase === "seal") {
+				const cycle = params.intervalStartCycleId == null ? await inspectSatCycle(_config, { cycleId: params.cycleId }) : null;
+				const intervalStartCycleId = params.intervalStartCycleId ?? cycle?.unlockIntervalStartCycleId;
+				if (intervalStartCycleId == null || !Number.isSafeInteger(intervalStartCycleId)) {
+					throw new Error(`SAT cycle ${params.cycleId} does not expose its unlock interval start`);
+				}
+				intervalStartCycleIdForSigner = intervalStartCycleId;
+				const [satUnlockIntervalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_UNLOCK_INTERVAL_STATE_SEED), encodeU64(intervalStartCycleId)], programId);
+				accounts.push({
+					pubkey: satUnlockIntervalState,
 					isSigner: false,
 					isWritable: true
+				});
+				accounts.push({
+					pubkey: new solana.PublicKey(SLOT_HASHES_SYSVAR_ID),
+					isSigner: false,
+					isWritable: false
+				});
+			}
+			return {
+				keys: accounts,
+				...intervalStartCycleIdForSigner == null ? {} : { context: { intervalStartCycleId: String(intervalStartCycleIdForSigner) } }
+			};
+		}
+	});
+}
+async function submitSatCloseCommitPhase(_config, params) {
+	return submitSatCyclePhaseInstruction(_config, {
+		...params,
+		phase: "close"
+	});
+}
+async function submitSatSealCycleEntropy(_config, params) {
+	return submitSatCyclePhaseInstruction(_config, {
+		...params,
+		phase: "seal"
+	});
+}
+async function submitSatReleaseUnrevealedCommit(_config, params) {
+	const cfg = loadConfigForSatRuntime(_config);
+	return submitInstruction({
+		cfg,
+		env: process.env,
+		data: buildReleaseUnrevealedCommitData(params),
+		accountResolver: async (solana, signer) => {
+			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
+			const minerAuthority = new solana.PublicKey(params.minerAuthority);
+			const [satCycleState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_STATE_SEED), encodeU64(params.cycleId)], programId);
+			const [satMinerCycleState] = solana.PublicKey.findProgramAddressSync([
+				Buffer.from(SAT_MINER_CYCLE_STATE_SEED),
+				minerAuthority.toBuffer(),
+				encodeU64(params.cycleId)
+			], programId);
+			const [satMinerCapitalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_MINER_CAPITAL_STATE_SEED), minerAuthority.toBuffer()], programId);
+			const [satTreasuryState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_TREASURY_STATE_SEED)], programId);
+			const [satTreasuryVault] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_TREASURY_VAULT_SEED)], programId);
+			return [
+				{
+					pubkey: signer,
+					isSigner: true,
+					isWritable: false
 				},
 				{
-					pubkey: satCycleSettlementProgress,
+					pubkey: satCycleState,
 					isSigner: false,
 					isWritable: true
 				},
@@ -1605,27 +2308,42 @@ async function submitSatCycle(_config, params) {
 					isWritable: true
 				},
 				{
-					pubkey: satRegistryReserve,
+					pubkey: satTreasuryState,
 					isSigner: false,
 					isWritable: true
 				},
 				{
-					pubkey: satTreasuryState,
+					pubkey: satTreasuryVault,
 					isSigner: false,
 					isWritable: true
-				},
+				}
+			];
+		}
+	});
+}
+async function submitSatAbortEmptyCycle(_config, params) {
+	const cfg = loadConfigForSatRuntime(_config);
+	return submitInstruction({
+		cfg,
+		env: process.env,
+		data: buildAbortEmptyCycleData(params),
+		accountResolver: async (solana, signer) => {
+			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
+			const [satCycleState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_STATE_SEED), encodeU64(params.cycleId)], programId);
+			const [satCycleRegistryMeta] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_REGISTRY_META_SEED), encodeU64(params.cycleId)], programId);
+			return [
 				{
-					pubkey: solana.SystemProgram.programId,
-					isSigner: false,
+					pubkey: signer,
+					isSigner: true,
 					isWritable: false
 				},
 				{
-					pubkey: satRebateVault,
+					pubkey: satCycleState,
 					isSigner: false,
 					isWritable: true
 				},
 				{
-					pubkey: satTreasuryVault,
+					pubkey: satCycleRegistryMeta,
 					isSigner: false,
 					isWritable: true
 				}
@@ -1633,6 +2351,101 @@ async function submitSatCycle(_config, params) {
 		}
 	});
 }
+async function submitSatRevealCycle(_config, params) {
+	const cfg = loadConfigForSatRuntime(_config);
+	const nonce = Buffer.from(params.nonceBase64, "base64");
+	return submitInstruction({
+		cfg,
+		env: process.env,
+		data: buildRevealCycleData({
+			...params,
+			nonce
+		}),
+		accountResolver: async (solana, signer) => {
+			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
+			const pageIndex = await resolveSatCycleRegistryPageIndex(_config, params.cycleId);
+			const cycle = params.intervalStartCycleId == null ? await inspectSatCycle(_config, { cycleId: params.cycleId }) : null;
+			const intervalStartCycleId = params.intervalStartCycleId ?? cycle?.unlockIntervalStartCycleId;
+			if (intervalStartCycleId == null || !Number.isSafeInteger(intervalStartCycleId)) {
+				throw new Error(`SAT cycle ${params.cycleId} does not expose its unlock interval start`);
+			}
+			const [satCycleState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_STATE_SEED), encodeU64(params.cycleId)], programId);
+			const [satCycleRegistryMeta] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_REGISTRY_META_SEED), encodeU64(params.cycleId)], programId);
+			const [satCycleRegistryPage] = solana.PublicKey.findProgramAddressSync([
+				Buffer.from(SAT_CYCLE_REGISTRY_PAGE_SEED),
+				encodeU64(params.cycleId),
+				encodeU64(pageIndex)
+			], programId);
+			const [satCycleSettlementProgress] = solana.PublicKey.findProgramAddressSync([Buffer.from("sat_cycle_settlement_progress_v2"), encodeU64(params.cycleId)], programId);
+			const [satMinerCycleState] = solana.PublicKey.findProgramAddressSync([
+				Buffer.from(SAT_MINER_CYCLE_STATE_SEED),
+				signer.toBuffer(),
+				encodeU64(params.cycleId)
+			], programId);
+			const [satMinerCapitalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_MINER_CAPITAL_STATE_SEED), signer.toBuffer()], programId);
+			const [satUnlockIntervalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_UNLOCK_INTERVAL_STATE_SEED), encodeU64(intervalStartCycleId)], programId);
+			const [satRegistryReserve] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_REGISTRY_RESERVE_SEED)], programId);
+			return {
+				keys: [
+					{
+						pubkey: signer,
+						isSigner: true,
+						isWritable: true
+					},
+					{
+						pubkey: satCycleState,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satCycleRegistryMeta,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satCycleRegistryPage,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satCycleSettlementProgress,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satMinerCycleState,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satMinerCapitalState,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satUnlockIntervalState,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: satRegistryReserve,
+						isSigner: false,
+						isWritable: true
+					},
+					{
+						pubkey: solana.SystemProgram.programId,
+						isSigner: false,
+						isWritable: false
+					}
+				],
+				context: {
+					intervalStartCycleId: String(intervalStartCycleId),
+					registryPageIndex: String(pageIndex)
+				}
+			};
+		}
+	});
+}
 async function submitSatSettleCyclePage(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
 	return submitInstruction({
@@ -1728,7 +2541,22 @@ async function submitSatSettleCyclePage(_config, params) {
 					isWritable: true
 				});
 			}
-			return accounts;
+			const minerCycleAddresses = params.minerCycleAccounts ?? [];
+			const minerCycles = minerCycleAddresses.length > 0 ? await inspectSatMinerCyclesByAddress(_config, { addresses: minerCycleAddresses }) : [];
+			const minerAuthorities = minerCycles.map((entry, index) => {
+				const authority = String(entry?.authority ?? "").trim();
+				if (!authority) {
+					throw new Error(`SAT settleCyclePage could not resolve miner authority for ${minerCycleAddresses[index]}`);
+				}
+				return authority;
+			});
+			if (minerAuthorities.length !== minerCycleAddresses.length) {
+				throw new Error("SAT settleCyclePage miner authority count mismatch");
+			}
+			return {
+				keys: accounts,
+				...minerAuthorities.length > 0 ? { context: { minerAuthorities } } : {}
+			};
 		}
 	});
 }
@@ -1893,16 +2721,34 @@ async function submitSatScoreCyclePage(_config, params) {
 					isWritable: true
 				});
 			}
-			return accounts;
+			const minerCycleAddresses = params.minerCycleAccounts ?? [];
+			const minerCycles = minerCycleAddresses.length > 0 ? await inspectSatMinerCyclesByAddress(_config, { addresses: minerCycleAddresses }) : [];
+			const minerAuthorities = minerCycles.map((entry, index) => {
+				const authority = String(entry?.authority ?? "").trim();
+				if (!authority) {
+					throw new Error(`SAT scoreCyclePage could not resolve miner authority for ${minerCycleAddresses[index]}`);
+				}
+				return authority;
+			});
+			if (minerAuthorities.length !== minerCycleAddresses.length) {
+				throw new Error("SAT scoreCyclePage miner authority count mismatch");
+			}
+			return {
+				keys: accounts,
+				...minerAuthorities.length > 0 ? { context: { minerAuthorities } } : {}
+			};
 		}
 	});
 }
 async function submitSatDistributeCyclePage(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
+	const lookupTableAddress = params.lookupTableAddress?.trim() ?? "";
+	const requiresLookupTable = (params.minerCycleAccounts?.length ?? 0) >= SAT_DISTRIBUTION_LOOKUP_MIN_MINERS;
 	return submitInstruction({
 		cfg,
 		env: process.env,
 		data: buildDistributeCyclePageData(params),
+		...lookupTableAddress || requiresLookupTable ? { manageAddressLookupTable: { ...lookupTableAddress ? { lookupTableAddress } : {} } } : {},
 		accountResolver: async (solana, signer) => {
 			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
 			const [satCycleState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_STATE_SEED), encodeU64(params.cycleId)], programId);
@@ -1921,6 +2767,7 @@ async function submitSatDistributeCyclePage(_config, params) {
 			], programId);
 			const [satSignerMinerCapitalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_MINER_CAPITAL_STATE_SEED), signer.toBuffer()], programId);
 			const [satRebateVault] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_REBATE_VAULT_SEED)], programId);
+			const [satTreasuryVault] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_TREASURY_VAULT_SEED)], programId);
 			const accounts = [
 				{
 					pubkey: signer,
@@ -1945,7 +2792,7 @@ async function submitSatDistributeCyclePage(_config, params) {
 				{
 					pubkey: satGlobalState,
 					isSigner: false,
-					isWritable: true
+					isWritable: false
 				},
 				{
 					pubkey: satTreasuryState,
@@ -1966,10 +2813,16 @@ async function submitSatDistributeCyclePage(_config, params) {
 					pubkey: satRebateVault,
 					isSigner: false,
 					isWritable: true
+				},
+				{
+					pubkey: satTreasuryVault,
+					isSigner: false,
+					isWritable: true
 				}
 			];
 			const minerCycleAccounts = params.minerCycleAccounts ?? [];
 			const minerCycles = minerCycleAccounts.length > 0 ? await inspectSatMinerCyclesByAddress(_config, { addresses: minerCycleAccounts }).catch(() => []) : [];
+			const minerAuthorities = [];
 			for (const [index, minerCycleAccount] of minerCycleAccounts.entries()) {
 				const satMinerCycleState = new solana.PublicKey(minerCycleAccount);
 				const minerCycle = minerCycles[index] ?? null;
@@ -1977,6 +2830,7 @@ async function submitSatDistributeCyclePage(_config, params) {
 				if (!authorityKey) {
 					throw new Error(`SAT distributeCyclePage could not resolve miner authority for ${minerCycleAccount}`);
 				}
+				minerAuthorities.push(authorityKey.toBase58());
 				const [satMinerCapitalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_MINER_CAPITAL_STATE_SEED), authorityKey.toBuffer()], programId);
 				accounts.push({
 					pubkey: satMinerCycleState,
@@ -1989,10 +2843,41 @@ async function submitSatDistributeCyclePage(_config, params) {
 					isWritable: true
 				});
 			}
-			return accounts;
+			return {
+				keys: accounts,
+				...minerAuthorities.length > 0 ? { context: { minerAuthorities } } : {}
+			};
 		}
 	});
 }
+async function submitSatCleanupDistributionLookupTable(_config, params) {
+	const cfg = loadConfigForSatRuntime(_config);
+	const context = await prepareLocalSignerSubmitContext(cfg, process.env);
+	assertSatLookupTableEnabled(context.effectiveEnv);
+	if (!context.walletId) {
+		throw new Error("typed SAT lookup-table cleanup requires an explicit mining walletId");
+	}
+	const lookupTable = params.lookupTableAddress.trim();
+	if (!lookupTable) {
+		throw new Error("SAT distribution lookup table address is required");
+	}
+	const submitted = await executeTypedSatLookupOperation({
+		context: {
+			...context,
+			walletId: context.walletId
+		},
+		cfg,
+		action: params.action,
+		address: lookupTable
+	});
+	return {
+		lookupTable,
+		action: params.action,
+		transactionHashes: [submitted.signature],
+		signerState: submitted.state,
+		requestId: submitted.requestId
+	};
+}
 async function submitSatClaimCycleRewards(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
 	return submitInstruction({
@@ -2199,27 +3084,6 @@ async function submitSatClaimCycleRewardsBatch(_config, params) {
 		}
 	});
 }
-async function submitSatSetProtocolRecipients(_config, params) {
-	const cfg = loadConfigForSatRuntime(_config);
-	return submitInstruction({
-		cfg,
-		env: process.env,
-		data: buildSetProtocolRecipientsData(params),
-		accountResolver: async (solana, signer) => {
-			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
-			const [satGlobalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_GLOBAL_STATE_SEED)], programId);
-			return [{
-				pubkey: signer,
-				isSigner: true,
-				isWritable: true
-			}, {
-				pubkey: satGlobalState,
-				isSigner: false,
-				isWritable: true
-			}];
-		}
-	});
-}
 async function submitSatClaimProtocolTreasury(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
 	return submitInstruction({
@@ -2355,18 +3219,20 @@ async function submitSatRefillRegistryReserveFromTreasury(_config, params) {
 }
 async function submitSatClaimProtocolDistributorSat(_config, params) {
 	const cfg = loadConfigForSatRuntime(_config);
+	const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
+	assertDedicatedBondProgram(effectiveEnv);
 	return submitInstruction({
 		cfg,
-		env: process.env,
+		env: effectiveEnv,
 		data: buildClaimProtocolDistributorSatData(),
 		accountResolver: async (solana, signer) => {
-			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
+			const programId = new solana.PublicKey(resolveSatProgramIdFromEnv(effectiveEnv));
 			const recipientOwner = new solana.PublicKey(params.recipientOwner);
 			const [satGlobalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_GLOBAL_STATE_SEED)], programId);
 			const [treasury] = solana.PublicKey.findProgramAddressSync([Buffer.from("treasury")], programId);
 			const [satTreasuryState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_TREASURY_STATE_SEED)], programId);
-			const [mintAuthority] = solana.PublicKey.findProgramAddressSync([Buffer.from("authority")], new solana.PublicKey(SAT_MINT_PROGRAM_ID()));
-			const recipientAta = deriveAssociatedTokenAddress(solana, recipientOwner, new solana.PublicKey(SAT_MINT_ADDRESS()));
+			const [mintAuthority] = solana.PublicKey.findProgramAddressSync([Buffer.from("authority")], new solana.PublicKey(resolveSatMintProgramIdFromEnv(effectiveEnv)));
+			const recipientAta = deriveAssociatedTokenAddress(solana, recipientOwner, new solana.PublicKey(resolveSatMintAddressFromEnv(effectiveEnv)));
 			return [
 				{
 					pubkey: signer,
@@ -2399,7 +3265,7 @@ async function submitSatClaimProtocolDistributorSat(_config, params) {
 					isWritable: true
 				},
 				{
-					pubkey: new solana.PublicKey(SAT_MINT_ADDRESS()),
+					pubkey: new solana.PublicKey(resolveSatMintAddressFromEnv(effectiveEnv)),
 					isSigner: false,
 					isWritable: true
 				},
@@ -2424,7 +3290,12 @@ async function submitSatClaimProtocolDistributorSat(_config, params) {
 					isWritable: false
 				},
 				{
-					pubkey: new solana.PublicKey(SAT_MINT_PROGRAM_ID()),
+					pubkey: new solana.PublicKey(resolveSatMintProgramIdFromEnv(effectiveEnv)),
+					isSigner: false,
+					isWritable: false
+				},
+				{
+					pubkey: new solana.PublicKey(resolveSatBondProgramIdFromEnv(effectiveEnv)),
 					isSigner: false,
 					isWritable: false
 				}
@@ -2442,6 +3313,8 @@ async function submitSatRetargetUnlock(_config, params) {
 			const programId = new solana.PublicKey(SAT_PROGRAM_ID());
 			const [satGlobalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_GLOBAL_STATE_SEED)], programId);
 			const [satCycleState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_CYCLE_STATE_SEED), encodeU64(params.cycleId)], programId);
+			const intervalStartCycleId = Math.max(0, params.cycleId + 1 - SAT_PROTOCOL_CONSTANTS.cycleUnlockRetargetIntervalCycles);
+			const [satUnlockIntervalState] = solana.PublicKey.findProgramAddressSync([Buffer.from(SAT_UNLOCK_INTERVAL_STATE_SEED), encodeU64(intervalStartCycleId)], programId);
 			return [
 				{
 					pubkey: signer,
@@ -2457,6 +3330,11 @@ async function submitSatRetargetUnlock(_config, params) {
 					pubkey: satCycleState,
 					isSigner: false,
 					isWritable: false
+				},
+				{
+					pubkey: satUnlockIntervalState,
+					isSigner: false,
+					isWritable: true
 				}
 			];
 		}
@@ -2677,10 +3555,16 @@ async function submitSatCompactPendingCycleRange(_config, params) {
 					isWritable: false
 				});
 			}
-			return accounts;
+			return {
+				keys: accounts,
+				context: {
+					frontCycleIds: params.frontCycleIds.map(String),
+					backCycleIds: params.backCycleIds.map(String)
+				}
+			};
 		}
 	});
 }
 
 //#endregion
-export { submitSatCancelBondUnlock, submitSatClaimBondStakingRewards, submitSatFinalizeBondUnlock, submitSatIncreaseBondPosition, submitSatInitBondStakingDistributor, submitSatOpenBondPosition, submitSatRequestBondUnlock, submitSatSyncBondStakingPosition, submitSatSyncBondStakingRewards };
+export { runWithSatSubmissionWorkflow, submitSatCancelBondUnlock, submitSatClaimBondStakingRewards, submitSatFinalizeBondUnlock, submitSatIncreaseBondPosition, submitSatOpenBondPosition, submitSatRequestBondUnlock, submitSatSyncBondStakingPosition, submitSatSyncBondStakingRewards };