@jinn-network/client 0.1.8 → 0.1.9-canary.01623b98

package/dist/earning/bootstrap.js

@@ -4,8 +4,8 @@
  * Phase 1 (master): generate mnemonic → fund master EOA
  * Phase 2 (per-service): derive agent → stake → deploy mech
  */
-import { decodeEventLog, encodeAbiParameters, encodeFunctionData, formatEther, getAddress, zeroAddress, } from 'viem';
-import { ERC20_ABI, EVENT_TOPICS, IDENTITY_REGISTRY_ABI, IDENTITY_REGISTRY_ADDRESSES, SERVICE_MANAGER_ABI, SERVICE_REGISTRY_APPROVE_ABI, SERVICE_REGISTRY_L2_ABI, STAKING_ABI, MECH_MARKETPLACE_CREATE_ABI, STOLAS_DISTRIBUTOR_ABI, STOLAS_STAKING_SLOTS_ABI, applyChainGasOverrides, cidToBytes32, getChainConfig, } from './contracts.js';
+import { encodeAbiParameters, encodeFunctionData, formatEther, getAddress, zeroAddress, } from 'viem';
+import { ERC20_ABI, IDENTITY_REGISTRY_ABI, IDENTITY_REGISTRY_ADDRESSES, SERVICE_MANAGER_ABI, SERVICE_REGISTRY_APPROVE_ABI, SERVICE_REGISTRY_L2_ABI, STAKING_ABI, MECH_MARKETPLACE_CREATE_ABI, STOLAS_DISTRIBUTOR_ABI, STOLAS_STAKING_SLOTS_ABI, applyChainGasOverrides, cidToBytes32, getChainConfig, } from './contracts.js';
 import { executeSafeTxBatch, executeSafeTxDirect, initDeployedSafe, initPredictedSafe, } from './safe-adapter.js';
 import { bindAgentWalletToSafe } from './agent-wallet-binding.js';
 import { FleetStateStore } from './store.js';
@@ -17,12 +17,18 @@ import { previousSafeBeingAbandoned, sweepOrphanedServiceFunds, } from './orphan
 import { DEFAULT_FAUCET_LOOP_TIMEOUT_MS, computeFaucetDripCap, requestTestnetFunding, } from './faucet.js';
 import { flattenErrorMessage, sleep, viemSendTransactionWithRetry, waitForContractCode, waitForTransactionReceiptWithRetry, } from '../tx-retry.js';
 import { isUnauthorizedAccountError } from '../errors/unauthorized-account.js';
+import { formatKnownRevert } from '../adapters/mech/safe-revert.js';
 import { createJinnPublicClient, createJinnWalletClient } from './viem-clients.js';
 import { isTransientEthReadError } from '../chain-read-errors.js';
 import { nextFleetServiceIndex } from './next-service-index.js';
 import { displayFleetServiceIndex } from './fleet-display-index.js';
+import { DEFAULT_MASTER_ETH_DAILY_WEI } from './master-gas.js';
 import { rpcHostForDisplay } from '../preflight/rpc-network.js';
 import { detectDeprecatedTestnetSetup, migrateDeprecatedTestnetSetup, } from './testnet-setup-migration.js';
