@fased/fased 0.1.62 → 0.1.64

package/extensions/sat-mining/src/cycle-progress.ts

@@ -23,7 +23,7 @@ const SAT_SETTLEMENT_ACTIONS = new Set([
   "distributeCyclePage",
 ]);
 const SAT_CLOSE_ACTIONS = new Set(["closeResolvedCycleAccounts", "closeResolvedCycleArtifacts"]);
-const SAT_SUBMIT_ACTIONS = new Set(["submitCycle", "openCycle"]);
+const SAT_PARTICIPATION_ACTIONS = new Set(["commitCycle", "revealCycle", "submitCycle"]);
 const SAT_RUNTIME_PENDING_CYCLE_WINDOW = 12;
 
 function actionTimeMs(entry: { at?: string }) {
@@ -86,8 +86,13 @@ export function hasSuccessfulClaimOrCloseRecord(
   cycleId: number,
 ): boolean {
   return (
-    hasSuccessfulCycleAction(state, cycleId, ["claimCycleRewards", "claimCycleRewardsBatch"]) ||
-    hasAuthoritativeCloseRecord(state, cycleId)
+    state.recentActions.some(
+      (entry) =>
+        entry.status === "success" &&
+        entry.complete !== false &&
+        entry.cycleId === cycleId &&
+        (entry.action === "claimCycleRewards" || entry.action === "claimCycleRewardsBatch"),
+    ) || hasAuthoritativeCloseRecord(state, cycleId)
   );
 }
 
@@ -112,7 +117,7 @@ export function hasAuthoritativeCloseRecord(
     return false;
   }
   const latestSettlementAt = latestSuccessfulActionTimeMs(state, cycleId, SAT_SETTLEMENT_ACTIONS);
-  const latestSubmitAt = latestSuccessfulActionTimeMs(state, cycleId, SAT_SUBMIT_ACTIONS);
+  const latestSubmitAt = latestSuccessfulActionTimeMs(state, cycleId, SAT_PARTICIPATION_ACTIONS);
   const latestProgressAt = Math.max(latestSettlementAt ?? 0, latestSubmitAt ?? 0);
   return latestCloseAt >= latestProgressAt;
 }
