@fased/fased 0.1.62 → 0.1.65

package/extensions/sat-mining/src/solana-submit.ts

@@ -1,7 +1,11 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
 import { createRequire } from "node:module";
+import { isDeepStrictEqual } from "node:util";
 import {
   callLocalSocketSigner,
-  enforceWalletCustodyForAutonomousSend,
+  createSignerReviewApprovalRequest,
+  LEGACY_EMBEDDED_KEYSTORE_MIGRATION_MESSAGE,
   loadConfig,
   readWalletProviderRegistry,
   requireLocalSocketSignerPath,
@@ -12,14 +16,32 @@ import {
   resolveWalletProviderId,
   resolveWalletRuntimeConfig,
   type FasedAgentConfig,
+  type WalletProviderJupiterReviewV2,
 } from "fased/plugin-sdk/sat-runtime";
 import type { SatMiningConfig } from "./config.js";
 import { decodeHash32 } from "./hash-spec.js";
 import {
+  resolveSatGenesisProfileContract,
   SAT_BOND_INSTRUCTION_DISCRIMINATORS,
   SAT_INSTRUCTION_DISCRIMINATORS,
+  SAT_PROTOCOL_CONSTANTS,
 } from "./protocol-contract.js";
-import { inspectSatCycleRegistryMeta, inspectSatMinerCyclesByAddress } from "./rpc-read.js";
+import {
+  inspectSatAddressLookupTable,
+  inspectSatChainSlot,
+  inspectSatCycle,
+  inspectSatCycleRegistryMeta,
+  inspectSatMinerCyclesByAddress,
+} from "./rpc-read.js";
+import { resolveSatSignerCodec, type SatSignerAction } from "./signer-codec-manifest.js";
+import {
+  buildSatSubmissionOperationKey,
+  claimSatSubmission,
+  digestSatSubmissionIntent,
+  updateSatSubmission,
+  waitForSatSubmissionLease,
+  type SatSubmissionSignerState,
+} from "./submission-ledger.js";
 
 const require = createRequire(import.meta.url);
 
@@ -47,16 +69,46 @@ 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<SatSignerAction>([
+  "updateBondTierPolicy",
+  "openBondPosition",
+  "increaseBondPosition",
+  "requestBondUnlock",
+  "cancelBondUnlock",
+  "finalizeBondUnlock",
+  "syncBondStakingRewards",
+  "syncBondStakingPosition",
+  "claimBondStakingRewards",
+  "claimUnallocatedStakingRewards",
+]);
+
+const satSubmissionWorkflowStorage = new AsyncLocalStorage<string>();
+
+export async function runWithSatSubmissionWorkflow<T>(
+  workflowId: string,
+  task: () => Promise<T>,
+): Promise<T> {
+  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: string) {
   if (String(process.env.FASED_SAT_SUBMIT_DEBUG ?? "").trim() === "1") {
     console.error(message);
@@ -71,6 +123,21 @@ type SolanaAccountMeta = {
   isWritable: boolean;
 };
 
+type SatSignerSemanticContext = {
+  targetAuthority?: string;
+  disputeAuthority?: string;
+  intervalStartCycleId?: string;
+  registryPageIndex?: string;
+  minerAuthorities?: string[];
+  frontCycleIds?: string[];
+  backCycleIds?: string[];
+};
+
+type SatResolvedInstruction = {
+  keys: SolanaAccountMeta[];
+  context?: SatSignerSemanticContext;
+};
+
 let solanaModulePromise: Promise<SolanaModuleLike> | null = null;
 
 async function loadSolanaWeb3(): Promise<SolanaModuleLike> {
@@ -115,6 +182,11 @@ function resolveSatWalletId(cfg: FasedAgentConfig): string | undefined {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 
+function resolveSatCluster(cfg: FasedAgentConfig): "local" | "devnet" | "mainnet-beta" {
+  const value = cfg.plugins?.entries?.["sat-mining"]?.config?.network;
+  return value === "local" || value === "mainnet-beta" || value === "devnet" ? value : "devnet";
+}
+
 function resolveSatEffectiveEnv(cfg: FasedAgentConfig, env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
   return {
     ...env,
@@ -125,92 +197,58 @@ function resolveSatEffectiveEnv(cfg: FasedAgentConfig, env: NodeJS.ProcessEnv):
 function resolveSatProviderId(cfg: FasedAgentConfig, env: NodeJS.ProcessEnv): string {
   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,
+    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;
-      }
-      if (hasSelfHostedSignerMaterial) {
-        return "local-socket-signer";
-      }
-      if (wallet?.providerId) {
-        return wallet.providerId;
-      }
-    } catch {}
-    if (hasSelfHostedSignerMaterial) {
-      return "local-socket-signer";
+    }
+    if (wallet?.providerId === "local-socket-signer") {
+      return wallet.providerId;
     }
   }
-  return resolveWalletProviderId(cfg, effectiveEnv);
-}
-
-async function enforceSatCustodyAutonomousSigning(
-  cfg: FasedAgentConfig,
-  env: NodeJS.ProcessEnv,
-): Promise<void> {
-  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);
-  }
-}
-
-function resolveSatRegistrySolanaAddress(cfg: FasedAgentConfig, env: NodeJS.ProcessEnv): string {
-  const effectiveEnv = resolveSatEffectiveEnv(cfg, env);
-  const walletId = resolveSatWalletId(cfg);
-  if (!walletId) {
-    return "";
+  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.",
+    );
   }
-  const wallet = readWalletProviderRegistry(effectiveEnv).wallets.find(
-    (entry) => entry.id === walletId,
-  );
-  return typeof wallet?.addresses?.solana === "string" ? wallet.addresses.solana.trim() : "";
+  return providerId;
 }
 
 async function resolveSatLocalSignerAddress(
   cfg: FasedAgentConfig,
   env: NodeJS.ProcessEnv,
   errorMessage: string,
+  verifyCapabilities = true,
 ): Promise<string> {
   const effectiveEnv = resolveSatEffectiveEnv(cfg, env);
   const walletId = resolveSatWalletId(cfg);
-  const result = await callLocalSocketSigner<{ solana?: string }>(
-    requireLocalSocketSignerPath(effectiveEnv),
-    {
-      op: "getAddresses",
-      ...(walletId ? { walletId } : {}),
-    },
-  );
-  const signer = String(result.solana ?? "").trim();
+  if (!walletId) {
+    throw new Error("SAT mining local signer address lookup requires an attached walletId");
+  }
+  const socketPath = requireLocalSocketSignerPath(effectiveEnv);
+  if (verifyCapabilities) {
+    await requireTypedSatSignerCapabilities(socketPath, "solana.satAction");
+  }
+  const result = await callLocalSocketSigner<{ publicKey?: string }>(socketPath, {
+    op: "v2.wallet.get",
+    walletId,
+  });
+  const signer = String(result.publicKey ?? "").trim();
   if (signer) {
     return signer;
   }
-  const fallback = resolveSatRegistrySolanaAddress(cfg, env);
-  if (fallback) {
-    return fallback;
-  }
   throw new Error(errorMessage);
 }
 
@@ -275,7 +313,6 @@ function assertDedicatedBondProgram(env: NodeJS.ProcessEnv): void {
 export async function resolveSatValidatorAuthority(_config: SatMiningConfig) {
   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",
@@ -291,10 +328,25 @@ export async function resolveSatValidatorAuthority(_config: SatMiningConfig) {
 type SatInstructionSubmitSpec = {
   data: Buffer;
   programId?: string;
+  addressLookupTables?: string[];
+  manageAddressLookupTable?: { lookupTableAddress?: string };
   accountResolver: (
     solana: SolanaModuleLike,
     signer: import("@solana/web3.js").PublicKey,
-  ) => Promise<SolanaAccountMeta[]>;
+  ) => Promise<SolanaAccountMeta[] | SatResolvedInstruction>;
+};
+
+type SatInstructionSubmitResult = {
+  txHash: string;
+  signer: string;
+  signerState: SatSignerOperation["state"];
+  requestId: string;
+  transactionVersion: "legacy" | "v0";
+  lookupTableAddress?: string;
+  lookupTableCreated?: boolean;
+  lookupTableExtended?: boolean;
+  lookupTableAddressCount?: number;
+  lookupTableTransactionHashes?: string[];
 };
 
 async function prepareLocalSignerSubmitContext(cfg: FasedAgentConfig, env: NodeJS.ProcessEnv) {
@@ -306,6 +358,7 @@ async function prepareLocalSignerSubmitContext(cfg: FasedAgentConfig, env: NodeJ
     cfg,
     effectiveEnv,
     "local-socket-signer returned no Solana address for SAT mining wallet",
+    false,
   );
   const signer = new solana.PublicKey(signerAddress);
   return { effectiveEnv, solana, walletId, socketPath, signerAddress, signer };
@@ -314,22 +367,753 @@ async function prepareLocalSignerSubmitContext(cfg: FasedAgentConfig, env: NodeJ
 async function buildLocalSignerInstructionRequest(params: {
   solana: SolanaModuleLike;
   signer: import("@solana/web3.js").PublicKey;
-  walletId?: string;
+  env: NodeJS.ProcessEnv;
   spec: SatInstructionSubmitSpec;
 }) {
-  const keys = await params.spec.accountResolver(params.solana, params.signer);
+  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] data_len=${params.spec.data.length} disc=${params.spec.data[0] ?? -1} keys=${keys.length}`,
+    `[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 } : {}),
+  };
+}
+
+type SatSignerOperation = {
+  requestId: string;
+  state: "reserved" | "broadcast" | "confirmed" | "failed" | "unknown";
+  signature?: string;
+  error?: string;
+};
+
+const REQUIRED_SAT_SIGNER_FEATURES = [
+  "failClosedPolicies",
+  "policyHashes",
+  "durableCaps",
+  "atomicIdempotency",
+  "ambiguousBroadcastReconciliation",
+  "signerOwnedKeys",
+  "typedSolanaTransactions",
+  "typedSATActions",
+] as const;
+
+async function requireTypedSatSignerCapabilities(
+  socketPath: string,
+  intentType: "solana.satAction" | "solana.satLookupTable" | "solana.vaultBondAction",
+) {
+  const result = await callLocalSocketSigner<{
+    ready?: boolean;
+    capabilities?: {
+      protocol?: { current?: number; min?: number; max?: number };
+      intentTypes?: string[];
+      operationStates?: string[];
+      features?: string[];
+    };
+  }>(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: {
+  socketPath: string;
+  walletId: string;
+  requestId: string;
+  operation?: SatSignerOperation;
+}) {
+  let operation =
+    params.operation ??
+    (await callLocalSocketSigner<SatSignerOperation>(params.socketPath, {
+      op: "v2.operation.get",
+      walletId: params.walletId,
+      request: { requestId: params.requestId },
+    }));
+  if (operation.state === "broadcast" || operation.state === "unknown") {
+    try {
+      operation = await callLocalSocketSigner<SatSignerOperation>(params.socketPath, {
+        op: "v2.operation.reconcile",
+        walletId: params.walletId,
+        request: { requestId: params.requestId },
+      });
+    } catch {
+      // The durable signature and ambiguous state remain authoritative. Never
+      // replace this with a second request ID or another broadcast attempt.
+    }
+  }
+  return operation;
+}
+
+function assertSatSignerOperationIdentity(
+  operation: SatSignerOperation,
+  requestId: string,
+): SatSignerOperation {
+  if (operation.requestId !== requestId) {
+    throw new Error(
+      `SAT signer returned request ${operation.requestId || "<empty>"} while reconciling ${requestId}`,
+    );
+  }
+  return operation;
+}
+
+function signerStateForLedger(state: SatSignerOperation["state"]): SatSubmissionSignerState {
+  return state;
+}
+
+type SatLookupTableAction = "create" | "extend" | "deactivate" | "close";
+
+function assertSatLookupTableAction(value: string): asserts value is SatLookupTableAction {
+  if (value !== "create" && value !== "extend" && value !== "deactivate" && value !== "close") {
+    throw new Error(`unsupported SAT lookup-table action ${value}`);
+  }
+}
+
+class SatSubmissionUnresolvedError extends Error {
+  readonly requestId: string;
+  readonly signature?: string;
+
+  constructor(params: { requestId: string; state: string; signature?: string; detail?: string }) {
+    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: {
+  socketPath: string;
+  walletId: string;
+  action: SatSignerAction | "cleanupBatch" | "create" | "extend" | "deactivate" | "close";
+  instruction?: Awaited<ReturnType<typeof buildLocalSignerInstructionRequest>>;
+  instructions?: Array<Awaited<ReturnType<typeof buildLocalSignerInstructionRequest>>>;
+  lookupTable?: { address: string; recentSlot?: string; addresses?: string[] };
+  cluster: "local" | "devnet" | "mainnet-beta";
+  env: NodeJS.ProcessEnv;
+}) {
+  const isLookupTable = params.lookupTable != null;
+  const isVaultBond =
+    !isLookupTable &&
+    params.action !== "cleanupBatch" &&
+    VAULT_BOND_ACTIONS.has(params.action as SatSignerAction);
+  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" as const,
+          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" as const,
+            cluster: params.cluster,
+            ...params.instruction,
+          };
+        })()
+      : {
+          type: "solana.satAction" as const,
+          action: params.action,
+          ...(params.instruction ?? {}),
+          ...(params.instructions ? { instructions: params.instructions } : {}),
+        };
+  const policy = await callLocalSocketSigner<{ hash: string }>(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: SatSignerOperation | undefined;
+  if (intent.type === "solana.vaultBondAction") {
+    let reviewWasSigned = false;
+    try {
+      let review: WalletProviderJupiterReviewV2;
+      try {
+        review = await callLocalSocketSigner<WalletProviderJupiterReviewV2>(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<WalletProviderJupiterReviewV2>(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 (): Promise<SatSignerOperation> => {
+    try {
+      return await callLocalSocketSigner<SatSignerOperation>(params.socketPath, {
+        op: "v2.execute",
+        walletId: params.walletId,
+        request: {
+          requestId,
+          policyHash: policy.hash,
+          intent,
+        },
+      });
+    } catch (executeError) {
+      try {
+        return await callLocalSocketSigner<SatSignerOperation>(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: SatSignerOperation;
+  if (resumedReviewedOperation) {
+    operation = resumedReviewedOperation;
+  } else if (!claim.created) {
+    const callerStateWasAmbiguous =
+      claim.record.state === "broadcast" || claim.record.state === "unknown";
+    try {
+      operation = assertSatSignerOperationIdentity(
+        await callLocalSocketSigner<SatSignerOperation>(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 };
+}
+
+type SatLookupSubmitContext = Awaited<ReturnType<typeof prepareLocalSignerSubmitContext>> & {
+  walletId: string;
+};
+
+function assertSatLookupTableEnabled(env: NodeJS.ProcessEnv): void {
+  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: {
+  context: SatLookupSubmitContext;
+  cfg: FasedAgentConfig;
+  action: "create" | "extend" | "deactivate" | "close";
+  address: string;
+  recentSlot?: number;
+  addresses?: string[];
+}) {
+  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: {
+  config: SatMiningConfig;
+  address: string;
+  authority: string;
+}) {
+  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: {
+  config: SatMiningConfig;
+  address: string;
+  authority: string;
+  requireNextSlot: boolean;
+}) {
+  let lastError: unknown;
+  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: {
+  context: SatLookupSubmitContext;
+  cfg: FasedAgentConfig;
+  config: SatMiningConfig;
+  lookupTableAddress?: string;
+  addresses: string[];
+}) {
+  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: string[] = [];
+  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,
   };
 }
 
@@ -338,39 +1122,67 @@ async function submitInstructionViaLocalSigner(
     cfg: FasedAgentConfig;
     env: NodeJS.ProcessEnv;
   } & SatInstructionSubmitSpec,
-) {
+): Promise<SatInstructionSubmitResult> {
   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<{ txHash: string; signer?: string }>(
-    context.socketPath,
-    {
-      op: "sendSolanaInstruction",
-      request,
-    },
-  );
+  if (!context.walletId) {
+    throw new Error("typed SAT signing requires an explicit mining walletId");
+  }
+  let managedLookupTable: Awaited<ReturnType<typeof ensureSatDistributionLookupTable>> | undefined;
+  if (params.manageAddressLookupTable) {
+    managedLookupTable = await ensureSatDistributionLookupTable({
+      context: { ...context, walletId: context.walletId },
+      cfg: params.cfg,
+      config: params.cfg as unknown as SatMiningConfig,
+      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" as const,
+          lookupTableAddress: request.addressLookupTables[0],
+        }
+      : { transactionVersion: "legacy" as const }),
+    ...(managedLookupTable
+      ? {
+          lookupTableCreated: managedLookupTable.created,
+          lookupTableExtended: managedLookupTable.extended,
+          lookupTableAddressCount: managedLookupTable.addressCount,
+          lookupTableTransactionHashes: managedLookupTable.transactionHashes,
+        }
+      : {}),
   };
 }
 
-async function submitInstruction(params: {
-  cfg: FasedAgentConfig;
-  env: NodeJS.ProcessEnv;
-  data: Buffer;
-  programId?: string;
-  accountResolver: (
-    solana: SolanaModuleLike,
-    signer: import("@solana/web3.js").PublicKey,
-  ) => Promise<import("@solana/web3.js").AccountMeta[]>;
-}) {
+async function submitInstruction(
+  params: {
+    cfg: FasedAgentConfig;
+    env: NodeJS.ProcessEnv;
+  } & SatInstructionSubmitSpec,
+) {
   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");
   }
@@ -379,6 +1191,8 @@ async function submitInstruction(params: {
     env: effectiveEnv,
     data: params.data,
     programId: params.programId,
+    addressLookupTables: params.addressLookupTables,
+    manageAddressLookupTable: params.manageAddressLookupTable,
     accountResolver: params.accountResolver,
   });
 }
@@ -396,7 +1210,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",
@@ -409,26 +1222,27 @@ async function submitInstructionBatch(params: {
       await buildLocalSignerInstructionRequest({
         solana: context.solana,
         signer: context.signer,
-        walletId: context.walletId,
+        env: context.effectiveEnv,
         spec,
       }),
     );
   }
-  const submitted = await callLocalSocketSigner<{
-    txHash: string;
-    signer?: string;
-    metadata?: Record<string, unknown>;
-  }>(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,
   };
 }
@@ -568,11 +1382,10 @@ function buildMiningCrankData() {
   return Buffer.from([IX.miningCrank]);
 }
 
-function buildBootstrapData(params: { authority: string; initialStake: number }) {
+function buildTopUpRegistryReserveData(params: { targetBalanceLamports: number }) {
   return Buffer.concat([
-    Buffer.from([IX.bootstrap]),
-    encodePubkey(params.authority),
-    encodeU64(params.initialStake),
+    Buffer.from([IX.topUpRegistryReserve]),
+    encodeU64(params.targetBalanceLamports),
   ]);
 }
 
@@ -596,23 +1409,6 @@ function buildSetActiveCommitData(params: { lamports: number }) {
   return Buffer.concat([Buffer.from([IX.setActiveCommit]), encodeU64(params.lamports)]);
 }
 
-function buildInitBondTierPolicyData(params: {
-  updateAuthority: string;
-  basicMinRaw: number;
-  operatorMinRaw: number;
-  unlockDelaySlots: number;
-  scheduledEffectiveSlot?: number;
-}) {
-  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: {
   updateAuthority: string;
   basicMinRaw: number;
@@ -661,18 +1457,6 @@ function buildFinalizeBondUnlockData(env: NodeJS.ProcessEnv = process.env) {
   return Buffer.from([BOND_IX.finalizeBondUnlock]);
 }
 
-function buildInitBondStakingDistributorData(
-  params: { updateAuthority: string; minStakeRaw: number },
-  env: NodeJS.ProcessEnv = process.env,
-) {
-  assertDedicatedBondProgram(env);
-  return Buffer.concat([
-    Buffer.from([BOND_IX.initStakingDistributor]),
-    encodePubkey(params.updateAuthority),
-    encodeU64(params.minStakeRaw),
-  ]);
-}
-
 function buildSyncBondStakingRewardsData(env: NodeJS.ProcessEnv = process.env) {
   assertDedicatedBondProgram(env);
   return Buffer.from([BOND_IX.syncStakingRewards]);
@@ -688,26 +1472,96 @@ function buildClaimBondStakingRewardsData(env: NodeJS.ProcessEnv = process.env)
   return Buffer.from([BOND_IX.claimStakingRewards]);
 }
 
-function buildSubmitCycleData(params: { cycleId: number; allocationFp: number[] }) {
-  if (params.allocationFp.length !== 25) {
-    throw new Error(`expected 25 allocation buckets, got ${params.allocationFp.length}`);
+function buildClaimUnallocatedStakingRewardsData(env: NodeJS.ProcessEnv = process.env) {
+  assertDedicatedBondProgram(env);
+  return Buffer.from([BOND_IX.claimUnallocatedStakingRewards]);
+}
+
+function encodeAllocationFp(allocationFp: number[]): Buffer {
+  if (allocationFp.length !== 25) {
+    throw new Error(`expected 25 allocation buckets, got ${allocationFp.length}`);
   }
-  const body = Buffer.concat([
-    Buffer.from([IX.submitCycle]),
-    encodeU64(params.cycleId),
-    Buffer.concat(
-      params.allocationFp.map((value) => {
-        const out = Buffer.alloc(4);
-        out.writeUInt32LE(value);
-        return out;
-      }),
-    ),
+  return Buffer.concat(
+    allocationFp.map((value) => {
+      if (!Number.isSafeInteger(value) || value < 0 || value > 0xffff_ffff) {
+        throw new Error(`invalid allocation bucket value: ${value}`);
+      }
+      const out = Buffer.alloc(4);
+      out.writeUInt32LE(value);
+      return out;
+    }),
+  );
+}
+
+export function buildSatCycleCommitment(params: {
+  authority: string;
+  cycleId: number;
+  committedLamports: number;
+  nonce: Buffer;
+  allocationFp: number[];
+  programId?: string;
+}): Buffer {
+  if (params.nonce.length !== 32) {
+    throw new Error(`expected 32-byte cycle nonce, got ${params.nonce.length}`);
+  }
+  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),
+        encodeU64(params.committedLamports),
+        params.nonce,
+        allocation,
+      ]),
+    )
+    .digest();
+}
+
+function buildCommitCycleData(params: { cycleId: number; commitment: Buffer }) {
+  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: { cycleId: number }) {
+  return Buffer.concat([Buffer.from([IX.closeCommitPhase]), encodeU64(params.cycleId)]);
+}
+
+function buildSealCycleEntropyData(params: { cycleId: number }) {
+  return Buffer.concat([Buffer.from([IX.sealCycleEntropy]), encodeU64(params.cycleId)]);
+}
+
+function buildRevealCycleData(params: { cycleId: number; nonce: Buffer; allocationFp: number[] }) {
+  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: { cycleId: number; minerAuthority: string }) {
+  return Buffer.concat([
+    Buffer.from([IX.releaseUnrevealedCommit]),
+    encodeU64(params.cycleId),
+    encodePubkey(params.minerAuthority),
+  ]);
+}
+
+function buildAbortEmptyCycleData(params: { cycleId: number }) {
+  return Buffer.concat([Buffer.from([IX.abortEmptyCycle]), encodeU64(params.cycleId)]);
 }
 
 function buildClaimCycleRewardsData(params: { cycleId: number }) {
@@ -728,17 +1582,6 @@ function buildClaimCycleRewardsBatchData(params: { cycleIds: number[] }) {
   ]);
 }
 
-function buildSetProtocolRecipientsData(params: {
-  treasuryRecipient: string;
-  distributorRecipient: string;
-}) {
-  return Buffer.concat([
-    Buffer.from([IX.setProtocolRecipients]),
-    encodePubkey(params.treasuryRecipient),
-    encodePubkey(params.distributorRecipient),
-  ]);
-}
-
 function buildClaimProtocolTreasuryData() {
   return Buffer.from([IX.claimProtocolTreasury]);
 }
@@ -924,13 +1767,16 @@ export async function submitSatValidatorAttestation(
         [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() },
+      };
     },
   });
 }
@@ -967,13 +1813,16 @@ export async function submitSatOpenDispute(
         [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() },
+      };
     },
   });
 }
@@ -1009,12 +1858,15 @@ export async function submitSatResolveDispute(
         ],
         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() },
+      };
     },
   });
 }
