@elgora/cli 7.5.1 → 8.0.0

package/README.md

@@ -41,7 +41,8 @@ answer.
   on ElgoraHub.
 - `guardian:deliver-key` wraps one Solver–Submission content key for delivery
   so the funding Poster can retrieve the winning work; idempotent, and accepted
-  only for the pair ElgoraHub currently records or the finalized winner.
+  only for the pair ElgoraHub currently records or the finalized winner. While
+  a settlement is not yet finalized it delivers nothing and exits `75`.
 - `claim` prepares or sends the winning Solver's reserved award or the
   Poster's queued refund, as selected from finalized ElgoraHub state.
 - `verification-record` is a plain, unauthenticated GET that fetches or lazily
@@ -79,6 +80,11 @@ needs.
 
 ## Deployment configuration
 
+Since 8.0.0 the default deployment is **Base mainnet** (`base`, chain `8453`),
+which escrows real USDC. Elgora's staging deployment runs on **Base Sepolia**
+(`base-sepolia`, chain `84532`) behind `https://staging.elgora.ai`. A run that
+selects no network prints one stderr line saying it used the default.
+
 Every command accepts `--network <name|chain id>`, which selects the deployment
 for that invocation without touching the environment. It takes a network name
 (`base`, `base-sepolia`, `local`) or that network's chain id (`8453`, `84532`,
@@ -86,9 +92,10 @@ for that invocation without touching the environment. It takes a network name
 passed — for that run only:
 
 ```sh
-elgora-cli guardian:judgeable                        # the default deployment
-elgora-cli claim --network base-sepolia 7            # one invocation, by name
+elgora-cli guardian:judgeable                        # Base mainnet, the default
+elgora-cli claim --network base-sepolia 7            # staging, by name
 elgora-cli claim --network 84532 7                   # the same, by chain id
+export ELGORA_CHAIN_ID=84532                         # staging for every run in this shell
 ```
 
 The chain's public RPC, the ElgoraHub address, the escrow token, and the subgraph
@@ -101,10 +108,11 @@ and which values it defaults. Supply a complete, coherent configuration when
 targeting a deployment this CLI release does not know about, and do not mix
 addresses or endpoints from different deployments.
 
-Commands that use the public API accept `--api-base-url <url>`. That is a
-separate choice from the chain: it names one API deployment, and the flag wins
-over `ELGORA_API_BASE_URL` for that invocation. Point it at an API serving the
-deployment you selected.
+The API follows the chain too: `https://elgora.ai` for `base` and
+`https://staging.elgora.ai` for `base-sepolia`. Commands that use the public API
+accept `--api-base-url <url>`, which wins over `ELGORA_API_BASE_URL` and that
+default for one invocation — for example to reach a Vercel preview. Point it at
+an API serving the deployment you selected.
 
 Protected API reads and writes use one EIP-712 approval per request. The
 signature is bound to the method, path, body, query, API host, and a recent

package/dist/cli.js

@@ -1352,8 +1352,8 @@ function readFrontmatter(markdown, issues) {
     return null;
   }
 }
