diff --git a/content/api-references/genlayer-node/content.mdx b/content/api-references/genlayer-node/content.mdx
index b57b37eb..d69244a0 100644
--- a/content/api-references/genlayer-node/content.mdx
+++ b/content/api-references/genlayer-node/content.mdx
@@ -34,11 +34,11 @@ The GenLayer Node also supports Ethereum-compatible methods that are proxied to
- `eth_call`
- And other standard Ethereum JSON-RPC methods
-## zkSync Compatibility
+## Legacy `zksync` group (`zks_*`)
-[zkSync-compatible](https://docs.zksync.io/zksync-protocol/api/zks-rpc) methods are also supported and proxied to the underlying infrastructure. These methods are prefixed with `zks_`.
+The node still has an RPC group named `zksync`. It forwards any `zks_*` method unchanged to the GenLayer Chain RPC configured in `rollup.genlayerchainrpcurl`. The name is a legacy one: GenLayer Chain is now an Arbitrum Orbit L2, not a zkSync chain, and its RPC does not serve `zks_*` methods. An enabled group therefore returns the chain's "method not found" error (`-32601`) for these calls.
-The default `config.yaml` turns the `zksync` group off (`node.rpc.endpoints.zksync.enabled: false`). Set it to `true` to forward `zks_*` calls.
+The default `config.yaml` turns the `zksync` group off (`node.rpc.endpoints.zksync.enabled: false`). Keep it off. The key is still accepted, so existing configs that set it continue to load.
## Usage Examples
diff --git a/pages/FAQ.mdx b/pages/FAQ.mdx
index 8e9e3b33..ca61b00b 100644
--- a/pages/FAQ.mdx
+++ b/pages/FAQ.mdx
@@ -8,7 +8,7 @@ description: "Frequently asked questions about GenLayer: Intelligent Contracts,
What is GenLayer?
- GenLayer is the **adjudication layer for the agentic economy**. It uses decentralized AI-validator consensus to resolve contracts that require judgment, not just code. It's built as an L2 on zkSync Elastic Chain, anchoring to Ethereum's security. Contracts on GenLayer — called **Intelligent Contracts** — can interpret language, process images, fetch live web data, and reach consensus on contested or subjective outcomes. See [What is GenLayer](/understand-genlayer-protocol/what-is-genlayer).
+ GenLayer is the **adjudication layer for the agentic economy**. It uses decentralized AI-validator consensus to resolve contracts that require judgment, not just code. Its onchain layer, GenLayer Chain, is an Arbitrum Orbit L2 that settles to Ethereum. Contracts on GenLayer — called **Intelligent Contracts** — can interpret language, process images, fetch live web data, and reach consensus on contested or subjective outcomes. See [What is GenLayer](/understand-genlayer-protocol/what-is-genlayer).
@@ -99,7 +99,7 @@ description: "Frequently asked questions about GenLayer: Intelligent Contracts,
- Token holders delegate stake to validators, incentivizing honest behavior
- Multiple validators independently verify each transaction
- Appeals provide a failsafe — dishonest validators get slashed
- - The system anchors to Ethereum via zkSync for finality
+ - GenLayer Chain is an Arbitrum Orbit L2 that settles to Ethereum: its state is asserted on Ethereum and confirmed there after a challenge period
diff --git a/pages/api-references/genlayer-node.mdx b/pages/api-references/genlayer-node.mdx
index 33c51780..60340aaf 100644
--- a/pages/api-references/genlayer-node.mdx
+++ b/pages/api-references/genlayer-node.mdx
@@ -1657,11 +1657,11 @@ The GenLayer Node also supports Ethereum-compatible methods that are proxied to
- `eth_call`
- And other standard Ethereum JSON-RPC methods
-## zkSync Compatibility
+## Legacy `zksync` group (`zks_*`)
-[zkSync-compatible](https://docs.zksync.io/zksync-protocol/api/zks-rpc) methods are also supported and proxied to the underlying infrastructure. These methods are prefixed with `zks_`.
+The node still has an RPC group named `zksync`. It forwards any `zks_*` method unchanged to the GenLayer Chain RPC configured in `rollup.genlayerchainrpcurl`. The name is a legacy one: GenLayer Chain is now an Arbitrum Orbit L2, not a zkSync chain, and its RPC does not serve `zks_*` methods. An enabled group therefore returns the chain's "method not found" error (`-32601`) for these calls.
-The default `config.yaml` turns the `zksync` group off (`node.rpc.endpoints.zksync.enabled: false`). Set it to `true` to forward `zks_*` calls.
+The default `config.yaml` turns the `zksync` group off (`node.rpc.endpoints.zksync.enabled: false`). Keep it off. The key is still accepted, so existing configs that set it continue to load.
## Usage Examples
diff --git a/pages/developers/decentralized-applications/architecture-overview.mdx b/pages/developers/decentralized-applications/architecture-overview.mdx
index 0790082b..068dcf30 100644
--- a/pages/developers/decentralized-applications/architecture-overview.mdx
+++ b/pages/developers/decentralized-applications/architecture-overview.mdx
@@ -20,7 +20,7 @@ Fee-charging writes carry an explicit policy for consensus time units, execution
### Consensus Layer
The consensus layer implements GenLayer's Optimistic Democracy mechanism to ensure reliable and secure execution of transactions using a validator-driven commit-reveal scheme. It also handles appeals and transaction finality to maintain integrity and fairness.
-It is built on ZK-stack rollups to provide scalability and cost-efficiency, secure state updates, and anchoring to Ethereum's security model.
+Its contracts run on GenLayer Chain, an EVM-compatible Arbitrum Orbit L2 that settles to Ethereum and uses GEN as its native gas token. See [GenLayer Chain integration](/understand-genlayer-protocol/core-concepts/rollup-integration) for how settlement works.
### Execution Environment
The execution environment (the GenVM) is the engine that executes Intelligent Contracts. It supports both deterministic and non-deterministic operations, enabling AI integration and web data access.
diff --git a/pages/understand-genlayer-protocol/core-concepts/rollup-integration.mdx b/pages/understand-genlayer-protocol/core-concepts/rollup-integration.mdx
index a4c4576a..ed5ab9c1 100644
--- a/pages/understand-genlayer-protocol/core-concepts/rollup-integration.mdx
+++ b/pages/understand-genlayer-protocol/core-concepts/rollup-integration.mdx
@@ -4,7 +4,7 @@ description: "Learn how GenLayer Chain, its consensus contracts, validator nodes
# GenLayer Chain integration
-GenLayer Chain is an EVM-compatible chain built with the ZK Stack. It hosts ordinary Solidity contracts and the consensus contracts that coordinate Intelligent Contract execution. GenVM is a separate execution environment operated by nodes; it is not an EVM precompile or an Ethereum rollup execution engine.
+GenLayer Chain is an EVM-compatible Arbitrum Orbit L2 that settles to Ethereum. GEN is its native gas token. It hosts ordinary Solidity contracts and the consensus contracts that coordinate Intelligent Contract execution. GenVM is a separate execution environment operated by nodes; it is not an EVM precompile or an Ethereum rollup execution engine.
```mermaid
%%{init: {"flowchart": {"curve": "basis", "nodeSpacing": 48, "rankSpacing": 54, "htmlLabels": true}}}%%
@@ -69,4 +69,8 @@ The shared address gives wallets and EVM contracts one destination even though e
## Settlement and protocol finality are different
-GenLayer Chain inherits its rollup settlement properties from its ZK Stack and Ethereum configuration. Separately, an Intelligent Contract transaction reaches **protocol finality** only after its consensus decision and appeal window complete. Applications must use the Intelligent Contract transaction status—not only the enclosing EVM transaction receipt—to determine whether an outcome is final.
+GenLayer Chain settles to Ethereum the way Arbitrum Orbit chains do. Its sequencer orders transactions. Its state is asserted on its parent chain without a validity proof: an assertion can be disputed during the chain's challenge period and is confirmed only after that period ends. A message from GenLayer Chain to Ethereum, such as a GEN withdrawal or an inflation request, can be executed through the canonical Outbox contract only after the assertion that contains it is confirmed. A sequencer receipt or an L2 event alone does not authorize an action on Ethereum.
+
+On Testnet Bradbury, the parent chain is Ethereum Sepolia and the chain runs in AnyTrust mode: a data availability committee stores transaction data, and the parent chain records the committee's certificates. See [Networks](/developers/networks) for each network's endpoints.
+
+Separately, an Intelligent Contract transaction reaches **protocol finality** only after its consensus decision and appeal window complete. Applications must use the Intelligent Contract transaction status—not only the enclosing EVM transaction receipt—to determine whether an outcome is final.
diff --git a/pages/understand-genlayer-protocol/what-is-genlayer.mdx b/pages/understand-genlayer-protocol/what-is-genlayer.mdx
index 0b536497..21b8db2e 100644
--- a/pages/understand-genlayer-protocol/what-is-genlayer.mdx
+++ b/pages/understand-genlayer-protocol/what-is-genlayer.mdx
@@ -52,7 +52,7 @@ flowchart TB
### GenLayer Chain
-GenLayer Chain is an EVM-compatible ZK Stack chain. Solidity consensus contracts record transaction order, committee assignments, votes, appeals, and final outcomes. For the consensus process, this onchain state is authoritative.
+GenLayer Chain is an EVM-compatible Arbitrum Orbit L2 that settles to Ethereum and uses GEN as its native gas token. Solidity consensus contracts record transaction order, committee assignments, votes, appeals, and final outcomes. For the consensus process, this onchain state is authoritative.
### Validator nodes
diff --git a/pages/validators/network-keeper-roles.mdx b/pages/validators/network-keeper-roles.mdx
index 1c6be363..ddf17924 100644
--- a/pages/validators/network-keeper-roles.mdx
+++ b/pages/validators/network-keeper-roles.mdx
@@ -17,7 +17,7 @@ Today the GenLayer Foundation operates a baseline set of these keepers so the ne
| Role | Function | Who may call | Reward | Risk if idle |
|---|---|---|---|---|
-| **Inflation relayer** | `GEN.executeL2Message()` (L1) | Anyone (permissionless) | `incentivePercentage` × epoch inflation, minted to caller. | **Epoch progression halts network-wide.** L2 cannot advance past `inflationEpoch`. |
+| **Inflation relayer** | Outbox execution of the L2 request, then `GEN.executeInflationRequest()` (L1) | Anyone (permissionless) | Bounded, cost-based GEN reward for `executeInflationRequest()`, minted to caller. | **Epoch progression halts network-wide.** L2 cannot advance past `inflationEpoch`. |
| **Epoch advancer** | `Staking.epochAdvance()` (L2) | Anyone (permissionless) | None | Epochs stop advancing; fees/inflation are not distributed. |
| **Validator primer** | `Staking.validatorPrime(validator)` (L2) | Anyone, on behalf of a validator | 1% of any slash that fires (only when a slash is pending and caller ≠ validator). Healthy validator → none. | Validator misses selection; pending slashes go unenforced. |
| **Appellant** | SDK/CLI appeal operation (`topUpAndSubmitAppeal`) | Anyone (permissionless, payable) | Successful appeal returns 2.5× the bond: principal plus 1.5× profit. | Incorrect results are not challenged. |
@@ -34,33 +34,42 @@ Today the GenLayer Foundation operates a baseline set of these keepers so the ne
## Inflation Relayer
-**Function:** `GEN.executeL2Message(batchNumber, txIndex, batchIndex, message, proof, l2GasPrice, l2GasLimit)` on the **L1** GEN token contract.
+**Functions:** `executeTransaction` on the canonical Arbitrum **Outbox** (L1), then `GEN.executeInflationRequest(epochTo, gasPrice, gasLimit)` on the **L1** GEN token contract.
-Each epoch's inflation makes a round trip: the L2 Staking contract requests it, L1 mints and bridges it back, and L2 receives it. The middle step — proving the L2→L1 message on L1 and relaying it — **cannot happen on-chain**, because zkSync L2→L1 messages can only be proved after the L2 batch has finalized on L1 (roughly an hour on real networks). Someone has to call `executeL2Message()` off-chain to complete the round trip.
+Each epoch's inflation makes a round trip between GenLayer Chain (an Arbitrum Orbit L2) and its parent chain:
+
+1. The L2 Staking contract requests the next window of inflation by sending an L2→L1 message through `ArbSys`.
+2. Once the assertion that contains the message is confirmed on L1, after the chain's challenge period, anyone executes the message through the canonical Outbox. This approves that exact epoch and gas parameters on GEN for one day.
+3. Anyone then calls `GEN.executeInflationRequest()` with those parameters. GEN mints the inflation once and sends it to L2 as a retryable ticket through the chain's `ERC20Inbox`. On L2, `ArbitrumInflationEscrow` hands it to Staking.
+4. After Staking receives it, the escrow sends an acknowledgement back through `ArbSys`. Executing that acknowledgement through the Outbox, again after confirmation, closes the transfer on L1. Only one inflation transfer can be open at a time.
+
+Steps 2 to 4 **cannot happen on-chain by themselves**: an L2→L1 message can only be executed on L1 after its assertion is confirmed, so someone has to submit the Outbox executions and the request off-chain.
- **This role gates the entire network's epoch progression.** The L2 `Staking.epochAdvance()` can only move forward while `epoch + 1 <= inflationEpoch`, and `inflationEpoch` only rises when `executeL2Message()` is successfully relayed on L1. **If no one relays inflation, epoch progression halts network-wide** once the current epoch catches up to `inflationEpoch`. This is the single most important keeper to keep running.
+ **This role gates the entire network's epoch progression.** The L2 `Staking.epochAdvance()` can only move forward while `epoch + 1 <= inflationEpoch`, and `inflationEpoch` only rises when the requested inflation is delivered to L2. **If no one relays inflation, epoch progression halts network-wide** once the current epoch catches up to `inflationEpoch`. This is the single most important keeper to keep running.
-**When to call:** whenever an inflation request message is pending relay. Pre-check any candidate message — and estimate the reward — with the L1 view helper:
+**When to call:** whenever a confirmed inflation request or acknowledgement is waiting in the Outbox, and whenever GEN has an approved request. Check an approval before submitting:
```solidity
-// Returns (pending, rewards): whether the message still needs relaying,
-// and the estimated GEN reward for relaying it.
-(bool pending, uint256 rewards) = GEN.isL2MessagePending(
- batchNumber, txIndex, batchIndex, message
-);
+// True while the exact (epochTo, gasPrice, gasLimit) request is approved,
+// not yet issued, and within its one-day window.
+bool approved = GEN.isInflationRequestApproved(epochTo, gasPrice, gasLimit);
```
-**Reward:** on a successful INFLATION relay, the caller is paid
+**Reward:** a successful `executeInflationRequest()` mints its caller a bounded GEN reward based on the gas that call used, emitting `KeeperRewardPaid`. The Outbox executions and the proof generation are not reimbursed. The full inflation principal goes to Staking.
-```
-reward = totalInflation × incentivePercentage / 10000
-```
+**Recovery:** if the L2 delivery fails, the principal stays in the escrow and anyone can call `ArbitrumInflationEscrow.retry()` on L2. A ticket that is still live can be redeemed or kept alive. `GEN.retryInflationDelivery()` resends the same request, paid entirely by the caller; it never mints the principal again.
+
+**Cadence:** submit each step as soon as it becomes executable. Outbox executions wait for assertion confirmation, so do not assume a fixed delay.
+
+**Replay protection, not idempotency.** Each step can succeed only once, and a repeated call **reverts**; it is not a silent no-op:
-minted to `msg.sender` on L1, emitting `IncentiveRewardPaid(caller, reward)`. The reward is **carved out of** that epoch's inflation, not minted on top — total new supply is `fees + totalInflation` regardless of the incentive.
+- An Outbox message can be executed once. Executing it again reverts in the Outbox (`AlreadySpent`).
+- A successful `executeInflationRequest()` deletes its approval. Calling it again with the same parameters reverts with `ArbitrumRequestNotApproved`, as does a call after the one-day window.
+- `executeInflationRequest()` also reverts with `InflationTransferPending` while an earlier transfer is still open, and with `InflationAlreadyRealized` if `epochTo` is not beyond the last issued epoch.
-**Cadence:** relay each pending inflation message shortly after its L2 batch finalizes on L1 (about hourly on testnet, gated by batch finalization). Relaying is idempotent per target epoch — a duplicate request for an already-requested epoch is a safe no-op — so a keeper that occasionally double-submits does no harm.
+Before submitting, check the state so a duplicate costs nothing: simulate the call (`eth_call`), call `GEN.isInflationRequestApproved(epochTo, gasPrice, gasLimit)`, and compare `epochTo` with `GEN.lastInflationEpoch()`. When several keepers race, expect the losers' transactions to revert and pay gas; only the first call that lands is rewarded.
---
@@ -164,7 +173,7 @@ Removes accumulated burnable GEN (unclaimed inflation, the post-incentive slashe
**When to call:** almost never manually. Burning fires **automatically inside `epochAdvance()`** whenever the accumulated `burning` balance meets the configured `burnThreshold`. The manual call is a **fallback** for flushing balances that sit **below** the threshold, or when threshold automation is disabled (`burnThreshold = 0`, the default).
- Completing a burn on L1 requires two further off-chain operator steps (`finalizeWithdrawal` then a BURN-payload `executeL2Message`) that pair with the L2 emission. Those steps do **not** pay the inflation relayer reward. See the staking system specification for the full burn flow.
+ The L2 burn sends the GEN to L1 as a withdrawal through `ArbSys`. Completing it on L1 requires one further off-chain step: once the assertion that contains the withdrawal is confirmed, execute it through the canonical Outbox. That delivers the GEN to `ArbitrumGENBridge`, and GEN burns exactly the withdrawn amount. This step does **not** pay a keeper reward. See the staking system specification for the full burn flow.
**Reward:** none.
@@ -191,14 +200,14 @@ Paginated garbage collection that reclaims **expired** quarantine records. It on
**Network endpoints and contract addresses.** Keepers need the L2 Staking / consensus contract address and the L1 GEN token address for the target network. The L2 consensus `AddressManager` address and the chain RPC/WebSocket URLs for each testnet live in the [Network-Specific Consensus Configuration](/validators/setup-guide#network-specific-consensus-configuration) section of the setup guide. From the CLI, `genlayer network info` prints the active network's configuration and contract addresses.
-**Reference implementations.** The consensus repository ships reference scripts for the multi-step relay flows — the inflation relayer's proof-fetch-and-execute logic lives at `scripts/consensus_flows/staking/executeL2Message.ts`, alongside companion scripts for the other staking flows. Use these as a starting point for a production keeper: they show how to fetch the L2 receipt, poll `zks_getL2ToL1LogProof` until the batch is finalized, and submit the L1 call.
+**Reference implementations.** The consensus repository ships reference scripts for the multi-step relay flows — the Orbit keeper at `scripts/arbitrum/runKeeper.ts` runs one inflation or burn step per operation file (`execute-outbox`, `init`, `execute-request`, `retry`, `redeem-ticket`, `keepalive-ticket`). Use it as a starting point for a production keeper: it checks the Outbox proof and the request identity, simulates first, and sends only when asked.
**Practical guidance:**
- **Prioritize the inflation relayer.** It is the only keeper whose absence halts the whole network, and the only one that pays a standing reward. Everything else is a backstop to already-automated behavior.
-- **Check for a reward before assuming one.** Only the inflation relayer (via `incentivePercentage`), the validator primer (only on an actually-enforced slash), and the appellant (only on a successful appeal) ever pay. The rest are unpaid liveness/hygiene work.
-- **Expect idempotency.** Inflation relays, stuck-tx healing, and quarantine GC are all safe to retry or double-submit — duplicate or non-applicable calls are no-ops, not errors.
-- **Watch gas vs. reward.** For the paid roles, compare the estimated reward (e.g. `isL2MessagePending`'s `rewards`, or the pending slash amount) against the transaction cost before submitting.
+- **Check for a reward before assuming one.** Only the inflation relayer (for `executeInflationRequest()`), the validator primer (only on an actually-enforced slash), and the appellant (only on a successful appeal) ever pay. The rest are unpaid liveness/hygiene work.
+- **Know which calls are idempotent.** Stuck-tx healing and quarantine GC are safe to retry: non-applicable calls are no-ops. Inflation relay steps are not: each succeeds once and a duplicate reverts (see [replay protection](#inflation-relayer)), so simulate before sending.
+- **Watch gas vs. reward.** For the paid roles, compare the estimated reward (e.g. the gas-based `executeInflationRequest()` reward, or the pending slash amount) against the transaction cost before submitting.
## Related Resources
diff --git a/pages/validators/setup-guide.mdx b/pages/validators/setup-guide.mdx
index 0b2b5c55..72a5825f 100644
--- a/pages/validators/setup-guide.mdx
+++ b/pages/validators/setup-guide.mdx
@@ -642,6 +642,8 @@ metrics:
```
+**Proxied RPC groups.** Under `node.rpc.endpoints`, the `ethereum` group forwards `eth_*` methods to the GenLayer Chain RPC in `rollup.genlayerchainrpcurl`. The `zksync` group forwards `zks_*` methods to the same RPC. `zksync` is a legacy name: GenLayer Chain is an Arbitrum Orbit L2, its RPC does not serve `zks_*` methods, and the example keeps the group off. The key is still accepted, so leave it as it is. See [GenLayer Node API](/api-references/genlayer-node).
+
#### Network-Specific Consensus Configuration
Replace the matching sections of your `config.yaml` with the block for the network you want to join. Replace each top-level section as a whole rather than adding a second `rollup:` or `consensus:` key.
diff --git a/pages/validators/upgrade.mdx b/pages/validators/upgrade.mdx
index a173377f..de0c6647 100644
--- a/pages/validators/upgrade.mdx
+++ b/pages/validators/upgrade.mdx
@@ -57,7 +57,7 @@ Breaking changes involve a new consensus deployment. The old database is incompa
- The node needs the trusted protocol manifest of the network. Set `consensus.manifestpath` (default `configs/node/protocol-manifest.json`) and `consensus.chainid`. The release package has no network files: take the manifest and values from [Network-Specific Consensus Configuration](/validators/setup-guide#network-specific-consensus-configuration).
- GenVM moved from `third_party/genvm` to `opt/genvm/`, with the link `opt/genvm/current` to it. Set `genvm.root_dir: ./opt/genvm/current` and run `python3 ./opt/genvm/current/bin/setup.py` (see [download instructions](/validators/setup-guide#download-the-node-software)).
- The Bradbury RPC WebSocket needs an API key. Set it in the environment as `GENLAYERNODE_ROLLUP_GENLAYERCHAINRPCKEY`; it has no `config.yaml` key. See [Testnet Bradbury](/validators/setup-guide#testnet-bradbury).
-- The `genlayer_debug` (`gen_dbg_*`) and `zksync` (`zks_*`) RPC groups are off in the default `config.yaml` (`node.rpc.endpoints`).
+- The `genlayer_debug` (`gen_dbg_*`) and `zksync` (`zks_*`) RPC groups are off in the default `config.yaml` (`node.rpc.endpoints`). `zksync` is a legacy group name: GenLayer Chain is now an Arbitrum Orbit L2 and does not serve `zks_*` methods.
- The data store is split into `genvm.db` and `ops.db`. On startup the node renames an old `genlayer.db` to `genvm.db`; it refuses to start if both exist.
- Docker: `NODE_PASSWORD` has no default, and a validator needs it: the node refuses validator mode without a password. It reaches the node as `GENLAYERNODE_PASSWORD`, not as `--password`. See [Running the Node using docker-compose](/validators/setup-guide#running-the-node-using-docker-compose).
- Docker: the node container runs as uid `10001`. Make `./data` writable by it once: `sudo chown -R 10001:10001 ./data`.
@@ -70,7 +70,7 @@ Breaking changes involve a new consensus deployment. The old database is incompa
### v0.4.x to v0.5.0 (Breaking)
- The two consensus contract addresses (`contractmainaddress` and `contractdataaddress`) have been replaced by a single `consensusaddress` field. Do not copy your old consensus config — use the new example `config.yaml`.
-- The GenLayer Chain ZKSync RPC URLs (`genlayerchainrpcurl` and `genlayerchainwebsocketurl`) have changed. Update both the HTTP RPC and WebSocket URLs in your `config.yaml` to the new endpoints.
+- The GenLayer Chain RPC URLs (`genlayerchainrpcurl` and `genlayerchainwebsocketurl`) have changed. Update both the HTTP RPC and WebSocket URLs in your `config.yaml` to the new endpoints.
- Database must be wiped (the node creates a fresh one on startup).
- Re-staking is required — breaking changes involve a new consensus deployment, so you must stake again using the [validator wizard](/validators/setup-guide#using-the-validator-wizard).
diff --git a/scripts/check-protocol-docs.js b/scripts/check-protocol-docs.js
index 347501cf..c035d698 100644
--- a/scripts/check-protocol-docs.js
+++ b/scripts/check-protocol-docs.js
@@ -162,6 +162,32 @@ for (const stub of removedStubs) {
}
}
+// GenLayer Chain is an Arbitrum Orbit L2. Pages must not describe it as a
+// ZK Stack / zkSync chain. Allowed: release history (changelogs), partners
+// built on the ZK Stack, and real identifiers (the legacy `zksync` RPC group,
+// `zks_*` methods, contract error names).
+const architectureExceptions = new Set([
+ path.join("pages", "validators", "changelog.mdx"),
+ path.join("pages", "partners", "heurist.mdx"),
+]);
+const outdatedArchitecture = [
+ [/\bZK[- ]?Stack\b/i, "ZK Stack"],
+ [/\bZK[- ]?rollups?\b/i, "ZK rollup"],
+ [/\bzkSync Elastic\b/i, "zkSync Elastic Chain"],
+ [/\b(?:via|on|built (?:on|with)) zkSync\b/i, "zkSync as the chain's base"],
+ [/\bzks_getL2ToL1LogProof\b/, "zkSync L2-to-L1 proofs"],
+ [/\bzkSync RPC\b/i, "zkSync RPC"],
+];
+for (const file of walk(path.join(ROOT, "pages")).filter((file) => file.endsWith(".mdx"))) {
+ if (architectureExceptions.has(relative(file))) continue;
+ const content = fs.readFileSync(file, "utf8");
+ for (const [pattern, description] of outdatedArchitecture) {
+ if (pattern.test(content)) {
+ failures.push(`${relative(file)}: describes GenLayer Chain with outdated ${description} wording`);
+ }
+ }
+}
+
if (failures.length) {
console.error("check-protocol-docs: FAILED");
for (const failure of failures) console.error(` - ${failure}`);
diff --git a/scripts/retrofit/retrofit.js b/scripts/retrofit/retrofit.js
index 91709581..5965db4c 100644
--- a/scripts/retrofit/retrofit.js
+++ b/scripts/retrofit/retrofit.js
@@ -46,7 +46,7 @@ const EXCLUDED_FILES = [
];
const CANON = `Project context — GenLayer documentation (docs.genlayer.com):
-GenLayer is the first Intelligent Blockchain: an L2 (on zkSync Elastic Chain, anchored to Ethereum) whose smart contracts — called Intelligent Contracts, written in Python — can natively access the web, call LLMs, and reach consensus on non-deterministic, subjective outcomes. Consensus mechanism: Optimistic Democracy; validators agree on non-deterministic outputs via the Equivalence Principle. Execution environment: GenVM. Dev tools: GenLayer CLI, GenLayer Studio (browser IDE), GenLayerJS / GenLayerPY SDKs, GenLayer Testing Suite (genlayer-test). Networks: Localnet, Studionet, Testnet Bradbury.
+GenLayer is the first Intelligent Blockchain: an L2 (GenLayer Chain, an Arbitrum Orbit chain that settles to Ethereum) whose smart contracts — called Intelligent Contracts, written in Python — can natively access the web, call LLMs, and reach consensus on non-deterministic, subjective outcomes. Consensus mechanism: Optimistic Democracy; validators agree on non-deterministic outputs via the Equivalence Principle. Execution environment: GenVM. Dev tools: GenLayer CLI, GenLayer Studio (browser IDE), GenLayerJS / GenLayerPY SDKs, GenLayer Testing Suite (genlayer-test). Networks: Localnet, Studionet, Testnet Bradbury.
Canonical terminology — always use exactly these names: "Intelligent Contract" (never "AI contract" or "smart contract 2.0"), "Optimistic Democracy", "Equivalence Principle", "GenVM", "GenLayer Studio". You may read other files in this repository (e.g. public/llms.txt, sibling pages in the same directory) to stay consistent with how concepts are described elsewhere.`;