@@ -1047,53 +1899,37 @@ export async function submitSatRepublishEpochRoots(
   });
 }
 
-export async function submitSatBootstrap(
+export async function submitSatTopUpRegistryReserve(
   _config: SatMiningConfig,
-  params: { authority?: string; initialStake?: number } = {},
+  params: { targetBalanceLamports: number },
 ) {
   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, isWritable: true },
         { pubkey: solana.SystemProgram.programId, isSigner: false, isWritable: false },
-        { pubkey: satRebateVault, isSigner: false, isWritable: true },
-        { pubkey: satTreasuryVault, isSigner: false, isWritable: true },
       ];
     },
   });
@@ -1150,15 +1986,23 @@ export async function submitSatInitMinerCapital(
   params: { authority?: string },
 ) {
   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 authorityKey = new solana.PublicKey(authority);
       const [satMinerCapitalState] = solana.PublicKey.findProgramAddressSync(
-        [Buffer.from(SAT_MINER_CAPITAL_STATE_SEED), authority.toBuffer()],
+        [Buffer.from(SAT_MINER_CAPITAL_STATE_SEED), authorityKey.toBuffer()],
         programId,
       );
       return [
@@ -1281,47 +2125,6 @@ function resolveSatBondAccounts(
   };
 }
 
-export async function submitSatInitBondTierPolicy(
-  _config: SatMiningConfig,
-  params: {
-    updateAuthority?: string;
-    basicMinRaw: number;
-    operatorMinRaw: number;
-    unlockDelaySlots: number;
-    scheduledEffectiveSlot?: number;
-  },
-) {
-  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 },
-      ];
-    },
-  });
-}
-
 export async function submitSatUpdateBondTierPolicy(
   _config: SatMiningConfig,
   params: {
@@ -1337,13 +2140,11 @@ export async function submitSatUpdateBondTierPolicy(
   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,
@@ -1446,12 +2247,17 @@ export async function submitSatRequestBondUnlock(_config: SatMiningConfig) {
     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, isWritable: true },
         { pubkey: bondTierPolicy, isSigner: false, isWritable: false },
       ];
-      accounts.push({ pubkey: bondPosition, isSigner: false, isWritable: true });
+      accounts.push(
+        { pubkey: bondPosition, isSigner: false, isWritable: true },
+        { pubkey: bondStakingDistributor, isSigner: false, isWritable: true },
+        { pubkey: bondStakingPosition, isSigner: false, isWritable: true },
+      );
       return accounts;
     },
   });