+import { parseAgentIdFromReceipt as parseAgentIdFromReceiptImpl, parseMultisigFromReceipt as parseMultisigFromReceiptImpl, parseServiceIdFromReceipt as parseServiceIdFromReceiptImpl, } from './steps/receipt-parsing.js';
+import { stepFleetSafePredict as stepFleetSafePredictImpl } from './steps/fleet-safe-predict.js';
+import { stepFleetSafeDeploy as stepFleetSafeDeployImpl } from './steps/fleet-safe-deploy.js';
+import { stepFleetIdentityRegister as stepFleetIdentityRegisterImpl } from './steps/fleet-identity-register.js';
 const addr = (value) => getAddress(value);
 const SAFE_TOKEN_BOOTSTRAP_MULTIPLIER = 2n;
 /**
@@ -148,17 +154,6 @@ export function stage1MinMasterEth(config, targetServices = 1) {
         config.minEoaGasEth * STANDARD_MASTER_BOOTSTRAP_MULTIPLIER +
         extraServiceTransfers);
 }
-/**
- * Conservative default: ~0.0005 ETH/day master gas if not configured.
- *
- * Post-bootstrap master burn is dominated by rare BalanceTopupLoop top-ups,
- * not every-poll activity — the previous 0.001 ETH/day floor (alongside a
- * poll-based blend, since removed) over-estimated steady-state burn and
- * surfaced a misleading "1 days runway" dashboard reading at ~0.008 ETH
- * balances (#288). Mirrored at client/src/api/status-build.ts; collapsing
- * the two copies is a deferred follow-up per the #288 design note.
- */
-const DEFAULT_MASTER_ETH_DAILY_WEI = 500000000000000n;
 /** Warn when ETH above the minimum would last fewer than this many days at the daily estimate. */
 const MASTER_ETH_RUNWAY_WARN_DAYS = 7n;
 /**
@@ -183,6 +178,8 @@ const MASTER_ETH_RUNWAY_WARN_DAYS = 7n;
  */
 const DEFAULT_SAFE_BINDING_MAX_ATTEMPTS = 3;
 const DEFAULT_SAFE_BINDING_RETRY_DELAY_MS = 3_000;
