diff --git a/pages/developers/_meta.json b/pages/developers/_meta.json
index 0a1f25fe..65f79116 100644
--- a/pages/developers/_meta.json
+++ b/pages/developers/_meta.json
@@ -1,8 +1,11 @@
{
"networks": "Networks & RPCs",
"consensus-v06-migration": "Consensus v0.6 Migration",
+ "bridging-gen": "Bridging GEN (L1 ↔ L2)",
+ "exchange-wallet-integration": "Exchange & Wallet Integration",
"intelligent-contracts": "Intelligent Contracts",
"decentralized-applications": "Frontend & SDK Integration",
+ "delegating-gen": "Delegating GEN",
"error-reference": "Error & Revert Reference",
"staking-guide": "Staking Contract Guide"
}
diff --git a/pages/developers/bridging-gen.mdx b/pages/developers/bridging-gen.mdx
new file mode 100644
index 00000000..0acd198d
--- /dev/null
+++ b/pages/developers/bridging-gen.mdx
@@ -0,0 +1,100 @@
+---
+description: "How to bridge GEN between Ethereum (L1) and the GenLayer Chain (L2): deposit L1 to L2, withdraw L2 to L1, understand finalization timing, and track a transfer."
+---
+
+import { Callout } from "nextra-theme-docs";
+import { Card, Cards } from "nextra-theme-docs";
+
+# Bridging GEN (L1 ↔ L2)
+
+GenLayer Chain is an Arbitrum Orbit L2. A deposit moves ERC-20 GEN on Ethereum to native GEN on GenLayer Chain. A withdrawal returns native GEN to Ethereum as ERC-20 GEN. Bradbury Phase 2 settles to Ethereum Sepolia and uses AnyTrust for data availability.
+
+This guide follows a transfer through the canonical bridge from the first wallet signature to the balance change on the destination chain.
+
+
+ For Bradbury Phase 2, open the [GenLayer testnet bridge on Rollbridge](https://genlayer-chain-testnet-cfn8m3xc6l-86e44e69a1216817.testnets.rollbridge.app/). Check that the route connects Ethereum Sepolia (11155111) and GenLayer Chain (4221). Verify the [Phase 2 genesis hash](/developers/networks#testnet-bradbury) and the [Sepolia GEN token](https://sepolia.etherscan.io/address/0x424242424b68330CcFb022881d25a6acC29852ea). If you cannot verify the route or token, stop before approving or sending GEN.
+
+
+## Before you start
+
+Bridging touches two chains, so you need both set up:
+
+- **The GenLayer Chain (L2) in your wallet.** Add it from the [GenLayer Chain (L2)](/developers/networks#genlayer-chain-l2) section on the Networks page (it includes an "add to wallet" control). GEN is the **native** token on this chain — balances are denominated in wei (1 GEN = 10¹⁸ wei).
+- **The corresponding L1 (Ethereum) network** in the same wallet, holding the GEN you want to deposit plus a little of the L1 gas token to pay for the deposit transaction.
+- **Gas on both sides.** A deposit costs L1 gas; a withdrawal costs L2 gas to initiate and then L1 gas to finalize/claim on Ethereum.
+
+
+ Use the bridge for your specific GenLayer deployment. An Arbitrum One or Nova bridge address belongs to a different chain.
+
+
+---
+
+## Deposit: L1 → L2
+
+Deposits are the fast direction. Bringing GEN from Ethereum onto the GenLayer Chain follows the standard rollup deposit flow:
+
+1. **Connect your wallet** to the [Bradbury Phase 2 bridge](https://genlayer-chain-testnet-cfn8m3xc6l-86e44e69a1216817.testnets.rollbridge.app/) and select Ethereum Sepolia as the source. Use the wallet that holds your Sepolia GEN.
+2. **Select the deposit direction** (L1 → GenLayer Chain) and the amount of GEN.
+3. **Approve and deposit the GEN.** Check the spender and amount in the L1 token approval. Submit the native-token deposit through the chain’s ERC-20 Inbox.
+4. **Verify the L2 credit.** When the sequencer includes the deposit, check the recipient’s native GEN balance. A native GEN deposit uses a direct Inbox credit. Contract calls and messages can use retryable tickets.
+
+
+ Once the deposit lands on L2, your GEN is the native currency of the GenLayer Chain — you can transfer it, pay fees with it, or [delegate it to a validator](/developers/delegating-gen).
+
+
+---
+
+## Withdraw: L2 → L1
+
+A [canonical withdrawal](https://docs.arbitrum.io/how-arbitrum-works/deep-dives/l2-to-l1-messaging) requires a transaction on each chain.
+
+1. **Initiate on L2.** Select the L1 recipient and submit the withdrawal through the bridge. The L2 transaction uses `ArbSys` to create an L2-to-L1 message. Save its transaction hash.
+2. **Claim on L1.** Wait for the rollup assertion covering the message to be confirmed on Ethereum after the deployment’s challenge period. Once the message is executable, you or a relayer can submit its inclusion proof to the L1 Outbox. A successful execution releases ERC-20 GEN to the L1 recipient.
+
+
+ **Check the message status before claiming.** The L2 receipt and publication of the batch are earlier milestones. The wait depends on the deployment’s challenge period and assertion confirmation.
+
+
+
+ The [GenLayer Finality Window](/understand-genlayer-protocol/core-concepts/optimistic-democracy/finality) governs appeals of Intelligent Contract results. The bridge uses the rollup assertion and the Outbox to determine when GEN can be claimed on Ethereum.
+
+
+If the bridge offers a relayer, track its L1 execution transaction. Otherwise return to the bridge when the message becomes executable and submit the claim.
+
+---
+
+## Track a transfer
+
+Because a transfer spans two chains, you follow it on both:
+
+- **L2 side (GenLayer Chain).** Use the Chain Explorer listed on [Networks](/developers/networks). Confirm the deposit credit or locate the withdrawal transaction and its L2-to-L1 message.
+- **L1 side (Ethereum).** For a deposit, check the L1 deposit receipt and then confirm the L2 credit. For a withdrawal, find the successful Outbox execution on the parent-chain explorer and verify the recipient’s ERC-20 GEN balance.
+- **Bridge status page.** If the network's bridge UI shows a transfer/withdrawal status (e.g. "ready to finalize"), that is usually the clearest signal for when a withdrawal's L1 claim step becomes available.
+
+
+ Keep the L2 withdrawal hash so you can find the message and claim it when its assertion is confirmed.
+
+
+---
+
+## Common pitfalls
+
+| Pitfall | What to do |
+|---|---|
+| Expecting a withdrawal to arrive as soon as the L2 receipt appears | Track the message until its assertion is confirmed and the Outbox claim succeeds. |
+| Forgetting the L1 finalization step | A withdrawal is not complete until the L1 claim/finalize transaction succeeds. If your network's bridge doesn't auto-finalize, you must return and complete it. |
+| No L1 gas to finalize | Keep some L1 gas token available to pay for the withdrawal's finalization transaction. |
+| Using an address from another network | Match the route and Sepolia GEN token to the Bradbury links above. Verify the destination genesis hash on [Networks](/developers/networks#testnet-bradbury). |
+| Confusing GenLayer finality with L2→L1 settlement | Follow the appeal window for an Intelligent Contract result and the Outbox message status for a bridge withdrawal. |
+
+---
+
+## Related resources
+
+
+
+
+
+
+
+
diff --git a/pages/developers/delegating-gen.mdx b/pages/developers/delegating-gen.mdx
new file mode 100644
index 00000000..ad5823ee
--- /dev/null
+++ b/pages/developers/delegating-gen.mdx
@@ -0,0 +1,202 @@
+---
+description: "A delegator's guide to staking GEN with a GenLayer validator: choose a validator, delegate, monitor and claim rewards, and switch validators safely."
+---
+
+import { Callout } from "nextra-theme-docs";
+import { Card, Cards } from "nextra-theme-docs";
+
+# Delegating GEN: A Delegator's Guide
+
+Delegating lets you put your GEN to work without running a validator node yourself. You pick a validator, delegate your GEN to it, and share in the rewards that validator earns for participating in consensus — while the validator does the operational work of running the node.
+
+This guide is written for token holders. It walks through the whole lifecycle: choosing a validator, delegating, monitoring and claiming rewards, and switching to a different validator. For the concepts underneath delegation (epochs, shares vs. stake, validator weight, reward distribution), see [Staking in GenLayer](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking).
+
+
+ Delegating is not the same as running a validator. As a delegator you never operate a node — you back an existing validator with your stake. If you want to run your own node instead, see the [Validator Setup Guide](/validators/setup-guide).
+
+
+## How delegation works, in brief
+
+- You delegate GEN to a specific validator. Your delegation is tracked as **shares** in that validator's pool, not as a fixed token amount.
+- Rewards **compound**: as the validator earns, the value of each share grows, so your position grows without any action on your part.
+- Delegations follow the network's **epoch** timing. A new delegation activates **2 epochs after** you make it (with a special exception during the genesis bootstrap — see [Delegating during Epoch 0](#delegating-during-epoch-0)).
+- Exiting is **not instant**. When you unstake, your GEN is locked for an **unbonding period of 7 epochs** before you can claim it back.
+
+
+ Because you hold **shares**, not a token balance, you always **exit by specifying a number of shares** (or a percentage of your shares), never a GEN amount. Keep this in mind for every unstake.
+
+
+An epoch is a fixed time window in which the validator set is active; on the network, an epoch lasts one day. See [Epoch System](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking#epoch-activation-and-priming) for details.
+
+---
+
+## Step 1 — Choose a validator
+
+Your rewards and risk both depend on the validator you back. Evaluate candidates before committing.
+
+### Where to look
+
+- **Validator and staking UI.** On Bradbury Phase 2, use the [staking explorer](https://stakegen.com/explore/) to compare validators. Check the deployment details on [Networks](/developers/networks#testnet-bradbury) before connecting your wallet.
+- **CLI (for a scriptable, always-current list).** The [GenLayer CLI](/api-references/genlayer-cli) prints the validator set with stake, status, and voting power:
+
+ ```bash
+ genlayer staking validators
+ genlayer staking validators --all # also include banned validators
+ ```
+
+ To inspect a single validator's stake, shares, and live/banned status:
+
+ ```bash
+ genlayer staking validator-info --validator 0xVALIDATOR_ADDRESS
+ ```
+
+### What to evaluate
+
+| Signal | Why it matters | How to check |
+|---|---|---|
+| **Uptime / liveness** | Validators that miss their duties earn less and risk penalties, which drags on your rewards. | `live` field in `validator-info`; status column in the explorer. |
+| **Not banned or quarantined** | A quarantined or banned validator is excluded from selection, so your delegation earns nothing while it's out. | `banned` field in `validator-info`; `genlayer staking validators --all` shows banned entries; `genlayer staking quarantined-validators` and `banned-validators` list them. |
+| **Stake size** | Very large validators are heavily backed already; smaller (but reliable) validators can mean a larger share of that validator's rewards go to you. | Stake column in the explorer / `validators` output. |
+| **Track record** | Consistent participation over time is a better signal than a single snapshot. | `genlayer staking validator-history --validator 0x...` shows recent per-epoch history. |
+
+
+ **Diversify.** You can delegate to more than one validator. Spreading your GEN across several reliable validators limits the impact if any single one has downtime or gets penalized. A downside of one validator does not affect delegations you hold with others.
+
+
+
+ Rewards are never guaranteed and can be reduced by validator downtime or [slashing](/understand-genlayer-protocol/core-concepts/optimistic-democracy/slashing). Choosing a reliable validator is the single biggest lever you control.
+
+
+---
+
+## Step 2 — Delegate your GEN
+
+Make sure your wallet is connected to the right network first (RPC and chain ID are on the [Networks](/developers/networks) page), and that you hold enough GEN to cover your delegation plus transaction fees.
+
+### Minimum
+
+Under normal rules (epoch 2 onward), the minimum delegation is **42 GEN per validator**. During the genesis bootstrap (epoch 0) this minimum is relaxed — see [Delegating during Epoch 0](#delegating-during-epoch-0).
+
+### Delegate with the CLI
+
+```bash
+genlayer staking delegator-join --validator 0xVALIDATOR_ADDRESS --amount 42gen
+```
+
+The `--amount` accepts a value in wei, or with a `gen` / `eth` suffix (for example `100gen`). To delegate to several validators, run the command once per validator with the address of each.
+
+
+ **When does it start earning?** Under normal rules, a new delegation activates **2 epochs after** you submit it. It begins accruing rewards once it's active, not the moment the transaction lands. Track the current epoch with `genlayer staking epoch-info`.
+
+
+### Add more to an existing delegation
+
+To increase a delegation you already hold, delegate again to the **same validator** — additional deposits have no minimum, and rewards on your existing position keep compounding in the meantime.
+
+For the underlying contract-level calls (useful if you're integrating delegation into your own tooling rather than using the CLI), see the [Staking Contract Guide](/developers/staking-guide#delegator-operations).
+
+---
+
+## Step 3 — Monitor and claim rewards
+
+### Rewards compound automatically
+
+You do **not** need to claim to keep earning. Rewards accrue into the validator's pool and raise the value of each share, so your delegated position grows on its own. Claiming is only needed when you want to withdraw GEN back to your wallet after unstaking (Step 4).
+
+### Check your position
+
+```bash
+genlayer staking delegation-info --validator 0xVALIDATOR_ADDRESS
+```
+
+This shows your delegation with the given validator (defaulting to your signer address; pass `--delegator 0x...` to check another address). Because your position is denominated in shares, its GEN value moves as the pool earns.
+
+To see network-wide reward context for an epoch — total inflation, how much has been claimed, and how much is still unclaimed — use:
+
+```bash
+genlayer staking epoch-info
+genlayer staking epoch-info --epoch 4 # a specific (current or previous) epoch
+```
+
+See [Reward Distribution](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking#rewards-and-risks) for how rewards are shared between a validator and its delegators.
+
+---
+
+## Step 4 — Unstake and claim your GEN
+
+Unstaking is a two-phase process because of the unbonding period.
+
+**Phase 1 — Exit (start unbonding).** Specify how many **shares** to withdraw. The request removes them from your available balance and starts the seven-epoch wait. Active stake still earns its normal rewards for the exit epoch. Rewards on the withdrawn stake stop when validator priming processes the withdrawal and removes that stake from the active record.
+
+```bash
+# Withdraw a number of shares from a validator you delegate to
+genlayer staking delegator-exit --validator 0xVALIDATOR_ADDRESS --shares SHARES
+```
+
+**Phase 2 — Claim (after unbonding).** Count seven epochs from the exit request. Once the withdrawal has matured and been priced, claim the GEN back to your address:
+
+```bash
+genlayer staking delegator-claim --validator 0xVALIDATOR_ADDRESS
+```
+
+```
+Epoch 5: request exit (active stake still earns epoch 5 rewards)
+Epochs 6–11: withdrawal remains locked
+Epoch 12: earliest claim for the priced withdrawal
+```
+
+
+ Track the current epoch with `genlayer staking epoch-info`. A partial exit leaves your remaining active shares earning rewards.
+
+
+
+ If you delegate to multiple validators, exit and claim from **each validator separately** — each delegation has its own shares and its own unbonding timer.
+
+
+For the concept-level walkthrough of exits and cooldowns, see [Unstaking in GenLayer](/understand-genlayer-protocol/core-concepts/optimistic-democracy/unstaking).
+
+---
+
+## Switching validators
+
+There is **no "redelegate" operation** on GenLayer. Moving your stake from one validator to another is not atomic — it is a full unstake from the old validator followed by a fresh delegation to the new one, with the unbonding period in between. Concretely:
+
+1. **Exit** your shares from your current validator: `genlayer staking delegator-exit --validator 0xOLD --shares SHARES`.
+2. **Wait** seven epochs from the exit request before claiming. The old delegation keeps its exit-epoch rewards.
+3. **Claim** the released GEN back to your wallet: `genlayer staking delegator-claim --validator 0xOLD`.
+4. **Delegate** the claimed GEN to the new validator: `genlayer staking delegator-join --validator 0xNEW --amount ...`. Remember this new delegation then takes **2 epochs** to activate.
+
+
+ The withdrawn stake stops earning with the old validator when priming removes it from the active record. It starts earning with the new validator once the new delegation activates.
+
+
+---
+
+## Delegating during Epoch 0
+
+**Epoch 0 is the genesis bootstrapping period** before the network is operational. Its rules are deliberately relaxed to help the network launch, and they differ from everything above:
+
+- **Delegation is effectively free of the usual minimum** — any non-zero amount is accepted, so you can delegate below the normal 42 GEN threshold.
+- **Below-minimum delegations are allowed to register**, but a delegation only becomes **active in epoch 2** if it meets the normal minimum by then. The network jumps straight from epoch 0 to epoch 2 (epoch 1 is skipped).
+- **No rewards are earned in epoch 0**, because no transactions are processed yet.
+
+From **epoch 2 onward, normal rules apply**: the 42 GEN minimum, the +2-epoch activation delay, and the 7-epoch unbonding period all take effect.
+
+
+ If you delegate a below-minimum amount during epoch 0, top it up to at least **42 GEN** before epoch 2 begins, or that delegation will not activate.
+
+
+The full epoch-0 rules — including validator behavior, share calculation, and the transition to epoch 2 — are documented in [Genesis Epoch 0](/developers/staking-guide#genesis-epoch-0).
+
+---
+
+## Related resources
+
+
+
+
+
+
+
+
+
diff --git a/pages/developers/exchange-wallet-integration.mdx b/pages/developers/exchange-wallet-integration.mdx
new file mode 100644
index 00000000..1c2b99cf
--- /dev/null
+++ b/pages/developers/exchange-wallet-integration.mdx
@@ -0,0 +1,121 @@
+---
+description: "Integrator guide for exchanges, wallets, and indexers onboarding GenLayer: chain IDs, RPC/WS endpoints, address formats, L1/L2 GEN, deposit detection, and finality guidance."
+---
+
+import { Callout } from "nextra-theme-docs";
+import { Card, Cards } from "nextra-theme-docs";
+
+# Exchange & Wallet Integrator Guide
+
+This guide is for teams **onboarding GenLayer into existing infrastructure** — exchanges listing GEN, wallets adding the network, and indexers or custodians tracking balances and transfers. It orients you to the chain model, the endpoints and formats you'll integrate against, and the finality considerations that matter for crediting deposits.
+
+
+ **This page points at the canonical sources for concrete values rather than duplicating them.** Network IDs, RPC endpoints, and contract addresses change per network and over time. Always read the live values from the [Networks](/developers/networks) page and the validator [Setup Guide](/validators/setup-guide) before wiring anything up, and re-verify after network upgrades.
+
+
+## Chain model
+
+GenLayer presents as **two layers**, and which one you integrate against depends on what you're doing:
+
+- **GenLayer node RPC** handles Intelligent Contract operations (`gen_*`) and forwards supported Ethereum (`eth_*`) calls to the chain. Use a Phase 2-compatible node for Intelligent Contract operations on Bradbury.
+- **GenLayer Chain (L2)** is the EVM-compatible Arbitrum Orbit chain that holds account balances and processes native GEN transfers. Connect to the chain RPC to index those transfers.
+
+Bradbury Phase 2 settles to Ethereum Sepolia and uses AnyTrust for data availability. An AnyTrust certificate attests to batch data availability. Withdrawal eligibility depends on confirmation of the rollup assertion on the parent chain.
+
+Use the [GenLayer Node API](/api-references/genlayer-node) to check which `eth_*` methods the node forwards. The optional `zks_*` compatibility proxy defaults to off on Bradbury Phase 2. Use standard Ethereum methods for Orbit integrations.
+
+---
+
+## Endpoints, chain IDs, and currency
+
+Read the exact values from the [Networks](/developers/networks) page — do not hardcode them from this guide. For quick orientation, GenLayer exposes distinct environments, each with its own chain ID and RPC:
+
+- **Testnet Bradbury Phase 2** — [Networks](/developers/networks#testnet-bradbury) lists the chain RPC, chain ID and explorer. The chain RPC serves EVM requests. Intelligent Contract methods require a GenLayer node RPC.
+- **Studionet** (hosted dev) and **Localnet** (local dev) — separate chain IDs, useful for staging your integration before pointing at a testnet.
+- **GenLayer Chain (L2)** — the underlying chain you'll index for balances/transfers; its RPC, chain ID, currency (**GEN**, 18 decimals), and chain explorer are in the [GenLayer Chain (L2)](/developers/networks#genlayer-chain-l2) section, which also provides an "add to wallet" control that emits the correct hex chain ID and native-currency metadata.
+
+
+ **WebSocket access.** Bradbury’s chain WebSocket requires a Conduit RPC key. Follow the configuration instructions on [Networks](/developers/networks#testnet-bradbury) before enabling subscriptions.
+
+
+
+ **Verify the deployment before crediting deposits.** Bradbury Phase 2 reuses chain ID 4221. Check the block-zero hash and AddressManager against [Networks](/developers/networks#testnet-bradbury) when onboarding or switching RPC providers.
+
+
+---
+
+## Addresses
+
+GenLayer uses **Ethereum-style accounts**: addresses are `0x`-prefixed hexadecimal strings, and the account model has **Externally Owned Accounts** (controlled by private keys) and **Contract Accounts** (Intelligent Contracts). Standard Ethereum address handling — hex parsing, checksumming, key management — applies. See [Accounts and Addressing](/understand-genlayer-protocol/core-concepts/accounts-and-addresses) for the account model.
+
+
+ **Same address across both layers.** An Intelligent Contract's GEN balance is held by its "ghost contract" on the chain layer at the **same address**, so a given address refers to the same account whether you view it via the GenLayer RPC or directly on the GenLayer Chain. This simplifies balance tracking — you index one address space.
+
+
+---
+
+## The GEN token
+
+**GEN is the native token of the GenLayer Chain** (analogous to ETH on Ethereum), not an ERC-20 on that chain. Balances are denominated in **wei** (1 GEN = 10¹⁸ wei), and you read a balance with standard `eth_getBalance` against the chain RPC.
+
+
+ On the Ethereum parent chain, GEN is an ERC-20. Track that token’s events on L1 and native GEN balances on L2. Verify the L1 token and bridge addresses against the deployment’s official information. See [Bridging GEN](/developers/bridging-gen).
+
+
+---
+
+## Deposit detection
+
+For crediting user deposits of native GEN on the GenLayer Chain, the pattern mirrors any EVM chain:
+
+1. **Assign and monitor deposit addresses** in the standard `0x` hex format. For direct native transfers, identify the customer by the destination address.
+2. **Follow new blocks** via the chain RPC (HTTP polling `eth_blockNumber` / `eth_getBlockByNumber`, or WebSocket subscriptions if available for your network).
+3. **Verify each deposit.** For direct native transfers, match the recipient and value and check that the receipt succeeded in the canonical block. If you also accept transfers made by contracts, use a trace-capable provider to identify successful internal value transfers. `eth_getBalance` gives the current balance, not a history of deposits.
+4. **Wait for finality before crediting** (see below) — don't credit on first inclusion.
+
+
+ Full-block decoders must support Nitro system transactions, including type `0x6a`. If you only need hashes, request `eth_getBlockByNumber` with its second argument set to `false`. Fetch the relevant transaction and its receipt individually to verify the recipient, value and success before crediting it.
+
+
+---
+
+## Finality guidance
+
+Choose the crediting threshold for each operation and record which signal the indexer requires.
+
+- **Sequencer inclusion.** A successful L2 receipt records execution. Indexers can record a pending deposit at this point and track the containing block.
+- **Ethereum settlement.** For a policy that requires a confirmed L2 state, wait for confirmation of the rollup assertion covering the transfer after the challenge period. Posting a batch or an AnyTrust certificate is an earlier event.
+- **Intelligent Contract finality.** For a credit that depends on an Intelligent Contract outcome, check the GenLayer [transaction status](/understand-genlayer-protocol/core-concepts/transactions/transaction-statuses). The [Finality Window](/understand-genlayer-protocol/core-concepts/optimistic-democracy/finality) allows appeals before the result becomes final.
+
+
+ Confirmation and challenge periods are deployment-specific. Use the parent-chain assertion status when your policy requires settlement. A fixed count of L2 blocks or elapsed minutes cannot establish that status.
+
+
+
+ For a canonical withdrawal, show the L2 submission, the wait for assertion confirmation and the successful L1 Outbox claim as separate stages. See [Bridging GEN](/developers/bridging-gen).
+
+
+---
+
+## Integration checklist
+
+- [ ] Pull chain IDs, RPC (HTTP + WS), currency, and explorer URLs from the [Networks](/developers/networks) page for **each** environment you support.
+- [ ] Verify the Bradbury Phase 2 genesis hash and AddressManager alongside the chain ID.
+- [ ] Verify the L1 token and canonical bridge for each deployment. For Bradbury Phase 2, use the [bridge and Sepolia GEN links](/developers/bridging-gen).
+- [ ] Track native GEN via `eth_getBalance` and native transfers (not ERC-20 logs) on the GenLayer Chain.
+- [ ] Specify whether each credit requires sequencer inclusion, a confirmed assertion or a finalized Intelligent Contract result.
+- [ ] Check the supported `eth_*` methods and test full-block decoding against a block containing a Nitro system transaction.
+- [ ] Re-validate all endpoints and addresses **after every network upgrade**.
+
+---
+
+## Related resources
+
+
+
+
+
+
+
+
+
diff --git a/pages/developers/staking-guide.mdx b/pages/developers/staking-guide.mdx
index df228bdc..a3cabc25 100644
--- a/pages/developers/staking-guide.mdx
+++ b/pages/developers/staking-guide.mdx
@@ -10,7 +10,7 @@ The Staking Contract Guide explains how developers can interact directly with Ge
To understand the concepts behind staking, including the epoch system, shares vs stake, validator selection weights, and reward distribution, see [Staking in GenLayer](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking).
- For CLI-based staking operations (recommended for most users), see the [GenLayer CLI Staking Commands](/api-references/genlayer-cli#staking-operations-testnet).
+ For CLI-based staking operations (recommended for most users), see the [GenLayer CLI Staking Commands](/api-references/genlayer-cli/staking/staking). For a delegator-focused, non-CLI-first walkthrough, see [Delegating GEN](/developers/delegating-gen).
## Validator Operations
@@ -94,7 +94,8 @@ validatorWallet.validatorExit(sharesToExit);
**Important Notes:**
-- Exited tokens stop earning rewards immediately
+- After epoch 0, an exit immediately removes the shares from the owner's available balance and queues the withdrawal. When priming processes that withdrawal, it prices the shares and updates active stake and selection weight.
+- The withdrawal still receives its share of rewards for the epochs it served and remains exposed to slashing for those epochs.
- Tokens are locked for **7 epochs** before claiming
- Each exit creates a separate withdrawal
@@ -200,16 +201,16 @@ genStaking.delegatorExit(validatorWallet, sharesToExit);
**Important Notes:**
-- Can exit partial amounts
-- Stop earning rewards immediately after exit
+- Can exit partial amounts, but a partial exit cannot leave the delegation below the minimum; exit all shares instead
+- After epoch 0, an exit immediately removes the shares from your available balance. When priming processes the withdrawal, it prices the shares and updates the validator's active delegated stake and selection weight.
- Tokens are locked for **7 epochs**
- Exit each validator separately if delegating to multiple
**Unbonding Timeline:**
```
-Epoch 5: delegatorExit() called
+Epoch 5: delegatorExit() called (active stake still earns epoch 5 rewards)
Epochs 6-11: Locked period
-Epoch 12: delegatorClaim() available
+Epoch 12: earliest delegatorClaim()
```
### Claiming Withdrawn Funds as a Delegator
@@ -469,4 +470,5 @@ genStaking.validatorClaim(validatorWallet);
- [Staking Concepts](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking) - How staking works in GenLayer
- [Unstaking](/understand-genlayer-protocol/core-concepts/optimistic-democracy/unstaking) - Unstaking process details
- [Slashing](/understand-genlayer-protocol/core-concepts/optimistic-democracy/slashing) - Slashing penalties and conditions
-- [GenLayer CLI Staking Commands](/api-references/genlayer-cli#staking-operations-testnet) - CLI reference for staking
+- [GenLayer CLI Staking Commands](/api-references/genlayer-cli/staking/staking) - CLI reference for staking
+- [Delegating GEN: A Delegator's Guide](/developers/delegating-gen) - End-user guide to picking a validator, delegating, and claiming rewards