@@ -1467,12 +2273,17 @@ export async function submitSatCancelBondUnlock(_config: SatMiningConfig) {
     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, isWritable: true },
         { pubkey: bondTierPolicy, isSigner: false, isWritable: false },
       ];
-      accounts.push({ pubkey: bondPosition, isSigner: false, isWritable: true });
+      accounts.push(
+        { pubkey: bondPosition, isSigner: false, isWritable: true },
+        { pubkey: bondStakingDistributor, isSigner: false, isWritable: true },
+        { pubkey: bondStakingPosition, isSigner: false, isWritable: true },
+      );
       return accounts;
     },
   });
@@ -1488,14 +2299,23 @@ export async function submitSatFinalizeBondUnlock(_config: SatMiningConfig) {
     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, isWritable: true },
         { pubkey: bondTierPolicy, isSigner: false, isWritable: false },
       ];
       accounts.push(
         { pubkey: bondPosition, isSigner: false, isWritable: true },
+        { pubkey: bondStakingDistributor, isSigner: false, isWritable: true },
+        { pubkey: bondStakingPosition, isSigner: false, isWritable: true },
         { pubkey: bondVault, isSigner: false, isWritable: true },
         { pubkey: signerTokenAccount, isSigner: false, isWritable: true },
         { pubkey: mint, isSigner: false, isWritable: true },
@@ -1512,28 +2332,105 @@ export async function submitSatFinalizeBondUnlock(_config: SatMiningConfig) {
   });
 }
 
