@fased/fased 0.1.62 → 0.1.65

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

@@ -51,6 +51,41 @@ const SAT_CLAIM_IDLE_INTERVAL_MS = 60_000;
 const SAT_CLAIM_ACTIVE_INTERVAL_MS = 15_000;
 const SAT_CLAIM_PENDING_WAIT_INTERVAL_MS = 45_000;
 const SAT_TOKEN_DECIMALS = 11;
+
+type SatClaimGatewayResult = {
+  ok?: boolean;
+  payload?: {
+    resolvedCycleIds?: number[];
+    pendingCycleIds?: number[];
+  };
+};
+
+function resolveClaimGatewayCompletion(
+  result: SatClaimGatewayResult,
+  requestedCycleIds: readonly number[],
+): { resolvedCycleIds: number[]; pendingCycleIds: number[] } {
+  const requested = new Set(requestedCycleIds);
+  const hasExplicitCompletion =
+    Array.isArray(result.payload?.resolvedCycleIds) ||
+    Array.isArray(result.payload?.pendingCycleIds);
+  if (!hasExplicitCompletion) {
+    return { resolvedCycleIds: [...requested], pendingCycleIds: [] };
+  }
+  const resolvedCycleIds = [
+    ...new Set(
+      (result.payload?.resolvedCycleIds ?? []).filter((cycleId) => requested.has(cycleId)),
+    ),
+  ];
+  const resolved = new Set(resolvedCycleIds);
+  const explicitPending = new Set(
+    (result.payload?.pendingCycleIds ?? []).filter((cycleId) => requested.has(cycleId)),
+  );
+  const pendingCycleIds = [...requested].filter(
+    (cycleId) => !resolved.has(cycleId) || explicitPending.has(cycleId),
+  );
+  return { resolvedCycleIds, pendingCycleIds };
+}
+
 function resolveClaimNextDelayMs(hasPendingWork: boolean): number {
   return hasPendingWork ? SAT_CLAIM_PENDING_WAIT_INTERVAL_MS : SAT_CLAIM_IDLE_INTERVAL_MS;
 }