-function resolveProfile(declared, fallback, issues) {
-  const pinned = getProtocolProfile(declared) ?? (declared === fallback.profile ? fallback : null);
+function resolveProfile(declared, fallback2, issues) {
+  const pinned = getProtocolProfile(declared) ?? (declared === fallback2.profile ? fallback2 : null);
   if (pinned === null) {
     issues.push({
       code: "profile_unknown",
@@ -1486,19 +1486,30 @@ function parseInlineList(value) {
 }
 
 // ../../packages/core/src/deployments.ts
-import { baseSepolia as baseSepolia2 } from "viem/chains";
+import { base as base2, baseSepolia as baseSepolia2 } from "viem/chains";
 var DEPLOYMENTS = {
+  [base2.id]: {
+    ELGORA_HUB_ADDRESS: "0x8f80d1183cd983b01b0c9ac6777cc732ec9800de",
+    ELGORA_ESCROW_TOKEN_ADDRESS: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    payoutSchemeAddress: "0x36d304993cb1575a2f9b8a0388b18aa5ec6d7a61",
+    ELGORA_SUBGRAPH_ENDPOINT: "https://api.goldsky.com/api/public/project_cmtu7wslg04s501ovc2je3beh/subgraphs/elgora-elgorahub-base/production/gn",
+    ELGORA_API_BASE_URL: "https://elgora.ai",
+    deployBlock: 51752389,
+    deployTransaction: "0xd62f407b770c8fca82a9704b30ed0605d9e3ed2b56278dcca152958063f7f469",
+    sourceCommit: "8d40270d617a63dd5a7a35045db0d9ea3ddd9093"
+  },
   [baseSepolia2.id]: {
     ELGORA_HUB_ADDRESS: "0x2f97b5f616495c2e923f39a46648eb783c053ad7",
     ELGORA_ESCROW_TOKEN_ADDRESS: "0x036cbd53842c5426634e7929541ec2318f3dcf7e",
     payoutSchemeAddress: "0x752d4305b8567b777d479dfa9847dc4f5ffb5750",
     ELGORA_SUBGRAPH_ENDPOINT: "https://api.goldsky.com/api/public/project_cmtu7wslg04s501ovc2je3beh/subgraphs/elgora-elgorahub/testnet-production/gn",
+    ELGORA_API_BASE_URL: "https://staging.elgora.ai",
     deployBlock: 46353511,
     deployTransaction: "0xed3d3c8af3c69f9f8d4ec47da7179fe4b89bd4a4cd8d8232dbbd3d3f3d38e74b",
     sourceCommit: "1377da5c38dc5c90d8608ffa3cb15ad6f8567a01"
   }
 };
-var DEFAULT_CHAIN_ID = baseSepolia2.id;
+var DEFAULT_CHAIN_ID = base2.id;
 function getDeployment(chainId) {
   return DEPLOYMENTS[chainId];
 }
@@ -4716,20 +4727,52 @@ function invalidWrittenVerdict(path5, message) {
 import {
   createPublicClient,
   createWalletClient,
+  fallback,
   http
 } from "viem";
+
+// ../../packages/core/src/auth/freshness.ts
+var API_REQUEST_APPROVAL_ANCHOR_LAG_SECONDS = 6;
+var FALLBACK_BLOCK_TIME_MS = 2e3;
+function blockTimeMsFor(chainId) {
+  const chain = chainId === void 0 ? void 0 : SUPPORTED_CHAINS[chainId];
+  return chain?.blockTime ?? FALLBACK_BLOCK_TIME_MS;
+}
+function blocksForSeconds(seconds, chainId) {
+  const blocks = Math.ceil(seconds * 1e3 / blockTimeMsFor(chainId));
+  return BigInt(Math.max(1, blocks));
+}
+function apiRequestApprovalAnchorLagBlocks(chainId) {
+  return blocksForSeconds(API_REQUEST_APPROVAL_ANCHOR_LAG_SECONDS, chainId);
+}
+
+// ../../packages/core/src/chain-client.ts
 var RPC_RETRY_COUNT = 3;
+function createChainTransport(chainId, rpcUrl) {
+  const publicRpcUrl = resolveSupportedChain(chainId).rpcUrls.default.http[0];
+  const configuredRpcUrl = rpcUrl?.trim() || publicRpcUrl;
+  if (!publicRpcUrl || configuredRpcUrl === publicRpcUrl) {
+    return http(configuredRpcUrl, { retryCount: RPC_RETRY_COUNT });
+  }
+  return fallback(
+    [
+      http(configuredRpcUrl, { retryCount: 0 }),
+      http(publicRpcUrl, { retryCount: 0 })
+    ],
+    { retryCount: RPC_RETRY_COUNT }
+  );
+}
 function createChainPublicClient(chainId, rpcUrl) {
   return createPublicClient({
     chain: resolveSupportedChain(chainId),
-    transport: http(rpcUrl, { retryCount: RPC_RETRY_COUNT })
+    transport: createChainTransport(chainId, rpcUrl)
   });
 }
 function createChainWalletClient(chainId, rpcUrl, account) {
   return createWalletClient({
     account,
     chain: resolveSupportedChain(chainId),
-    transport: http(rpcUrl, { retryCount: RPC_RETRY_COUNT })
+    transport: createChainTransport(chainId, rpcUrl)
   });
 }
 function assertChainId(actual, expected) {
@@ -4737,10 +4780,10 @@ function assertChainId(actual, expected) {
     throw new Error(`RPC returned chain_id ${actual}, expected ${expected}`);
   }
 }
-var SIGNING_BLOCK_OFFSET = 3n;
 async function fetchSignableBlock(client) {
+  const offset = apiRequestApprovalAnchorLagBlocks(client.chain?.id);
   const head = await client.getBlockNumber();
-  const anchorNumber = head > SIGNING_BLOCK_OFFSET ? head - SIGNING_BLOCK_OFFSET : 0n;
+  const anchorNumber = head > offset ? head - offset : 0n;
   const anchor = await client.getBlock({ blockNumber: anchorNumber });
   return { number: anchor.number, hash: anchor.hash };
 }
@@ -5032,7 +5075,6 @@ function loadClaimConfig(env, claimantAddress) {
 }
 
 // ../../packages/core/src/api-client-config.ts
-var PRODUCTION_API_BASE_URL = "https://elgora.vercel.app";
 var LOCAL_DEV_API_BASE_URL = "http://127.0.0.1:3000";
 var API_BASE_URL_FLAG = "--api-base-url";
 function loadApiClientConfig(env, apiBaseUrlOverride) {
@@ -5060,7 +5102,15 @@ function resolveApiBaseUrl(env, override) {
   return value;
 }
 function defaultApiBaseUrl(env) {
-  return env.NODE_ENV === "development" ? LOCAL_DEV_API_BASE_URL : PRODUCTION_API_BASE_URL;
+  if (env.NODE_ENV === "development") return LOCAL_DEV_API_BASE_URL;
+  const chainId = Number(env.ELGORA_CHAIN_ID?.trim() || DEFAULT_CHAIN_ID);
+  const recorded = getDeployment(chainId)?.ELGORA_API_BASE_URL;
+  if (!recorded) {
+    throw new Error(
+      `No Elgora API is recorded for chain ${chainId}; set ELGORA_API_BASE_URL or pass --api-base-url`
+    );
+  }
+  return recorded;
 }
 
 // ../../packages/core/src/api-client.ts
@@ -5581,6 +5631,7 @@ function readGuardianPrivateKeys(env) {
 }
 
 // src/guardian-deliver-key.ts
+var PENDING_FINALITY_EXIT_CODE = 75;
 var USAGE = "Usage: elgora-cli guardian:deliver-key <bounty_id> <solver> <submission_commitment>";
 async function main4(env = process.env, argv = process.argv.slice(2)) {
   const { apiBaseUrl, argv: positionalArgs } = extractApiBaseUrlFlag(argv);
@@ -5595,6 +5646,33 @@ async function main4(env = process.env, argv = process.argv.slice(2)) {
       "ELGORA_GUARDIAN_ACCOUNT_PRIVATE_KEY must be a 32-byte hex private key"
     );
   }
+  const guardianPrivateKeys = readGuardianPrivateKeys(env);
+  const publicClient = createChainPublicClient(config.chainId, rpcUrl);
+  const finality = await readSettlementFinality(
+    publicClient,
+    config.hubAddress,
+    bountyId
+  );
+  if (finality.latestStatus === "no_valid_submission" || finality.latestStatus === "timed_out") {
+    throw new Error(
+      `Bounty ${bountyId.toString()} settled ${finality.latestStatus}; there is no winning key to deliver`
+    );
+  }
+  if (finality.pending) {
+    console.log(
+      JSON.stringify({
+        event: "guardian_deliver_key.pending_finality",
+        bounty_id: bountyId.toString(),
+        solver,
+        submission_commitment: submissionCommitment,
+        latest_status: finality.latestStatus,
+        finalized_status: finality.finalizedStatus,
+        message: "Settlement is not behind the chain's finalized tag yet; nothing was delivered. Retry in 10-20 minutes."
+      })
+    );
+    process.exitCode = PENDING_FINALITY_EXIT_CODE;
+    return;
+  }
   const account = privateKeyToAccount4(guardianAccountPrivateKey);
   const wrapped = await wrapWinningSolutionKey({
     config,
@@ -5605,8 +5683,8 @@ async function main4(env = process.env, argv = process.argv.slice(2)) {
       privateKey: guardianAccountPrivateKey,
       address: account.address
     },
-    publicClient: createChainPublicClient(config.chainId, rpcUrl),
-    guardianPrivateKeys: readGuardianPrivateKeys(env)
+    publicClient,
+    guardianPrivateKeys
   });
   console.log(
     JSON.stringify({
@@ -5618,6 +5696,30 @@ async function main4(env = process.env, argv = process.argv.slice(2)) {
     })
   );
 }
+async function readSettlementFinality(publicClient, hubAddress, bountyId) {
+  const finalizedBlock = await publicClient.getBlock({
+    blockTag: "finalized"
+  });
+  const readStatus = async (blockNumber) => {
+    const [, state] = await publicClient.readContract({
+      address: hubAddress,
+      abi: ELGORA_HUB_BOUNTY_READ_ABI,
+      functionName: "getBounty",
+      args: [bountyId],
+      ...blockNumber === void 0 ? {} : { blockNumber }
+    });
+    return decodeBountyStatus(state.status);
+  };
+  const [latestStatus, finalizedStatus] = await Promise.all([
+    readStatus(),
+    readStatus(finalizedBlock.number)
+  ]);
+  return {
+    pending: latestStatus === "awarded" && finalizedStatus === "open",
+    latestStatus,
+    finalizedStatus
+  };
+}
 function readArgs(argv) {
   const [bountyId, solver, submissionCommitment] = argv;
   if (!bountyId || !isNumeric(bountyId) || !solver || !isHexAddress(solver) || !submissionCommitment || !isHexBytes32(submissionCommitment)) {
@@ -5754,6 +5856,13 @@ var BOUNTY_DETAIL_QUERY = `
       reportCommitments
       awardedPayoutData
       timedOutRefundAmount
+      settledLogIndex
+      claimsQueued(first: 1, orderBy: queuedLogIndex, orderDirection: desc) {
+        recipient
+        amount
+        queuedTxHash
+        queuedLogIndex
+      }
       guardianRoster {
         ${GUARDIAN_ROSTER_SNAPSHOT_FIELDS}
       }
@@ -6131,8 +6240,17 @@ function mapAnalyticsGuardianRoster(row) {
 }
 function mapBountyDetail(row) {
   const record = readRecord(row);
+  const allocation = record.claimsQueued == null ? null : asArray(record.claimsQueued, "claimsQueued")[0];
+  let guardianFeeAmount = null;
+  if ((record.status === "Awarded" || record.status === "NoValidSubmission") && allocation && record.settledTxHash && record.settledLogIndex != null) {
+    const claim = readRecord(allocation);
+    if (asHex(claim.recipient, "recipient") === asHex(record.guardianFeeRecipient, "guardianFeeRecipient") && asHex(claim.queuedTxHash, "queuedTxHash") === asHex(record.settledTxHash, "settledTxHash") && asNumber(claim.queuedLogIndex, "queuedLogIndex") + 1 === asNumber(record.settledLogIndex, "settledLogIndex")) {
+      guardianFeeAmount = asString(claim.amount, "amount");
+    }
+  }
   return {
     ...mapBounty(record),
+    guardianFeeAmount,
     guardianRosterAdmin: asHex(
       record.guardianRosterAdmin,
       "guardianRosterAdmin"
@@ -6586,7 +6704,10 @@ function parseChallenge(text) {
 
 // src/guardian-verdict.ts
 import { readFile as readFile3 } from "fs/promises";
-import { zeroAddress as zeroAddress4 } from "viem";
+import {
+  BaseError as BaseError2,
+  zeroAddress as zeroAddress4
+} from "viem";
 import { privateKeyToAccount as privateKeyToAccount6 } from "viem/accounts";
 var OUTCOME = {
   no_valid_submission: 0,
@@ -6797,20 +6918,66 @@ async function main7(env = process.env, argv = process.argv.slice(2)) {
     functionName: "commitVerdict",
     args: contractArgs
   });
+  const replacements = [];
   const receipt = await publicClient.waitForTransactionReceipt({
-    hash: transactionHash
+    hash: transactionHash,
+    onReplaced: (replacement) => replacements.push(replacement)
   });
+  if (receipt.transactionHash !== transactionHash && replacements.at(-1)?.reason !== "repriced") {
+    throw new Error(
+      `commitVerdict transaction ${transactionHash} was ${replacements.at(-1)?.reason ?? "replaced"} by ${receipt.transactionHash}; this Verdict was not recorded`
+    );
+  }
   if (receipt.status !== "success") {
-    throw new Error(`commitVerdict transaction reverted: ${transactionHash}`);
+    throw new Error(
+      `commitVerdict transaction reverted: ${receipt.transactionHash}`
+    );
   }
-  const recorded = await publicClient.readContract({
-    address: config.hubAddress,
-    abi: ELGORA_HUB_VERDICT_WRITE_ABI,
-    functionName: "verdicts",
-    args: [args.bountyId, account.address]
-  });
-  if (!recorded[0] || recorded[1] !== contractArgs[1] || recorded[2].toLowerCase() !== contractArgs[2].toLowerCase() || recorded[3].toLowerCase() !== contractArgs[3].toLowerCase() || recorded[4].toLowerCase() !== reportCommitment || recorded[5].toLowerCase() !== "0x") {
-    throw new Error("ElgoraHub did not record the expected on-chain Verdict");
+  let readbackIssue;
+  try {
+    const recorded = await publicClient.readContract({
+      address: config.hubAddress,
+      abi: ELGORA_HUB_VERDICT_WRITE_ABI,
+      functionName: "verdicts",
+      args: [args.bountyId, account.address],
+      blockNumber: receipt.blockNumber
+    });
+    if (!recorded[0] || recorded[1] !== contractArgs[1] || recorded[2].toLowerCase() !== contractArgs[2].toLowerCase() || recorded[3].toLowerCase() !== contractArgs[3].toLowerCase() || recorded[4].toLowerCase() !== reportCommitment || recorded[5].toLowerCase() !== "0x") {
+      readbackIssue = {
+        observed: {
+          committed: recorded[0],
+          outcome: recorded[1],
+          winner: recorded[2],
+          awarded_submission_commitment: recorded[3],
+          report_commitment: recorded[4],
+          payout_data: recorded[5]
+        }
+      };
+    }
+  } catch (error) {
+    readbackIssue = {
+      error: error instanceof BaseError2 ? error.walk().name : error instanceof Error ? error.name : "UnknownError"
+    };
+  }
+  if (readbackIssue) {
+    console.warn(
+      JSON.stringify({
+        event: "guardian_verdict.readback_unconfirmed",
+        bounty_id: args.bountyId.toString(),
+        guardian: account.address.toLowerCase(),
+        tx_hash: receipt.transactionHash,
+        block_number: receipt.blockNumber.toString(),
+        expected: {
+          committed: true,
+          outcome: contractArgs[1],
+          winner: contractArgs[2],
+          awarded_submission_commitment: contractArgs[3],
+          report_commitment: reportCommitment,
+          payout_data: "0x"
+        },
+        ...readbackIssue
+      })
+    );
   }
   console.log(
     JSON.stringify({
@@ -6823,7 +6990,7 @@ async function main7(env = process.env, argv = process.argv.slice(2)) {
         awarded_submission_commitment: args.awardedSubmissionCommitment
       } : {},
       report_commitment: reportCommitment,
-      tx_hash: transactionHash,
+      tx_hash: receipt.transactionHash,
       block_number: receipt.blockNumber.toString()
     })
   );
@@ -6874,14 +7041,40 @@ function usageError() {
 }
 
 // src/network-flag.ts
-import { base as base2, baseSepolia as baseSepolia3, foundry as foundry3 } from "viem/chains";
+import { base as base3, baseSepolia as baseSepolia3, foundry as foundry3 } from "viem/chains";
 var NETWORK_FLAG = "--network";
-var NETWORK_CHAIN_IDS = {
-  base: base2.id,
-  "base-sepolia": baseSepolia3.id,
-  local: foundry3.id
-};
-var NETWORK_NAMES_HINT = Object.entries(NETWORK_CHAIN_IDS).map(([name, chainId]) => `${name} (${chainId})`).join(", ");
+var NETWORKS = [
+  { name: "base", chainId: base3.id, label: "Base mainnet" },
+  {
+    name: "base-sepolia",
+    chainId: baseSepolia3.id,
+    label: "Base Sepolia testnet, Elgora's staging deployment"
+  },
+  { name: "local", chainId: foundry3.id, label: "a local Anvil stack" }
+];
+var NETWORK_CHAIN_IDS = Object.fromEntries(
+  NETWORKS.map(({ name, chainId }) => [name, chainId])
+);
+var STAGING_NETWORK = NETWORKS.find(
+  ({ chainId }) => chainId === baseSepolia3.id
+);
+var NETWORK_NAMES_HINT = NETWORKS.map(
+  ({ name, chainId }) => `${name} (${chainId})`
+).join(", ");
+function describeChain(chainId) {
+  const network = NETWORKS.find((candidate) => candidate.chainId === chainId);
+  return network ? `${network.name} (${network.label})` : `chain ${chainId}`;
+}
+var STAGING_HINT = `add ${NETWORK_FLAG} ${STAGING_NETWORK.name} or set ELGORA_CHAIN_ID=${STAGING_NETWORK.chainId}`;
+var DEFAULT_NETWORK_HELP_LINES = [
+  `Default: ${describeChain(DEFAULT_CHAIN_ID)}.`,
+  `Staging: ${describeChain(STAGING_NETWORK.chainId)};`,
+  `  ${STAGING_HINT}.`
+];
+function defaultNetworkNotice(env) {
+  if (env.ELGORA_CHAIN_ID?.trim()) return void 0;
+  return `elgora-cli: using the default network, ${describeChain(DEFAULT_CHAIN_ID)}. For staging, ${STAGING_HINT}.`;
+}
 function applyNetworkFlag(env, argv) {
   const present = argv.some(
     (arg) => arg === NETWORK_FLAG || arg.startsWith(`${NETWORK_FLAG}=`)
@@ -6907,7 +7100,7 @@ function resolveChainId(selector) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "7.5.1" : "0.0.0-dev";
+var CLI_VERSION = true ? "8.0.0" : "0.0.0-dev";
 var CLI_NODE_ENGINES = true ? ">=24 <25" : ">=24 <25";
 
 // src/node-engines.ts
@@ -8404,7 +8597,7 @@ var COMMAND_HELP = {
   "guardian:deliver-key": {
     usage: "elgora-cli guardian:deliver-key <bounty_id> <solver> <submission_commitment>",
     title: "Deliver the finalized winner's content key for Poster retrieval.",
-    description: "Required after a bounty finalizes `awarded`: wrap the winning\n  Submission's key so the funding Poster can retrieve the work. Read the\n  winning Solver and Submission from ElgoraHub's finalized state (the\n  subgraph), not from a local Verdict, and pass exactly that pair. The\n  API rechecks against ElgoraHub and accepts only the current active or\n  finalized winner; written Verdicts and local state authorize nothing.\n  Idempotent \u2014 safe to re-run and safe if another Guardian already did it.",
+    description: "Required after a bounty finalizes `awarded`: wrap the winning\n  Submission's key so the funding Poster can retrieve the work. Read the\n  winning Solver and Submission from ElgoraHub's finalized state (the\n  subgraph), not from a local Verdict, and pass exactly that pair. The\n  API rechecks against ElgoraHub and accepts only the current active or\n  finalized winner; written Verdicts and local state authorize nothing.\n  Idempotent \u2014 safe to re-run and safe if another Guardian already did it.\n  Until the settlement block is behind the chain's finalized tag (about\n  10-20 minutes after settlement) it delivers nothing, prints\n  guardian_deliver_key.pending_finality, and exits 75; retry later.",
     required: [
       "ELGORA_GUARDIAN_ACCOUNT_PRIVATE_KEY",
       "ELGORA_GUARDIAN_PRIVATE_KEYS_JSON"
@@ -8546,6 +8739,11 @@ async function run(rawArgv) {
     process.exitCode = 1;
     return;
   }
+  const networkNotice = COMMAND_HELP[subcommand]?.defaulted?.includes(
+    "ELGORA_CHAIN_ID"
+  ) ? defaultNetworkNotice(env) : void 0;
+  if (networkNotice) process.stderr.write(`${networkNotice}
+`);
   const missing = missingRequiredEnv(
     COMMAND_HELP[subcommand]?.required ?? [],
     env
@@ -8580,6 +8778,7 @@ function printUsage() {
       "",
       `Every command accepts ${NETWORK_FLAG} <name|chain id> to select the`,
       `deployment for that invocation. Supported: ${NETWORK_NAMES_HINT}.`,
+      ...DEFAULT_NETWORK_HELP_LINES,
       "",
       "Run `elgora-cli help <command>` for exact arguments and configuration.",
       "Run `elgora-cli --version` to print this release's version."
@@ -8615,7 +8814,8 @@ function printCommandHelpOrUsage(name) {
       "",
       `Accepts ${NETWORK_FLAG} <name|chain id>; it sets ELGORA_CHAIN_ID for`,
       "this invocation, winning over the environment.",
-      `Supported: ${NETWORK_NAMES_HINT}.`
+      `Supported: ${NETWORK_NAMES_HINT}.`,
+      ...DEFAULT_NETWORK_HELP_LINES
     );
   }
   if (help.apiBaseUrlFlag) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elgora/cli",
-  "version": "7.5.1",
+  "version": "8.0.0",
   "description": "Command-line client for Elgora, a decentralized bounty marketplace for science. Lets Posters, Solvers, and Guardians interact with Elgora's public API and on-chain contracts.",
   "type": "module",
   "license": "MIT",