@jinn-network/client 0.1.9 → 0.2.0

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';
@@ -22,8 +22,13 @@ import { createJinnPublicClient, createJinnWalletClient } from './viem-clients.j
 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;
 /**
@@ -149,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;
 /**
@@ -783,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) {
@@ -1069,8 +946,8 @@ export class FleetBootstrapper {
             }
             if (onChainState === 2) {
                 // Do NOT eagerly reStake at startup. Re-staking is orthogonal to the
-                // protocol loop and to JINN earning (JinnDistributor mints on
-                // delivered-work counts, not OLAS stake state), and an inline reStake
+                // 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
@@ -1082,7 +959,7 @@ export class FleetBootstrapper {
                 // cadence when enabled; when staking is intentionally dropped
                 // (evictionCheckIntervalMs=0) the service simply stays evicted, which
                 // does not affect earning (#789).
-                console.error(`[jinn-earning] Service ${svc.service_id} (fleet index ${index}) is evicted on-chain; ` +
+                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.`);
             }
@@ -1889,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,
@@ -1963,72 +1872,13 @@ 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 */
@@ -2037,18 +1887,20 @@ 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`. On a `reverted` receipt it
- * logs `reStake reverted` at error level (with the decoded reason if the
- * caller could obtain one) and throws so the recovery attempt re-queues.
+ * `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.error(`[eviction-recovery] Service ${serviceDisplayIndex}: reStake confirmed (tx: ${reStakeHash})`);
+        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.error(msg);
+    console.debug(msg);
     throw new Error(msg);
 }
 /**
@@ -2071,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, {