-export async function submitSatInitBondStakingDistributor(
+export async function submitSatSyncBondStakingRewards(_config: SatMiningConfig) {
+  const cfg = loadConfigForSatRuntime(_config);
+  const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
+  assertDedicatedBondProgram(effectiveEnv);
+  return submitInstruction({
+    cfg,
+    env: effectiveEnv,
+    data: buildSyncBondStakingRewardsData(effectiveEnv),
+    programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
+    accountResolver: async (solana, signer) => {
+      const { bondStakingDistributor, bondStakingRewardVault, mint } = resolveSatBondAccounts(
+        solana,
+        signer,
+        effectiveEnv,
+      );
+      return [
+        { pubkey: bondStakingDistributor, isSigner: false, isWritable: true },
+        { pubkey: bondStakingRewardVault, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: false },
+      ];
+    },
+  });
+}
+
+export async function submitSatSyncBondStakingPosition(_config: SatMiningConfig) {
+  const cfg = loadConfigForSatRuntime(_config);
+  const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
+  assertDedicatedBondProgram(effectiveEnv);
+  return submitInstruction({
+    cfg,
+    env: effectiveEnv,
+    data: buildSyncBondStakingPositionData(effectiveEnv),
+    programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
+    accountResolver: async (solana, signer) => {
+      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: bondStakingPosition, isSigner: false, isWritable: true },
+        { pubkey: bondPosition, isSigner: false, isWritable: false },
+        { pubkey: solana.SystemProgram.programId, isSigner: false, isWritable: false },
+      ];
+    },
+  });
+}
+
+export async function submitSatClaimBondStakingRewards(_config: SatMiningConfig) {
+  const cfg = loadConfigForSatRuntime(_config);
+  const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
+  assertDedicatedBondProgram(effectiveEnv);
+  return submitInstruction({
+    cfg,
+    env: effectiveEnv,
+    data: buildClaimBondStakingRewardsData(effectiveEnv),
+    programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
+    accountResolver: async (solana, signer) => {
+      const {
+        bondTierPolicy,
+        bondStakingDistributor,
+        bondStakingPosition,
+        bondPosition,
+        bondStakingRewardVault,
+        signerTokenAccount,
+        mint,
+      } = resolveSatBondAccounts(solana, signer, effectiveEnv);
+      return [
+        { pubkey: signer, isSigner: true, isWritable: true },
+        { pubkey: bondTierPolicy, isSigner: false, isWritable: false },
+        { pubkey: bondStakingDistributor, isSigner: false, isWritable: true },
+        { pubkey: bondStakingPosition, isSigner: false, isWritable: true },
+        { pubkey: bondPosition, 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,
+        },
+      ];
+    },
+  });
+}
+
+export async function submitSatClaimUnallocatedStakingRewards(
   _config: SatMiningConfig,
-  params: { minStakeRaw: number; updateAuthority?: string },
+  params: { recipientOwner: string },
 ) {
   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: buildClaimUnallocatedStakingRewardsData(effectiveEnv),
     programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
     accountResolver: async (solana, signer) => {
       const { bondStakingDistributor, bondStakingRewardVault, mint } = resolveSatBondAccounts(
@@ -1541,10 +2438,14 @@ export async function submitSatInitBondStakingDistributor(
         signer,
         effectiveEnv,
       );
+      const recipientOwner = new solana.PublicKey(params.recipientOwner);
+      const recipientTokenAccount = deriveAssociatedTokenAddress(solana, recipientOwner, mint);
       return [
         { pubkey: signer, isSigner: true, isWritable: true },
         { pubkey: bondStakingDistributor, isSigner: false, isWritable: true },
         { pubkey: bondStakingRewardVault, isSigner: false, isWritable: true },
+        { pubkey: recipientTokenAccount, isSigner: false, isWritable: true },
+        { pubkey: recipientOwner, isSigner: false, isWritable: false },
         { 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 },
@@ -1552,116 +2453,222 @@ export async function submitSatInitBondStakingDistributor(
           pubkey: new solana.PublicKey(ASSOCIATED_TOKEN_PROGRAM_ID),
           isSigner: false,
           isWritable: false,
-        },
-      ];
+        },
+      ];
+    },
+  });
+}
+
+export async function submitSatCommitCycle(
+  _config: SatMiningConfig,
+  params: { cycleId: number; commitmentHex: string },
+) {
+  const cfg = loadConfigForSatRuntime(_config);
+  const commitment = Buffer.from(params.commitmentHex, "hex");
+  return submitInstruction({
+    cfg,
+    env: process.env,
+    data: buildCommitCycleData({ cycleId: params.cycleId, commitment }),
+    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 [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,
+      );
+      return [
+        { pubkey: signer, isSigner: true, isWritable: true },
+        { pubkey: satCycleState, isSigner: false, isWritable: true },
+        { pubkey: satMinerCycleState, isSigner: false, isWritable: true },
+        { pubkey: satMinerCapitalState, isSigner: false, isWritable: true },
+        { pubkey: solana.SystemProgram.programId, isSigner: false, isWritable: false },
+      ];
+    },
+  });
+}
+
+async function submitSatCyclePhaseInstruction(
+  _config: SatMiningConfig,
+  params: { cycleId: number; phase: "close" | "seal"; intervalStartCycleId?: number },
+) {
+  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: number | undefined;
+      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) } }),
+      };
     },
   });
 }
 