@@ -152,7 +157,7 @@ export function collectRuntimePendingCycleIds(params: {
       cycleId == null ||
       cycleId < minRuntimePendingCycleId ||
       cycleId >= params.currentCycleId ||
-      !execution.participationSubmitted ||
+      (!execution.commitSubmitted && !execution.participationSubmitted) ||
       execution.claimSubmitted ||
       hasSuccessfulClaimOrCloseRecord(params.state, cycleId)
     ) {
@@ -163,7 +168,7 @@ export function collectRuntimePendingCycleIds(params: {
   for (const entry of params.state.recentActions) {
     if (
       entry.status === "success" &&
-      entry.action === "submitCycle" &&
+      SAT_PARTICIPATION_ACTIONS.has(entry.action) &&
       typeof entry.cycleId === "number" &&
       Number.isFinite(entry.cycleId) &&
       entry.cycleId > 0 &&
@@ -213,7 +218,7 @@ export function derivePendingCycleStage(
     return "stale-closed";
   }
   const execution = state.roundExecution.get(`${cycleId}:0`) ?? null;
-  if (hasSuccessfulCycleAction(state, cycleId, ["claimCycleRewards", "claimCycleRewardsBatch"])) {
+  if (hasSuccessfulClaimOrCloseRecord(state, cycleId)) {
     return "closing";
   }
   if (execution?.claimSubmitted) {
@@ -230,10 +235,13 @@ export function derivePendingCycleStage(
   }
   if (
     execution?.participationSubmitted ||
-    hasSuccessfulCycleAction(state, cycleId, ["submitCycle", "openCycle"])
+    hasSuccessfulCycleAction(state, cycleId, ["revealCycle", "submitCycle"])
   ) {
     return "settling";
   }
+  if (execution?.commitSubmitted || hasSuccessfulCycleAction(state, cycleId, ["commitCycle"])) {
+    return "submitted";
+  }
   return "unknown";
 }
 

package/extensions/sat-mining/src/epoch-service.ts

@@ -619,17 +619,21 @@ async function selectEpochTargetCycle(params: {
       execution.openRoundSubmitted = true;
     }
     if (!execution.participationSubmitted && authority) {
-      minerCycleExists = await Promise.resolve(
-        withEpochReadTimeout("miner-cycle existence", () =>
-          inspectSatMinerCycleAccountExists(state.activeConfig, {
+      const minerCycle = await Promise.resolve(
+        withEpochReadTimeout("miner-cycle participation", () =>
+          inspectSatMinerCycle(state.activeConfig, {
             authority,
             cycleId,
           }),
         ),
-      ).catch(() => false);
-      if (minerCycleExists) {
+      ).catch(swallowSatReadErrorUnlessTimeout);
+      minerCycleExists = minerCycle != null;
+      if (minerCycle?.validParticipation === true) {
         execution.openRoundSubmitted = true;
         execution.participationSubmitted = true;
+      } else if (minerCycle) {
+        execution.openRoundSubmitted = true;
+        execution.commitSubmitted = true;
       }
     }
     if (!execution.participationSubmitted) {

package/extensions/sat-mining/src/gateway-runner.ts

@@ -1,6 +1,7 @@
 import type { FasedAgentPluginApi } from "fased/plugin-sdk";
 import { callGatewayScoped, resolveGatewayPort } from "fased/plugin-sdk/sat-runtime";
 import { consumeSatGatewayMethodChaosOnce } from "./live-chaos.js";
+import { digestSatSubmissionIntent } from "./submission-ledger.js";
 
 function chaosError(envName: string, fallback: string): Error {
   return new Error(process.env[envName]?.trim() || fallback);
@@ -10,6 +11,7 @@ export async function runSatGatewayMethod<T = Record<string, unknown>>(params: {
   api: FasedAgentPluginApi;
   method: string;
   payload: unknown;
+  workflowId?: string;
 }): Promise<T> {
   if (
     consumeSatGatewayMethodChaosOnce({
@@ -30,12 +32,30 @@ export async function runSatGatewayMethod<T = Record<string, unknown>>(params: {
       ? currentConfig.gateway.auth.token.trim() || undefined
       : undefined;
   const url = `ws://127.0.0.1:${resolveGatewayPort(currentConfig, process.env)}`;
+  const payloadRecord =
+    params.payload && typeof params.payload === "object" && !Array.isArray(params.payload)
+      ? (params.payload as Record<string, unknown>)
+      : null;
+  const idempotencyKey =
+    params.workflowId?.trim() ||
+    `worker:${params.method}:${digestSatSubmissionIntent(params.payload)}`;
+  const mutationMethod = !/^sat\.(?:get|list|status)/u.test(params.method);
+  const gatewayParams =
+    mutationMethod && payloadRecord
+      ? {
+          ...payloadRecord,
+          idempotencyKey:
+            typeof payloadRecord.idempotencyKey === "string" && payloadRecord.idempotencyKey.trim()
+              ? payloadRecord.idempotencyKey.trim()
+              : idempotencyKey,
+        }
+      : params.payload;
   const result = await callGatewayScoped<T>({
     url,
     token,
     config: currentConfig,
     method: params.method,
-    params: params.payload,
+    params: gatewayParams,
     scopes: ["operator.admin"],
     timeoutMs: 15_000,
   });

package/extensions/sat-mining/src/protocol-contract.ts

@@ -36,8 +36,15 @@ export const SAT_INSTRUCTION_DISCRIMINATORS = {
   requestBondUnlock: 81,
   cancelBondUnlock: 82,
   finalizeBondUnlock: 83,
+  topUpRegistryReserve: 84,
   claimProtocolDistributorSat: 85,
   refillRegistryReserveFromTreasury: 88,
+  commitCycle: 89,
+  closeCommitPhase: 90,
+  sealCycleEntropy: 91,
+  revealCycle: 92,
+  releaseUnrevealedCommit: 93,
+  abortEmptyCycle: 94,
   miningCrank: 33,
 } as const;
 
@@ -53,12 +60,49 @@ export const SAT_BOND_INSTRUCTION_DISCRIMINATORS = {
   syncStakingRewards: 8,
   syncStakingPosition: 9,
   claimStakingRewards: 10,
+  claimUnallocatedStakingRewards: 11,
+  recordProtocolStakingRewards: 12,
 } as const;
 
 export const SAT_PROTOCOL_CONSTANTS = {
   allocationBuckets: 25,
   cycleSeconds: 300,
+  cycleOpenGraceSeconds: 30,
+  cycleCommitSeconds: 120,
+  cycleCommitSlots: 300,
+  cycleRevealSlots: 375,
+  cycleSettlementBufferSeconds: 30,
+  cycleEntropyDelaySlots: 8,
+  cycleEntropyHashCount: 8,
+  cycleRecoveryRevealSeconds: 120,
   cycleErosionPpm: 83n,
+  cycleNonRevealPenaltyBps: 100,
+  cycleUnlockRetargetIntervalCycles: 12,
+  cycleUnlockWindowIntervals: 24,
+  cycleUnlockMaxStepBps: 1_000,
   minimumEntryLamports: 250_000_000,
-  registryReserveTargetLamports: 200_000_000n,
+  entropyUnavailableSeedHex: "ff".repeat(32),
 } as const;
+
+export const SAT_GENESIS_PROFILE_CONTRACTS = {
+  devnet: {
+    cluster: "devnet",
+    configSha256: "79c536b73d7682842c9574f6785e7a8ab5916eb0a99e29f98c00bde4b18e3500",
+    registryReserveTargetLamports: 200_000_000n,
+    registryReserveMaxLamports: 200_000_000n,
+    keeperReserveSpendableLamports: 10_000_000n,
+  },
+  "mainnet-beta": {
+    cluster: "mainnet-beta",
+    configSha256: "f35ccf88352efc6f86e6ff18b5c6f349e7ba792916ec8a4ae5c3705fde4c963b",
+    registryReserveTargetLamports: 500_000_000n,
+    registryReserveMaxLamports: 1_000_000_000n,
+    keeperReserveSpendableLamports: 10_000_000n,
+  },
+} as const;
+
+export function resolveSatGenesisProfileContract(network: string | null | undefined) {
+  return network === "mainnet-beta"
+    ? SAT_GENESIS_PROFILE_CONTRACTS["mainnet-beta"]
+    : SAT_GENESIS_PROFILE_CONTRACTS.devnet;
+}

package/extensions/sat-mining/src/recovery-service.ts

@@ -3,8 +3,11 @@ import { refreshSatChainTime } from "./chain-time.js";
 import type { SatMiningConfig } from "./config.js";
 import { deriveExactPendingCycle } from "./cycle-progress.js";
 import { runSatGatewayMethod } from "./gateway-runner.js";
+import { SAT_PROTOCOL_CONSTANTS } from "./protocol-contract.js";
 import {
+  inspectSatCycle,
   inspectSatCycleSettlementProgressV2,
+  inspectSatChainSlot,
   inspectSatMinerCapital,
   inspectSatMinerCycle,
 } from "./rpc-read.js";
@@ -20,6 +23,7 @@ import {
   satRateLimitBackoffMs,
   scheduleWorkerNextRun,
   type SatMiningRuntimeState,
+  type SatRoundExecutionState,
 } from "./runtime.js";
 import {
   isSatServiceReadTimeoutError,
@@ -97,6 +101,53 @@ function hasPendingCapitalRange(firstPendingCycleId?: number, lastPendingCycleId
   );
 }
 
+function isZeroCycleSeed(value: string | undefined): boolean {
+  return !value || /^0+$/.test(value);
+}
+
+function isEntropyUnavailable(cycle: {
+  cycleSeed?: string;
+  entropyUnavailable?: boolean;
+}): boolean {
+  return (
+    cycle.entropyUnavailable === true ||
+    cycle.cycleSeed === SAT_PROTOCOL_CONSTANTS.entropyUnavailableSeedHex
+  );
+}
+
+function hasDurableRevealMaterial(execution: SatRoundExecutionState): boolean {
+  return (
+    typeof execution.revealNonceBase64 === "string" &&
+    execution.revealNonceBase64.length > 0 &&
+    Array.isArray(execution.allocationFp) &&
+    execution.allocationFp.length > 0
+  );
+}
+
+function isFullyResolvedEmptyCycle(
+  cycle: Awaited<ReturnType<typeof inspectSatCycle>> | null,
+): boolean {
+  if (!cycle || cycle.status !== 1 || BigInt(cycle.validMinerCount ?? "0") !== 0n) {
+    return false;
+  }
+  const committed = BigInt(cycle.committedMinerCount ?? "0");
+  const resolved = BigInt(cycle.resolvedCommitCount ?? "0");
+  const released = BigInt(cycle.releasedCommitCount ?? committed);
+  return committed > 0n && resolved === committed && released === committed;
+}
+
+function isMinerCycleResolvedForCleanup(
+  minerCycle: Awaited<ReturnType<typeof inspectSatMinerCycle>> | null,
+): boolean {
+  return Boolean(
+    minerCycle &&
+    minerCycle.capitalLockReleased === true &&
+    BigInt(minerCycle.claimableSatRaw ?? "0") === 0n &&
+    BigInt(minerCycle.claimableDetRebateLamports ?? "0") === 0n &&
+    BigInt(minerCycle.claimablePerfRebateLamports ?? "0") === 0n,
+  );
+}
+
 function collectCloseCandidateCycleIds(state: SatMiningRuntimeState, current: number): number[] {
   const candidateIds = new Set<number>();
   const minCandidateCycleId = Math.max(1, current - RECOVERY_CLOSE_BACKLOG_WINDOW);
@@ -174,6 +225,248 @@ export function createSatRecoveryService(params: {
   let tickInFlight = false;
   let lastPendingRangeCompactAt = 0;
 
+  const recoverPendingCommit = async (params: {
+    cycleId: number;
+    authority: string;
+    nowSec: number;
+    currentSlot: number | null;
+    anchor: string;
+    backlogDetail: string;
+  }): Promise<boolean> => {
+    const execution = state.roundExecution.get(`${params.cycleId}:0`) ?? null;
+    const [cycle, minerCycle] = await Promise.all([
+      withRecoveryReadTimeout("commit/reveal cycle", () =>
+        inspectSatCycle(state.activeConfig, { cycleId: params.cycleId }),
+      ).catch(swallowSatReadErrorUnlessTimeout),
+      withRecoveryReadTimeout("commit/reveal miner cycle", () =>
+        inspectSatMinerCycle(state.activeConfig, {
+          authority: params.authority,
+          cycleId: params.cycleId,
+        }),
+      ).catch(swallowSatReadErrorUnlessTimeout),
+    ]);
+    if (!cycle || !minerCycle) {
+      return false;
+    }
+    if (cycle.status === 2 && isMinerCycleResolvedForCleanup(minerCycle)) {
+      await runSatGatewayMethod({
+        api,
+        method: "sat.closeResolvedCycleAccounts",
+        payload: { cycleId: params.cycleId },
+      });
+      state.roundExecution.delete(`${params.cycleId}:0`);
+      await persistRuntimeState?.();
+      markWorkerSuccess(
+        state,
+        "recovery",
+        `${params.anchor}${params.backlogDetail} closed resolved commitment cycle ${params.cycleId}`,
+      );
+      scheduleWorkerNextRun(state, "recovery", RECOVERY_TICK_INTERVAL_MS);
+      return true;
+    }
+    if (cycle.status !== 1) {
+      return false;
+    }
+    if (minerCycle.validParticipation) {
+      if (execution) {
+        execution.participationSubmitted = true;
+        execution.entropySealed = !isZeroCycleSeed(cycle.cycleSeed) && !isEntropyUnavailable(cycle);
+        await persistRuntimeState?.();
+      }
+    }
+
+    const detailPrefix = `${params.anchor}${params.backlogDetail}`;
+    const commitDeadlineTs = cycle.commitDeadlineTs ?? 0;
+    const revealDeadlineTs = cycle.revealDeadlineTs ?? 0;
+    const commitPhaseOpen =
+      params.currentSlot != null && cycle.commitDeadlineSlot != null
+        ? params.currentSlot < cycle.commitDeadlineSlot
+        : params.nowSec < commitDeadlineTs;
+    const revealPhaseOpen =
+      params.currentSlot != null && cycle.revealDeadlineSlot != null
+        ? params.currentSlot < cycle.revealDeadlineSlot
+        : params.nowSec < revealDeadlineTs;
+    if (commitPhaseOpen) {
+      markWorkerWaiting(
+        state,
+        "recovery",
+        `cycle ${params.cycleId} commitment is waiting for the commit window to close`,
+      );
+      scheduleWorkerNextRun(
+        state,
+        "recovery",
+        Math.max(1_000, Math.min(10_000, (commitDeadlineTs - params.nowSec) * 1_000 + 500)),
+      );
+      return true;
+    }
+
+    if (execution?.entropyTargetPinned !== true) {
+      if (execution) {
+        execution.entropyTargetPinned = true;
+        await persistRuntimeState?.();
+      }
+    }
+
+    if (isEntropyUnavailable(cycle)) {
+      if (!minerCycle.capitalLockReleased) {
+        await runSatGatewayMethod({
+          api,
+          method: "sat.releaseUnrevealedCommit",
+          payload: { cycleId: params.cycleId, minerAuthority: params.authority },
+        });
+      }
+      const refreshedCycle = await withRecoveryReadTimeout("cancelled entropy cycle", () =>
+        inspectSatCycle(state.activeConfig, { cycleId: params.cycleId }),
+      ).catch(swallowSatReadErrorUnlessTimeout);
+      if (isFullyResolvedEmptyCycle(refreshedCycle)) {
+        await runSatGatewayMethod({
+          api,
+          method: "sat.abortEmptyCycle",
+          payload: { cycleId: params.cycleId },
+        });
+        await runSatGatewayMethod({
+          api,
+          method: "sat.closeResolvedCycleAccounts",
+          payload: { cycleId: params.cycleId },
+        });
+        state.roundExecution.delete(`${params.cycleId}:0`);
+        await persistRuntimeState?.();
+        markWorkerSuccess(
+          state,
+          "recovery",
+          `${detailPrefix} unwound unprovable entropy without penalty and aborted cycle ${params.cycleId}`,
+        );
+      } else {
+        markWorkerWaiting(
+          state,
+          "recovery",
+          `cycle ${params.cycleId} cancelled without penalty; waiting for remaining commitments to unwind`,
+        );
+      }
+      scheduleWorkerNextRun(state, "recovery", RECOVERY_TICK_INTERVAL_MS);
+      return true;
+    }
+
+    if (isZeroCycleSeed(cycle.cycleSeed) && revealPhaseOpen) {
+      if (minerCycle.validParticipation) {
+        markWorkerWaiting(
+          state,
+          "recovery",
+          `cycle ${params.cycleId} reveal is recorded; waiting for the sealed-strategy window to close`,
+        );
+        scheduleWorkerNextRun(state, "recovery", 1_000);
+        return true;
+      }
+      if (!execution || !hasDurableRevealMaterial(execution)) {
+        markWorkerWaiting(
+          state,
+          "recovery",
+          `cycle ${params.cycleId} cannot reveal safely because its durable nonce or allocation is unavailable`,
+        );
+        scheduleWorkerNextRun(state, "recovery", RECOVERY_TICK_INTERVAL_MS);
+        return true;
+      }
+      await runSatGatewayMethod({
+        api,
+        method: "sat.revealCycle",
+        payload: {
+          cycleId: params.cycleId,
+          nonceBase64: execution.revealNonceBase64,
+          allocationFp: execution.allocationFp,
+        },
+      });
+      execution.participationSubmitted = true;
+      await persistRuntimeState?.();
+      markWorkerSuccess(
+        state,
+        "recovery",
+        `${detailPrefix} recovered reveal for cycle ${params.cycleId}`,
+      );
+      scheduleWorkerNextRun(state, "recovery", 1_000);
+      return true;
+    }
+
+    if (isZeroCycleSeed(cycle.cycleSeed)) {
+      if (
+        params.currentSlot != null &&
+        cycle.entropyTargetSlot != null &&
+        params.currentSlot <= cycle.entropyTargetSlot
+      ) {
+        markWorkerWaiting(
+          state,
+          "recovery",
+          `cycle ${params.cycleId} reveal window closed; waiting for future entropy slots`,
+        );
+        scheduleWorkerNextRun(state, "recovery", 1_000);
+        return true;
+      }
+      try {
+        await runSatGatewayMethod({
+          api,
+          method: "sat.sealCycleEntropy",
+          payload: { cycleId: params.cycleId },
+        });
+      } catch (error) {
+        api.logger.debug?.(
+          `[sat-mining] recovery is waiting for cycle ${params.cycleId} entropy: ${String(error)}`,
+        );
+      }
+      markWorkerWaiting(
+        state,
+        "recovery",
+        `cycle ${params.cycleId} is sealing post-reveal entropy`,
+      );
+      scheduleWorkerNextRun(state, "recovery", 1_000);
+      return true;
+    }
+
+    if (execution) {
+      execution.entropySealed = true;
+      await persistRuntimeState?.();
+    }
+    if (minerCycle.validParticipation) {
+      return false;
+    }
+
+    if (!minerCycle.capitalLockReleased) {
+      await runSatGatewayMethod({
+        api,
+        method: "sat.releaseUnrevealedCommit",
+        payload: { cycleId: params.cycleId, minerAuthority: params.authority },
+      });
+    }
+    const refreshedCycle = await withRecoveryReadTimeout("released commit cycle", () =>
+      inspectSatCycle(state.activeConfig, { cycleId: params.cycleId }),
+    ).catch(swallowSatReadErrorUnlessTimeout);
+    if (isFullyResolvedEmptyCycle(refreshedCycle)) {
+      await runSatGatewayMethod({
+        api,
+        method: "sat.abortEmptyCycle",
+        payload: { cycleId: params.cycleId },
+      });
+      await runSatGatewayMethod({
+        api,
+        method: "sat.closeResolvedCycleAccounts",
+        payload: { cycleId: params.cycleId },
+      });
+      state.roundExecution.delete(`${params.cycleId}:0`);
+      await persistRuntimeState?.();
+      markWorkerSuccess(
+        state,
+        "recovery",
+        `${detailPrefix} released missed reveal and aborted empty cycle ${params.cycleId}`,
+      );
+    } else {
+      markWorkerSuccess(
+        state,
+        "recovery",
+        `${detailPrefix} released missed reveal for cycle ${params.cycleId}`,
+      );
+    }
+    scheduleWorkerNextRun(state, "recovery", RECOVERY_TICK_INTERVAL_MS);
+    return true;
+  };
+
   const collectPrioritizedCloseCycleIds = (params: {
     current: number;
     exactPendingCycleId?: number | null;
@@ -273,6 +566,25 @@ export function createSatRecoveryService(params: {
               backlogDetail = backlogDetail || ` ${exactPendingCycle.reason}`;
             }
             markWorkerRun(state, "recovery", `${anchor}${backlogDetail}`);
+            const currentSlot = exactPendingCycle
+              ? await withRecoveryReadTimeout("chain slot", () =>
+                  inspectSatChainSlot(state.activeConfig),
+                ).catch(swallowSatReadErrorUnlessTimeout)
+              : null;
+            if (
+              exactPendingCycle?.stage === "submitted" &&
+              chainTime.chainUnixTime != null &&
+              (await recoverPendingCommit({
+                cycleId: exactPendingCycle.cycleId,
+                authority: activeWalletAddress,
+                nowSec: chainTime.chainUnixTime,
+                currentSlot,
+                anchor,
+                backlogDetail,
+              }))
+            ) {
+              return;
+            }
             const pendingCapitalRangeExists = hasPendingCapitalRange(
               minerCapital?.firstPendingCycleId,
               minerCapital?.lastPendingCycleId,