@@ -99,9 +134,7 @@ function resolveWalletEnvValue(
 function resolveAutoSweepRpcUrl(walletId: string, env: NodeJS.ProcessEnv): string | undefined {
   return (
     resolveWalletEnvValue(env, "FASED_WALLET_SOLANA_READ_RPC_URL", walletId) ||
-    resolveWalletEnvValue(env, "FASED_WALLET_SOLANA_RPC_URL", walletId) ||
-    resolveWalletEnvValue(env, "FASED_WALLET_EMBEDDED_KEYSTORE_READ_RPC_URL", walletId) ||
-    resolveWalletEnvValue(env, "FASED_WALLET_EMBEDDED_KEYSTORE_RPC_URL", walletId)
+    resolveWalletEnvValue(env, "FASED_WALLET_SOLANA_RPC_URL", walletId)
   );
 }
 
@@ -238,6 +271,7 @@ function resolveAutoSweepDestination(params: {
 async function maybeAutoSweepClaimedSat(params: {
   api: FasedAgentPluginApi;
   state: SatMiningRuntimeState;
+  occurrenceId: string;
 }): Promise<void> {
   const sweep = params.state.activeConfig.automation?.satSweep;
   if (!sweep?.enabled) {
@@ -325,7 +359,24 @@ async function maybeAutoSweepClaimedSat(params: {
       walletId,
       walletName: resolveAutoSweepSourceWalletName(walletId, process.env),
     },
-    requestedBy: "sat-mining",
+    requestedBy: "sat-mining:auto-sweep",
+    executionIntentId: `sat-auto-sweep:${walletId}:${params.occurrenceId}`,
+    satSweepAuthorization: {
+      kind: "sat-auto-sweep-v1",
+      occurrenceId: params.occurrenceId,
+      walletId,
+      destination: destination.to,
+      mint: satMintAddress,
+      sourceBalanceRaw: recipientBalanceRaw.toString(),
+      amountRaw: sweepRaw.toString(),
+      keepRaw: keepRaw.toString(),
+      minRaw: minRaw.toString(),
+      mode: sweep.mode === "percentage" ? "percentage" : "all",
+      percentage:
+        typeof sweep.percentage === "number" && Number.isFinite(sweep.percentage)
+          ? Math.max(0, Math.min(100, sweep.percentage))
+          : 100,
+    },
     config: effectiveWalletConfig,
     runtimeConfig: cfg,
     sendPath: "automation",
@@ -520,11 +571,11 @@ async function collectResolvedInvalidOwnerClaimCycles(params: {
       resolved.push(cycleId);
       continue;
     }
-    const claimedSat = BigInt(minerCycle.claimedSatRaw ?? "0");
-    const claimedRebate =
-      BigInt(minerCycle.claimedDetRebateLamports ?? "0") +
-      BigInt(minerCycle.claimedPerfRebateLamports ?? "0");
-    if (minerCycle.capitalLockReleased && (claimedSat > 0n || claimedRebate > 0n)) {
+    const claimableSat = BigInt(minerCycle.claimableSatRaw ?? "0");
+    const claimableRebate =
+      BigInt(minerCycle.claimableDetRebateLamports ?? "0") +
+      BigInt(minerCycle.claimablePerfRebateLamports ?? "0");
+    if (minerCycle.capitalLockReleased && claimableSat === 0n && claimableRebate === 0n) {
       resolved.push(cycleId);
     }
   }
@@ -766,18 +817,38 @@ export function createSatClaimService(params: {
         return;
       }
       markSatClaimBacklogClaiming(state, readyCycleIds);
-      await runSatGatewayMethod({
+      const result = await runSatGatewayMethod<SatClaimGatewayResult>({
         api,
         method: "sat.claimCycleRewardsBatch",
         payload: { cycleIds: readyCycleIds },
       });
-      for (const cycleId of readyCycleIds) {
+      const completion = resolveClaimGatewayCompletion(result, readyCycleIds);
+      for (const cycleId of completion.resolvedCycleIds) {
         const execution = getOrCreateRoundExecutionState(state, cycleId, 0);
         execution.claimSubmitted = true;
       }
-      markSatClaimBacklogClaimed(state, readyCycleIds);
-      await maybeAutoSweepClaimedSat({ api, state });
-      markWorkerSuccess(state, "claim", `cycles ${readyCycleIds.join(",")} claimed`);
+      for (const cycleId of completion.pendingCycleIds) {
+        const execution = getOrCreateRoundExecutionState(state, cycleId, 0);
+        execution.claimSubmitted = false;
+      }
+      markSatClaimBacklogClaimed(state, completion.resolvedCycleIds);
+      markSatClaimBacklogReady(
+        state,
+        completion.pendingCycleIds,
+        "bounded SAT claim chunk submitted; rewards remain claimable",
+      );
+      await maybeAutoSweepClaimedSat({
+        api,
+        state,
+        occurrenceId: [...readyCycleIds].toSorted((left, right) => left - right).join(","),
+      });
+      markWorkerSuccess(
+        state,
+        "claim",
+        completion.pendingCycleIds.length > 0
+          ? `claim chunk confirmed; cycles ${completion.pendingCycleIds.join(",")} still have rewards`
+          : `cycles ${completion.resolvedCycleIds.join(",")} claimed`,
+      );
       scheduleWorkerNextRun(state, "claim", SAT_CLAIM_ACTIVE_INTERVAL_MS);
     } catch (error) {
       if (isSatServiceReadTimeoutError(error)) {

package/extensions/sat-mining/src/client.ts

@@ -11,6 +11,7 @@ export const SAT_GATEWAY_METHODS = {
   finalizeCycleSettlement: "sat.finalizeCycleSettlement",
   scoreCyclePage: "sat.scoreCyclePage",
   distributeCyclePage: "sat.distributeCyclePage",
+  cleanupDistributionLookupTable: "sat.cleanupDistributionLookupTable",
   claimCycleRewards: "sat.claimCycleRewards",
   claimCycleRewardsBatch: "sat.claimCycleRewardsBatch",
   retargetUnlock: "sat.retargetUnlock",
@@ -128,6 +129,18 @@ export class SatMiningClient {
     };
   }
 
+  buildCleanupDistributionLookupTableRequest(params: {
+    cycleId: number;
+    pageIndex: number;
+    action: "deactivate" | "close";
+    lookupTableAddress?: string;
+  }) {
+    return {
+      method: SAT_GATEWAY_METHODS.cleanupDistributionLookupTable,
+      params,
+    };
+  }
+
   buildRetargetUnlockRequest(params: { cycleId: number }) {
     return {
       method: SAT_GATEWAY_METHODS.retargetUnlock,

package/extensions/sat-mining/src/config.ts

@@ -25,6 +25,7 @@ export type SatMiningConfig = {
     | "safe_fallback";
   strategyExecution?: "deterministic" | "auto";
   strategyMode?: "base" | "skill";
+  cycleCadence?: 1 | 2 | 6 | 12;
   commitLamports?: number;
   minSolBalanceLamports?: number;
   walletId?: string;
@@ -103,6 +104,9 @@ export const satMiningConfigJsonSchema = Type.Object(
       Type.Union([Type.Literal("deterministic"), Type.Literal("auto")]),
     ),
     strategyMode: Type.Optional(Type.Union([Type.Literal("base"), Type.Literal("skill")])),
+    cycleCadence: Type.Optional(
+      Type.Union([Type.Literal(1), Type.Literal(2), Type.Literal(6), Type.Literal(12)]),
+    ),
     commitLamports: Type.Optional(Type.Number()),
     minSolBalanceLamports: Type.Optional(Type.Number()),
     walletId: Type.Optional(Type.String()),
@@ -326,6 +330,10 @@ export function parseSatMiningConfig(value: unknown): SatMiningConfig {
       : raw.strategyMode === "skill"
         ? "skill"
         : "base";
+  const cycleCadence =
+    raw.cycleCadence === 2 || raw.cycleCadence === 6 || raw.cycleCadence === 12
+      ? raw.cycleCadence
+      : 1;
   const commitLamports =
     typeof raw.commitLamports === "number" &&
     Number.isFinite(raw.commitLamports) &&
@@ -486,6 +494,7 @@ export function parseSatMiningConfig(value: unknown): SatMiningConfig {
     strategyPreset: strategyPreset ?? riskModeToStrategyPreset(riskMode),
     strategyExecution: strategyExecution ?? strategyModeToExecution(strategyMode),
     strategyMode,
+    cycleCadence,
     commitLamports,
     minSolBalanceLamports,
     walletId,

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;
+}