-export async function submitSatSyncBondStakingRewards(_config: SatMiningConfig) {
-  const cfg = loadConfigForSatRuntime(_config);
-  const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
-  assertDedicatedBondProgram(effectiveEnv);
-  return submitInstruction({
-    cfg,
-    env: effectiveEnv,
-    data: buildSyncBondStakingRewardsData(effectiveEnv),
-    programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
-    accountResolver: async (solana, signer) => {
-      const { bondStakingDistributor, bondStakingRewardVault, mint } = resolveSatBondAccounts(
-        solana,
-        signer,
-        effectiveEnv,
-      );
-      return [
-        { pubkey: bondStakingDistributor, isSigner: false, isWritable: true },
-        { pubkey: bondStakingRewardVault, isSigner: false, isWritable: false },
-        { pubkey: mint, isSigner: false, isWritable: false },
-      ];
-    },
-  });
+export async function submitSatCloseCommitPhase(
+  _config: SatMiningConfig,
+  params: { cycleId: number },
+) {
+  return submitSatCyclePhaseInstruction(_config, { ...params, phase: "close" });
 }
 
-export async function submitSatSyncBondStakingPosition(_config: SatMiningConfig) {
+export async function submitSatSealCycleEntropy(
+  _config: SatMiningConfig,
+  params: { cycleId: number; intervalStartCycleId?: number },
+) {
+  return submitSatCyclePhaseInstruction(_config, { ...params, phase: "seal" });
+}
+
+export async function submitSatReleaseUnrevealedCommit(
+  _config: SatMiningConfig,
+  params: { cycleId: number; minerAuthority: string },
+) {
   const cfg = loadConfigForSatRuntime(_config);
-  const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
-  assertDedicatedBondProgram(effectiveEnv);
   return submitInstruction({
     cfg,
-    env: effectiveEnv,
-    data: buildSyncBondStakingPositionData(effectiveEnv),
-    programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
+    env: process.env,
+    data: buildReleaseUnrevealedCommitData(params),
     accountResolver: async (solana, signer) => {
-      const { bondTierPolicy, bondStakingDistributor, bondStakingPosition, bondPosition } =
-        resolveSatBondAccounts(solana, signer, effectiveEnv);
+      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: true },
-        { pubkey: bondTierPolicy, isSigner: false, isWritable: false },
-        { pubkey: bondStakingDistributor, isSigner: false, isWritable: true },
-        { pubkey: bondStakingPosition, isSigner: false, isWritable: true },
-        { pubkey: bondPosition, isSigner: false, isWritable: false },
-        { pubkey: solana.SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: signer, isSigner: true, isWritable: false },
+        { pubkey: satCycleState, isSigner: false, isWritable: true },
+        { pubkey: satMinerCycleState, isSigner: false, isWritable: true },
+        { pubkey: satMinerCapitalState, isSigner: false, isWritable: true },
+        { pubkey: satTreasuryState, isSigner: false, isWritable: true },
+        { pubkey: satTreasuryVault, isSigner: false, isWritable: true },
       ];
     },
   });
 }
 