+const FAUCET_RATE_LIMIT_MAX_RETRIES = 3;
+const DEFAULT_FAUCET_RATE_LIMIT_BACKOFF_MS = 15_000;
 export class FleetBootstrapper {
     store;
     config;
@@ -199,6 +196,7 @@ export class FleetBootstrapper {
     autoTestnetFaucet;
     safeBindingMaxAttempts;
     safeBindingRetryDelayMs;
+    faucetRateLimitBackoffMs;
     constructor(options = {}) {
         this.store = new FleetStateStore(options.earningDir);
         this.chain = options.chain ?? 'base';
@@ -215,6 +213,8 @@ export class FleetBootstrapper {
             options.safeBindingMaxAttempts ?? DEFAULT_SAFE_BINDING_MAX_ATTEMPTS;
         this.safeBindingRetryDelayMs =
             options.safeBindingRetryDelayMs ?? DEFAULT_SAFE_BINDING_RETRY_DELAY_MS;
+        this.faucetRateLimitBackoffMs =
+            options.faucetRateLimitBackoffMs ?? DEFAULT_FAUCET_RATE_LIMIT_BACKOFF_MS;
         const dailyOpt = options.masterEthDailyEstimateWei;
         this.masterEthDailyEstimateWei =
             dailyOpt !== undefined
@@ -550,8 +550,13 @@ export class FleetBootstrapper {
                     targetWei: requiredMasterEth,
                     balanceWei: systemEth,
                 });
-                const INTER_DRIP_PAUSE_MS = 1_000;
                 const deadline = this.now() + this.faucetLoopTimeoutMs;
+                // requestFunding returns synchronously with a txHash and there is no
+                // on-chain confirmation to wait for between drips, so the happy path
+                // carries NO fixed inter-drip sleep (issue #984 work unit 1). A transient
+                // CDP 429 backs off and retries within the session instead of ending it
+                // on the first throttle; the wall-clock deadline stays the safety rail.
+                let rateLimitRetries = 0;
                 console.error(`[fleet-bootstrap] Master has ${formatEther(systemEth)} ETH; need ${formatEther(requiredMasterEth)} ETH. ` +
                     `Draining CDP faucet on ${this.chain} via ${rpcHostForDisplay(this.config.rpcUrl)} ` +
                     `(each drip ≈ 0.0001 ETH, up to ${maxFaucetIters} drips or ${Math.round(this.faucetLoopTimeoutMs / 1000)}s, whichever comes first).`);
@@ -564,6 +569,13 @@ export class FleetBootstrapper {
                     }
                     const faucetResult = await this.requestFunding(masterAddress, 'base-sepolia');
                     if (!faucetResult.ok) {
+                        if (faucetResult.rateLimited && rateLimitRetries < FAUCET_RATE_LIMIT_MAX_RETRIES) {
+                            rateLimitRetries++;
+                            console.error(`[fleet-bootstrap] CDP faucet rate-limited after ${i} drips: ${faucetResult.reason}. ` +
+                                `Backing off (retry ${rateLimitRetries}/${FAUCET_RATE_LIMIT_MAX_RETRIES}).`);
+                            await new Promise(r => setTimeout(r, this.faucetRateLimitBackoffMs));
+                            continue;
+                        }
                         if (faucetResult.rateLimited) {
                             console.error(`[fleet-bootstrap] CDP faucet rate-limited after ${i} drips: ${faucetResult.reason}`);
                         }
@@ -572,14 +584,17 @@ export class FleetBootstrapper {
                         }
                         break;
                     }
-                    await new Promise(r => setTimeout(r, INTER_DRIP_PAUSE_MS));
+                    // Balance is no longer read once per drip — only every 5th drip and on
+                    // the final iteration (issue #984 work unit 1). Target/early-exit is
+                    // only checked on iterations where balance was just refreshed.
+                    if ((i + 1) % 5 !== 0 && i !== maxFaucetIters - 1) {
+                        continue;
+                    }
                     const refreshed = await refreshSystemEth();
                     systemEth = refreshed.system;
                     masterBalance = refreshed.master;
-                    if ((i + 1) % 5 === 0) {
-                        console.error(`[fleet-bootstrap] drip ${i + 1}/${maxFaucetIters} · chain=${this.chain} · rpc=${rpcHostForDisplay(this.config.rpcUrl)} · ` +
-                            `master=${formatEther(masterBalance)} ETH · target=${formatEther(requiredMasterEth)} ETH`);
-                    }
+                    console.error(`[fleet-bootstrap] drip ${i + 1}/${maxFaucetIters} · chain=${this.chain} · rpc=${rpcHostForDisplay(this.config.rpcUrl)} · ` +
+                        `master=${formatEther(masterBalance)} ETH · target=${formatEther(requiredMasterEth)} ETH`);
                     if (systemEth >= requiredMasterEth) {
                         console.error(`[fleet-bootstrap] Faucet funding sufficient after ${i + 1} drip${i === 0 ? '' : 's'} ` +
                             `(master=${formatEther(masterBalance)} ETH). Continuing bootstrap...`);
@@ -762,131 +777,14 @@ export class FleetBootstrapper {
         }
     }
     // ── Stage 1: fleet-level identity steps (nghf) ────────────────────────
-    /** Deterministic Safe predict from the HD-index-1 agent EOA. */
     async stepFleetSafePredict(state, mnemonic) {
-        const agentAddress = deriveAgentAddress(mnemonic, 1);
-        const agentKey = walletPrivateKeyAtIndex(mnemonic, 1);
-        console.error(`[fleet-bootstrap] Stage 1: predicting fleet Safe (owner=${agentAddress})`);
-        const { address } = await initPredictedSafe({
-            rpcUrl: this.config.rpcUrl,
-            signerKey: agentKey,
-            owners: [agentAddress],
-            threshold: 1,
-        });
-        void state;
-        return this.store.patchFleet({ fleet_safe_address: getAddress(address) });
+        return stepFleetSafePredictImpl(this.stepContext(), state, mnemonic);
     }
-    /** Deploy the predicted fleet Safe. Funds the agent EOA from master if needed. */
     async stepFleetSafeDeploy(state, mnemonic) {
-        const agentAddress = deriveAgentAddress(mnemonic, 1);
-        const agentKey = walletPrivateKeyAtIndex(mnemonic, 1);
-        const agentSigner = deriveAgentSigner(mnemonic, 1);
-        const fleetSafe = state.fleet_safe_address;
-        // Fund agent EOA so it can pay for Safe deploy + setAgentWallet gas.
-        // 0.01 ETH covers Safe deploy (~250k gas) + register (~80k) + setAgentWallet
-        // (~200k) at testnet gas prices comfortably. STAGE1_AGENT_ETH is the
-        // module-level constant used both here and in `stage1MinMasterEth` so the
-        // gate and the transfer agree (jinn-mono-u34i).
-        const masterAccount = deriveMasterSigner(mnemonic);
-        const masterWallet = createJinnWalletClient(this.config.rpcUrl, this.chain, masterAccount);
-        const agentBalance = await this.publicClient.getBalance({
-            address: getAddress(agentAddress),
-        });
-        if (agentBalance < STAGE1_AGENT_ETH) {
-            const fundAmount = STAGE1_AGENT_ETH - agentBalance;
-            console.error(`[fleet-bootstrap] Stage 1: funding fleet agent EOA with ${fundAmount} wei from master`);
-            const fundHash = await viemSendTransactionWithRetry(masterWallet, this.publicClient, {
-                account: masterAccount,
-                to: addr(agentAddress),
-                value: fundAmount,
-            });
-            await waitForTransactionReceiptWithRetry(this.publicClient, fundHash);
-        }
-        console.error(`[fleet-bootstrap] Stage 1: deploying fleet Safe at ${fleetSafe}`);
-        const { safe } = await initPredictedSafe({
-            rpcUrl: this.config.rpcUrl,
-            signerKey: agentKey,
-            owners: [agentAddress],
-            threshold: 1,
-        });
-        const deployTx = await safe.createSafeDeploymentTransaction();
-        const agentWallet = createJinnWalletClient(this.config.rpcUrl, this.chain, agentSigner);
-        const deployHash = await viemSendTransactionWithRetry(agentWallet, this.publicClient, {
-            account: agentSigner,
-            to: deployTx.to,
-            value: BigInt(deployTx.value),
-            data: deployTx.data,
-        });
-        const receipt = await waitForTransactionReceiptWithRetry(this.publicClient, deployHash);
-        if (receipt.status !== 'success') {
-            throw new Error(`Fleet Safe deployment tx failed: ${deployHash}`);
-        }
-        try {
-            await waitForContractCode(this.publicClient, getAddress(fleetSafe));
-        }
-        catch {
-            throw new Error(`Fleet Safe deployment succeeded but no code at ${fleetSafe}`);
-        }
-        console.error(`[fleet-bootstrap] Stage 1: fleet Safe deployed (tx=${deployHash})`);
-        return this.store.load(this.chain);
+        return stepFleetSafeDeployImpl(this.stepContext(), state, mnemonic);
     }
-    /** Mint the fleet agentId + bind Safe via setAgentWallet (ERC-1271). */
     async stepFleetIdentityRegister(state, mnemonic) {
-        const identityRegistry = this.config.identityRegistry ?? IDENTITY_REGISTRY_ADDRESSES[this.config.chainId];
-        if (!identityRegistry) {
-            throw new Error(`IdentityRegistry address not configured for chainId=${this.config.chainId}.`);
-        }
-        const fleetSafe = state.fleet_safe_address;
-        const agentSigner = deriveAgentSigner(mnemonic, 1);
-        const agentWallet = createJinnWalletClient(this.config.rpcUrl, this.chain, agentSigner);
-        // Mint agentId — empty agent URI for v0 (matches stepRegisterAgent §6.1 in spec).
-        const registerData = encodeFunctionData({
-            abi: IDENTITY_REGISTRY_ABI,
-            functionName: 'register',
-            args: [''],
-        });
-        console.error(`[fleet-bootstrap] Stage 1: minting fleet agentId ` +
-            `(IdentityRegistry=${identityRegistry}, agentEOA=${agentSigner.address})`);
-        const mintTxHash = await viemSendTransactionWithRetry(agentWallet, this.publicClient, {
-            account: agentSigner,
-            to: addr(identityRegistry),
-            data: registerData,
-        });
-        const mintReceipt = await waitForTransactionReceiptWithRetry(this.publicClient, mintTxHash);
-        if (mintReceipt.status !== 'success') {
-            throw new Error(`Fleet IdentityRegistry.register() failed: ${mintTxHash}`);
-        }
-        const fleetAgentId = this.parseAgentIdFromReceipt(mintReceipt, identityRegistry);
-        if (fleetAgentId === null) {
-            throw new Error(`Fleet IdentityRegistry.register() succeeded but Registered event missing (tx=${mintTxHash})`);
-        }
-        // Persist agentId IMMEDIATELY so a crash between mint and bind doesn't lose it.
-        await this.store.patchFleet({
-            fleet_agent_id: fleetAgentId,
-            fleet_identity_registry: getAddress(identityRegistry),
-        });
-        // Bind the Safe via setAgentWallet (ERC-1271).
-        // Wrapped in the freshly-deployed-Safe retry (jinn-mono-k1ng). The
-        // pre-k1ng single-attempt version halted bootstrap when the documented
-        // race fired on the first attempt — exactly the 2026-05-18 canary's
-        // second-time-around failure mode.
-        console.error(`[fleet-bootstrap] Stage 1: binding fleet Safe ${fleetSafe} to agentId=${fleetAgentId}`);
-        const bindResult = await this.bindAgentWalletWithRetry({
-            identityRegistryAddress: addr(identityRegistry),
-            agentId: BigInt(fleetAgentId),
-            safeAddress: addr(fleetSafe),
-            agentEoaAccount: agentSigner,
-            agentEoaWalletClient: agentWallet,
-            publicClient: this.publicClient,
-            chainId: this.config.chainId,
-        }, 'Stage 1');
-        if (!bindResult.ok) {
-            const bindErr = bindResult.error;
-            throw new Error(`Fleet setAgentWallet failed after ${this.safeBindingMaxAttempts} attempts: ${bindErr.shortMessage}` +
-                (bindErr.revertReason ? ` (revert: ${bindErr.revertReason})` : ''));
-        }
-        console.error(`[fleet-bootstrap] Stage 1: setAgentWallet succeeded (tx=${bindResult.txHash})`);
-        return this.store.patchFleet({ fleet_stage: 'stage1' });
+        return stepFleetIdentityRegisterImpl(this.stepContext(), state, mnemonic);
     }
     // ── Phase 2: Per-service bootstrap ───────────────────────────────────
     async bootstrapService(state, mnemonic, index) {
@@ -1047,25 +945,23 @@ export class FleetBootstrapper {
                 throw error;
             }
             if (onChainState === 2) {
-                console.error(`[jinn-earning] Noticed service ${svc.service_id} (fleet index ${index}) evicted on-chain; running distributor reStake to restake.`);
-                // #789: a startup reStake can revert (e.g. NotEnoughTimeStaked when the
-                // service was re-staked < minStakingDuration ago) or fail transiently.
-                // Treat it as non-fatal so the daemon still launches — work delivery and
-                // JINN claims are decoupled from OLAS staking (JinnDistributor mints on
-                // delivered-work counts, not stake state), so a failed startup reStake
-                // must not block the operator from earning. The standalone EvictionLoop
-                // retries on its own cadence when enabled; when staking is intentionally
-                // dropped (evictionCheckIntervalMs=0) this simply leaves the service
-                // evicted, which does not affect JINN earning.
-                try {
-                    state = await this.recoverEvictedService(state, mnemonic, index);
-                    svc = state.services.find(s => s.index === index);
-                }
-                catch (err) {
-                    console.error(`[jinn-earning] Service ${svc.service_id} (fleet index ${index}) startup reStake failed (non-fatal); ` +
-                        `continuing launch and deferring to EvictionLoop if enabled: ` +
-                        `${err instanceof Error ? err.message : String(err)}`);
-                }
+                // Do NOT eagerly reStake at startup. Re-staking is orthogonal to the
+                // protocol loop and to earning (OLAS staking rewards accrue from
+                // delivered-work activity counts, not from re-stake liveness), and an inline reStake
+                // here broadcasts from the agent EOA during boot — contending with
+                // other agent-EOA work that runs in the same window (e.g. a launch's
+                // IdentityRegistry.setMetadata, which then reverts and strands the
+                // launch at `launching`). #773 removed the inline reStake from the
+                // mech-adapter solve path with exactly this reasoning ("staking is
+                // orthogonal to the loop — re-staking is handled out-of-band by the
+                // background EvictionLoop"); this completes #773 for the startup-resume
+                // path it missed. The throttled EvictionLoop (#917) restakes on its own
+                // cadence when enabled; when staking is intentionally dropped
+                // (evictionCheckIntervalMs=0) the service simply stays evicted, which
+                // does not affect earning (#789).
+                console.log(`[jinn-earning] Service ${svc.service_id} (fleet index ${index}) is evicted on-chain; ` +
+                    `NOT reStaking inline at startup — deferring to the background EvictionLoop ` +
+                    `(staking is orthogonal to earning; #773/#789/#917). Daemon launch continues.`);
             }
         }
         if (isOperationalServiceStep(svc.step)) {
@@ -1870,6 +1766,38 @@ export class FleetBootstrapper {
         return this.store.updateService(index, { step: 'staked' });
     }
     // ── Helpers ──────────────────────────────────────────────────────────
+    /**
+     * Fresh dependency bag for an extracted step. Rebuilt on every call so a
+     * spy installed after construction is honoured; the spied helper arrows
+     * dispatch through `this` at call time (see plan Binding rule).
+     */
+    stepContext() {
+        return {
+            store: this.store,
+            config: this.config,
+            publicClient: this.publicClient,
+            chain: this.chain,
+            stakingMode: this.stakingMode,
+            targetServices: this.targetServices,
+            debug: this.debug,
+            env: this.env,
+            safeBindingMaxAttempts: this.safeBindingMaxAttempts,
+            safeBindingRetryDelayMs: this.safeBindingRetryDelayMs,
+            bindAgentWalletWithRetry: (args, label) => this.bindAgentWalletWithRetry(args, label),
+            getServiceState: (serviceId) => this.getServiceState(serviceId),
+            waitForSuccessfulTx: (txHash, label) => this.waitForSuccessfulTx(txHash, label),
+            firstServiceUpdate: (index, patch) => this.firstServiceUpdate(index, patch),
+            stakingAddressForService: (svc) => this.stakingAddressForService(svc),
+            shouldPreserveExistingSetup: (svc) => this.shouldPreserveExistingSetup(svc),
+            parseServiceIdFromReceipt: (receipt) => this.parseServiceIdFromReceipt(receipt),
+            parseMultisigFromReceipt: (receipt) => this.parseMultisigFromReceipt(receipt),
+            getStakingState: (serviceId, stakingAddress) => this.getStakingState(serviceId, stakingAddress),
+            getBondTokenBalance: (address) => this.getBondTokenBalance(address),
+            parseAgentIdFromReceipt: (receipt, identityRegistry) => this.parseAgentIdFromReceipt(receipt, identityRegistry),
+            stolasPreflightCheck: () => this.stolasPreflightCheck(),
+            sweepAbandonedSafeForService: (state, mnemonic, serviceIndex, abandonedSafeAddress) => this.sweepAbandonedSafeForService(state, mnemonic, serviceIndex, abandonedSafeAddress),
+        };
+    }
     async getBondTokenBalance(address) {
         return this.publicClient.readContract({
             address: this.config.olasToken,
@@ -1944,76 +1872,37 @@ export class FleetBootstrapper {
         }));
     }
     async parseServiceIdFromReceipt(receipt) {
-        const createServiceTopic = EVENT_TOPICS.CreateService;
-        const serviceRegistryAddress = this.config.serviceRegistry.toLowerCase();
-        for (const log of receipt.logs) {
-            if (log.address.toLowerCase() !== serviceRegistryAddress ||
-                log.topics[0] !== createServiceTopic) {
-                continue;
-            }
-            try {
-                const decoded = decodeEventLog({
-                    abi: SERVICE_REGISTRY_L2_ABI,
-                    data: log.data,
-                    topics: log.topics,
-                    strict: false,
-                });
-                if (decoded.eventName === 'CreateService' && 'serviceId' in decoded.args) {
-                    return Number(decoded.args.serviceId);
-                }
-            }
-            catch {
-                // Not a matching event
-            }
-        }
-        return null;
+        return parseServiceIdFromReceiptImpl(receipt, this.config.serviceRegistry);
     }
     parseMultisigFromReceipt(receipt) {
-        const topic = EVENT_TOPICS.CreateMultisigWithAgents;
-        for (const log of receipt.logs) {
-            const t0 = log.topics[0];
-            if (t0 === topic && log.topics.length >= 3) {
-                return getAddress(('0x' + log.topics[2].slice(26)));
-            }
-        }
-        return null;
+        return parseMultisigFromReceiptImpl(receipt);
     }
-    /**
-     * Extract `agentId` from an `IdentityRegistry.Registered` log emitted in
-     * the receipt. Filters by `(address, topic[0])` first to avoid colliding
-     * with any other contract that happens to share the event signature.
-     *
-     * Returns the agentId as a decimal string (uint256) so it round-trips
-     * cleanly through JSON-persisted EarningState.
-     */
     parseAgentIdFromReceipt(receipt, identityRegistry) {
-        const topic = EVENT_TOPICS.Registered;
-        const target = identityRegistry.toLowerCase();
-        for (const log of receipt.logs) {
-            if (log.address.toLowerCase() !== target)
-                continue;
-            if (log.topics[0] !== topic)
-                continue;
-            try {
-                const decoded = decodeEventLog({
-                    abi: IDENTITY_REGISTRY_ABI,
-                    data: log.data,
-                    topics: log.topics,
-                    strict: false,
-                });
-                if (decoded.eventName === 'Registered' && 'agentId' in decoded.args) {
-                    return decoded.args.agentId.toString();
-                }
-            }
-            catch {
-                // Not a matching event
-            }
-        }
-        return null;
+        return parseAgentIdFromReceiptImpl(receipt, identityRegistry);
     }
 }
 /** @deprecated Use FleetBootstrapper */
 export const EarningBootstrapper = FleetBootstrapper;
+/**
+ * Inspect a mined reStake receipt and log the correct outcome (#916).
+ *
+ * Pure + I/O-free so it can be unit-tested without a chain client. On a
+ * `success` receipt it logs `reStake confirmed` at log level. On a `reverted`
+ * receipt it logs `reStake reverted` at debug level (a benign substrate event —
+ * the NotEnoughTimeStaked window / stale-RPC race; staking is non-load-bearing,
+ * DR-2026-06-04 / #1060) with the decoded reason if the caller could obtain one,
+ * and still throws so the recovery attempt re-queues (#916 control flow intact).
+ */
+export function handleReStakeReceipt(args) {
+    const { receipt, serviceDisplayIndex, reStakeHash, revertReason } = args;
+    if (receipt.status === 'success') {
+        console.log(`[eviction-recovery] Service ${serviceDisplayIndex}: reStake confirmed (tx: ${reStakeHash})`);
+        return;
+    }
+    const msg = `[eviction-recovery] Service ${serviceDisplayIndex}: reStake reverted (tx: ${reStakeHash}, reason: ${revertReason ?? 'unavailable'})`;
+    console.debug(msg);
+    throw new Error(msg);
+}
 /**
  * Re-stake an evicted service by calling `distributor.reStake(stakingProxy, serviceId)`.
  *
@@ -2034,7 +1923,7 @@ export async function recoverEvictedService(opts) {
         functionName: 'reStake',
         args: [addr(stakingAddress), BigInt(serviceId)],
     });
-    console.error(`[eviction-recovery] Service ${serviceDisplayIndex}: calling distributor.reStake() for evicted service ${serviceId}`);
+    console.debug(`[eviction-recovery] Service ${serviceDisplayIndex}: calling distributor.reStake() for evicted service ${serviceId}`);
     let reStakeHash;
     try {
         reStakeHash = await viemSendTransactionWithRetry(masterWallet, publicClient, {
@@ -2055,9 +1944,21 @@ export async function recoverEvictedService(opts) {
         throw err;
     }
     const receipt = await waitForTransactionReceiptWithRetry(publicClient, reStakeHash);
+    let revertReason;
     if (receipt.status !== 'success') {
-        throw new Error(`reStake failed for service ${serviceDisplayIndex}: ${reStakeHash}`);
+        // Best-effort: replay the call at the mined block to decode the revert.
+        try {
+            await publicClient.call({
+                account: masterAccount,
+                to: addr(distributorAddress),
+                data: reStakeData,
+                blockNumber: receipt.blockNumber,
+            });
+        }
+        catch (err) {
+            revertReason = formatKnownRevert(err) ?? flattenErrorMessage(err);
+        }
     }
-    console.error(`[eviction-recovery] Service ${serviceDisplayIndex}: reStake confirmed (tx: ${reStakeHash})`);
+    handleReStakeReceipt({ receipt, serviceDisplayIndex, reStakeHash, revertReason });
 }
 //# sourceMappingURL=bootstrap.js.map