-export async function submitSatClaimBondStakingRewards(_config: SatMiningConfig) {
+export async function submitSatAbortEmptyCycle(
+  _config: SatMiningConfig,
+  params: { cycleId: number },
+) {
   const cfg = loadConfigForSatRuntime(_config);
-  const effectiveEnv = resolveSatEffectiveEnv(cfg, process.env);
-  assertDedicatedBondProgram(effectiveEnv);
   return submitInstruction({
     cfg,
-    env: effectiveEnv,
-    data: buildClaimBondStakingRewardsData(effectiveEnv),
-    programId: resolveSatBondProgramIdFromEnv(effectiveEnv),
+    env: process.env,
+    data: buildAbortEmptyCycleData(params),
     accountResolver: async (solana, signer) => {
-      const {
-        bondTierPolicy,
-        bondStakingDistributor,
-        bondStakingPosition,
-        bondPosition,
-        bondStakingRewardVault,
-        signerTokenAccount,
-        mint,
-      } = resolveSatBondAccounts(solana, signer, effectiveEnv);
+      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: signer, isSigner: true, isWritable: true },
-        { pubkey: bondTierPolicy, isSigner: false, isWritable: false },
-        { pubkey: bondStakingDistributor, isSigner: false, isWritable: true },
-        { pubkey: bondStakingPosition, isSigner: false, isWritable: true },
-        { pubkey: bondPosition, 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,
-        },
+        { pubkey: signer, isSigner: true, isWritable: false },
+        { pubkey: satCycleState, isSigner: false, isWritable: true },
+        { pubkey: satCycleRegistryMeta, isSigner: false, isWritable: true },
       ];
     },
   });
 }
 
-export async function submitSatCycle(
+export async function submitSatRevealCycle(
   _config: SatMiningConfig,
-  params: { cycleId: number; allocationFp: number[] },
+  params: {
+    cycleId: number;
+    intervalStartCycleId?: number;
+    nonceBase64: string;
+    allocationFp: number[];
+  },
 ) {
   const cfg = loadConfigForSatRuntime(_config);
+  const nonce = Buffer.from(params.nonceBase64, "base64");
   return submitInstruction({
     cfg,
     env: process.env,
-    data: buildSubmitCycleData(params),
+    data: buildRevealCycleData({ ...params, nonce }),
     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 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,
@@ -1690,37 +2697,32 @@ export async function submitSatCycle(
         [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)],
+      const [satUnlockIntervalState] = solana.PublicKey.findProgramAddressSync(
+        [Buffer.from(SAT_UNLOCK_INTERVAL_STATE_SEED), encodeU64(intervalStartCycleId)],
         programId,
       );
-      const [satTreasuryVault] = solana.PublicKey.findProgramAddressSync(
-        [Buffer.from(SAT_TREASURY_VAULT_SEED)],
+      const [satRegistryReserve] = solana.PublicKey.findProgramAddressSync(
+        [Buffer.from(SAT_REGISTRY_RESERVE_SEED)],
         programId,
       );
-      return [
-        { pubkey: signer, isSigner: true, isWritable: true },
-        { pubkey: satGlobalState, isSigner: false, 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: satRegistryReserve, isSigner: false, isWritable: true },
-        { pubkey: satTreasuryState, isSigner: false, isWritable: true },
-        { pubkey: solana.SystemProgram.programId, isSigner: false, isWritable: false },
-        { pubkey: satRebateVault, isSigner: false, isWritable: true },
-        { pubkey: satTreasuryVault, isSigner: false, isWritable: true },
-      ];
+      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),
+        },
+      };
     },
   });
 }
@@ -1801,7 +2803,29 @@ export async function submitSatSettleCyclePage(
           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 } } : {}),
+      };
     },
   });
 }
@@ -1941,20 +2965,58 @@ export async function submitSatScoreCyclePage(
           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 } } : {}),
+      };
     },
   });
 }
 
 export async function submitSatDistributeCyclePage(
   _config: SatMiningConfig,
-  params: { cycleId: number; pageIndex: number; chunkIndex: number; minerCycleAccounts?: string[] },
+  params: {
+    cycleId: number;
+    pageIndex: number;
+    chunkIndex: number;
+    minerCycleAccounts?: string[];
+    lookupTableAddress?: string;
+  },
 ) {
   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(
@@ -1993,16 +3055,21 @@ export async function submitSatDistributeCyclePage(
         [Buffer.from(SAT_REBATE_VAULT_SEED)],
         programId,
       );
+      const [satTreasuryVault] = solana.PublicKey.findProgramAddressSync(
+        [Buffer.from(SAT_TREASURY_VAULT_SEED)],
+        programId,
+      );
       const accounts = [
         { pubkey: signer, isSigner: true, isWritable: true },
         { pubkey: satCycleState, isSigner: false, isWritable: true },
         { pubkey: satCycleRegistryPage, isSigner: false, isWritable: false },
         { pubkey: satCycleSettlementProgress, isSigner: false, isWritable: true },
-        { pubkey: satGlobalState, isSigner: false, isWritable: true },
+        { pubkey: satGlobalState, isSigner: false, isWritable: false },
         { pubkey: satTreasuryState, isSigner: false, isWritable: true },
         { pubkey: satSignerMinerCycleState, isSigner: false, isWritable: false },
         { pubkey: satSignerMinerCapitalState, isSigner: false, isWritable: true },
         { pubkey: satRebateVault, isSigner: false, isWritable: true },
+        { pubkey: satTreasuryVault, isSigner: false, isWritable: true },
       ];
       const minerCycleAccounts = params.minerCycleAccounts ?? [];
       const minerCycles =
@@ -2011,6 +3078,7 @@ export async function submitSatDistributeCyclePage(
               addresses: minerCycleAccounts,
             }).catch(() => [])
           : [];
+      const minerAuthorities: string[] = [];
       for (const [index, minerCycleAccount] of minerCycleAccounts.entries()) {
         const satMinerCycleState = new solana.PublicKey(minerCycleAccount);
         const minerCycle = minerCycles[index] ?? null;
@@ -2022,6 +3090,7 @@ export async function submitSatDistributeCyclePage(
             `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,
@@ -2029,11 +3098,43 @@ export async function submitSatDistributeCyclePage(
         accounts.push({ pubkey: satMinerCycleState, isSigner: false, isWritable: true });
         accounts.push({ pubkey: satMinerCapitalState, isSigner: false, isWritable: true });
       }
-      return accounts;
+      return {
+        keys: accounts,
+        ...(minerAuthorities.length > 0 ? { context: { minerAuthorities } } : {}),
+      };
     },
   });
 }
 
+export async function submitSatCleanupDistributionLookupTable(
+  _config: SatMiningConfig,
+  params: { lookupTableAddress: string; action: "deactivate" | "close" },
+) {
+  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,
+  };
+}
+
 export async function submitSatClaimCycleRewards(
   _config: SatMiningConfig,
   params: { cycleId: number },
@@ -2188,29 +3289,6 @@ export async function submitSatClaimCycleRewardsBatch(
   });
 }
 
-export async function submitSatSetProtocolRecipients(
-  _config: SatMiningConfig,
-  params: { treasuryRecipient: string; distributorRecipient: string },
-) {
-  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 },
-      ];
-    },
-  });
-}
-
 export async function submitSatClaimProtocolTreasury(
   _config: SatMiningConfig,
   params: { recipientOwner: string },
@@ -2320,12 +3398,14 @@ export async function submitSatClaimProtocolDistributorSat(
   params: { recipientOwner: string },
 ) {
   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)],
@@ -2341,12 +3421,12 @@ export async function submitSatClaimProtocolDistributorSat(
       );
       const [mintAuthority] = solana.PublicKey.findProgramAddressSync(
         [Buffer.from("authority")],
-        new solana.PublicKey(SAT_MINT_PROGRAM_ID()),
+        new solana.PublicKey(resolveSatMintProgramIdFromEnv(effectiveEnv)),
       );
       const recipientAta = deriveAssociatedTokenAddress(
         solana,
         recipientOwner,
-        new solana.PublicKey(SAT_MINT_ADDRESS()),
+        new solana.PublicKey(resolveSatMintAddressFromEnv(effectiveEnv)),
       );
       return [
         { pubkey: signer, isSigner: true, isWritable: true },
@@ -2355,7 +3435,11 @@ export async function submitSatClaimProtocolDistributorSat(
         { pubkey: satTreasuryState, isSigner: false, isWritable: true },
         { pubkey: recipientOwner, isSigner: false, isWritable: true },
         { pubkey: mintAuthority, isSigner: false, isWritable: true },
-        { pubkey: new solana.PublicKey(SAT_MINT_ADDRESS()), isSigner: false, isWritable: true },
+        {
+          pubkey: new solana.PublicKey(resolveSatMintAddressFromEnv(effectiveEnv)),
+          isSigner: false,
+          isWritable: true,
+        },
         { pubkey: recipientAta, isSigner: false, isWritable: true },
         { pubkey: solana.SystemProgram.programId, isSigner: false, isWritable: false },
         { pubkey: new solana.PublicKey(TOKEN_PROGRAM_ID), isSigner: false, isWritable: false },
@@ -2364,7 +3448,16 @@ export async function submitSatClaimProtocolDistributorSat(
           isSigner: false,
           isWritable: false,
         },
-        { pubkey: new solana.PublicKey(SAT_MINT_PROGRAM_ID()), isSigner: false, isWritable: false },
+        {
+          pubkey: new solana.PublicKey(resolveSatMintProgramIdFromEnv(effectiveEnv)),
+          isSigner: false,
+          isWritable: false,
+        },
+        {
+          pubkey: new solana.PublicKey(resolveSatBondProgramIdFromEnv(effectiveEnv)),
+          isSigner: false,
+          isWritable: false,
+        },
       ];
     },
   });
@@ -2389,10 +3482,19 @@ export async function submitSatRetargetUnlock(
         [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, isSigner: true, isWritable: true },
         { pubkey: satGlobalState, isSigner: false, isWritable: true },
         { pubkey: satCycleState, isSigner: false, isWritable: false },
+        { pubkey: satUnlockIntervalState, isSigner: false, isWritable: true },
       ];
     },
   });
@@ -2624,7 +3726,13 @@ export async function submitSatCompactPendingCycleRange(
           isWritable: false,
         });
       }
-      return accounts;
+      return {
+        keys: accounts,
+        context: {
+          frontCycleIds: params.frontCycleIds.map(String),
+          backCycleIds: params.backCycleIds.map(String),
+        },
+      };
     },
   });
 }