Join our community of builders on Discord!

On-Chain Permissions & Governance Scope

Control of the Lightchain mainnet is split in two. The Treasury is owned by a TimelockController that the community drives through LightChainGovernor: treasury funds move only through a proposal that the community has voted on and that has cleared the 48-hour Timelock. The protocol contracts (AIConfig, JobRegistry, WorkerRegistry, SessionManager, FeePool and ReputationRegistry) are owned by the protocol Safe 0xf737…8c57 (3 of 5 signers), as approved by a vote of the earlier Ethereum-based Beta DAO, so the protocol can be stopped or corrected quickly if something goes wrong. See Who controls the protocol contracts. This page enumerates every privileged surface area on mainnet, who can touch it, and — equally important — what is structurally outside the team's control.

Governance stack at a glance

ComponentPurposeAddress (mainnet)
LightChainGovernorProposal, voting, queueing surface (OpenZeppelin Governor)See Contract Addresses
TimelockControllerOwns the Treasury; enforces the 48-hour execution delaySee Contract Addresses
Protocol SafeOwns the six protocol contracts; any change needs 3 of its 5 signers0xf737…8c57 · open in Safe
NativeVotes (0x…1001)Tracks voting power from native LCAI balances. Provides IVotes to the GovernorGenesis precompile-style address 0x0000000000000000000000000000000000001001
Voting power is denominated in native LCAI held at the proposal snapshot block. No wrapper is needed on Lightchain itself — NativeVotes exposes the IVotes interface directly on top of native LCAI balances. For the configured parameters (proposal threshold, voting delay, voting period, quorum, timelock delay), see Governance & Protocol Parameters.

Timelock roles

The TimelockController owns the Treasury. Access to it is gated by four OpenZeppelin roles:
RoleHolderEffect
PROPOSER_ROLELightChainGovernor onlyOnly the Governor can queue an operation against the Timelock. There is no direct path to queue.
CANCELLER_ROLELightChainGovernor onlyCan cancel a queued operation before it executes. Cannot create or modify operations.
EXECUTOR_ROLEaddress(0) (open)Anyone can execute a queued operation once the Timelock delay has elapsed. This is intentional — execution is permissionless so no single party can hold a passed proposal hostage.
DEFAULT_ADMIN_ROLEThe Timelock itself onlyThe deployer's admin role was revoked at block 779,661. Role assignments can only be changed by a successful governance proposal that targets the Timelock itself.
The practical consequence is that the only way to move Treasury funds is:
  1. A proposer with ≥ PROPOSAL_THRESHOLD LCAI (140,000 LCAI) creates a proposal.
  2. Voting delay (~24 h) elapses; the snapshot block is reached.
  3. Voting period (~5 days: 216,000 blocks at 2 s) elapses; the proposal must reach quorum (3% of total voting power) with a majority for.
  4. The Governor queues the operation against the Timelock.
  5. 48 hours pass.
  6. Anyone executes the operation.
There is no path that skips any of these steps for the Treasury. The protocol contracts follow a different path, described next. The Governor itself is upgradeable (UUPS), but only through its own governance (onlyGovernance).

Who controls the protocol contracts

AIConfig, JobRegistry, WorkerRegistry, SessionManager, FeePool and ReputationRegistry are owned by the protocol Safe 0xf737…8c57 (Safe 1.5.0, 3 of 5 signers; open in Safe), not by the Timelock. The Beta DAO on Ethereum approved this so the protocol can be stopped or corrected quickly if something goes wrong. Ownership moved to the Safe from the deployer EOA 0x8a35E00eff6f3bf125aE5011cc7C603E18B8D616 on 20 October 2026. Changes to these contracts (model whitelisting, protocol parameters, upgrades) need 3 of the 5 Safe signatures and do not go through a Governor vote. Every change is a public transaction from the Safe that anyone can review on Lightscan. Check the current owner of any contract with owner().

What the owner controls

Every function below is gated by onlyOwner. For WorkerRegistry and AIConfig the owner is the protocol Safe (3 of 5 signatures). For the Treasury the owner is the TimelockController, reached only through the proposal flow described above.

WorkerRegistry — model eligibility and worker stake

FunctionWhat it does
addWhitelistedModel(bytes32 modelId)Adds a model to the per-worker whitelist. Workers can only opt in to whitelisted models.
removeWhitelistedModel(bytes32 modelId)Removes a model from the per-worker whitelist. Already-registered workers lose eligibility for that model.
setGuardian(address) / sunsetGuardian()Manage the Guardian role (see below). sunsetGuardian() is irreversible.
Slashing (slash(address, uint256)) is not governance-controlled — it is onlyJobRegistry, called automatically by JobRegistry when an offense is detected. The owner can tune the slashing rates inside AIConfig, but cannot directly slash a worker.

AIConfig — protocol parameters and model registry

FunctionWhat it does
registerModel(bytes32 modelId, uint256 fee, uint256 maxOutputTokens)Registers a new model and enables it.
enableModel(bytes32 modelId) / disableModel(bytes32 modelId)Toggles the modelEnabled[modelId] flag. Workers cannot serve a disabled model even if it is still whitelisted.
setModelFee(bytes32 modelId, uint256 fee)Updates the per-job fee for a model.
setFeeDistribution(uint256, uint256, uint256)Updates the worker / treasury / fee-pool split. Enforced invariant: shares sum to 10,000 bps.
setMinWorkerStake(uint256)Updates the minimum stake required to register as a worker.
setTimeoutSlashBps, setCompletionTimeoutSlashBps, setDisputeSlashBpsUpdate slashing rates. Each call enforces the rate ≤ maxSlashBps (5,000 bps / 50%).
setDisputeWindow, setResolutionTimeout, setDisputeBondMultiplierUpdate dispute timing and bond sizing.
setDisputerAddressUpdate the address of the disputer service, which the protocol authenticates against.
setDispatcherAddressUpdate the signer that the legacy dispatcher path checks (createSession, and session key updates while sortition is off). The dispatcher no longer runs; sessions open through on-chain sortition. Since 19 October 2026 it is set to the burn address 0x…dEaD.

Treasury

FunctionWhat it does
transfer(address, uint256)Sends funds from the Treasury to a recipient.
batchTransfer(address[], uint256[])Sends funds to multiple recipients in one operation.
There is no path to drain the Treasury that bypasses a governance proposal. claimWithdrawal() is open (it's the pull-mechanism fallback for a failed transfer), but it can only retrieve funds that were already approved for the caller by a prior governance action.

Contract upgrades

The protocol contracts and the Treasury are UUPS proxies. The upgrade authorization function _authorizeUpgrade(address) enforces onlyOwner. A protocol contract upgrade needs 3 of the 5 protocol Safe signatures. A Treasury upgrade needs the full proposal → vote → queue → 48 h → execute flow.

What the owner cannot do

Neither the protocol Safe nor a successful proposal can move certain dials, because the limits are enforced in the contracts as immutable bounds or invariants:
  • Slashing rates cannot exceed maxSlashBps. It is 5,000 (50%) today, so a call to setDisputeSlashBps(6000) reverts. maxSlashBps is a stored value the owner can change with setMaxSlashBps, up to 10,000.
  • Fee distribution must sum to 10,000 bps. A proposal that sets a 50/40/5 split (sum = 9,500) reverts.
  • Dispute window and resolution timeout have minimum bounds. Setters enforce floor values so a proposal cannot collapse the dispute window to zero.
  • WorkerRegistry.slash is onlyJobRegistry. Governance has no path to slash a worker directly. Slashing only happens through detected on-chain offenses.
These guardrails apply equally to the founding team and to the community — they are properties of the deployed code, not policies enforced off-chain.

The Guardian role

Admin control of the protocol contracts, including the emergency stop, was approved by a proposal on the earlier Ethereum-based Beta DAO so the protocol can be stopped quickly if something goes wrong. The DAO can vote on a new proposal to reduce or remove this control, and the protocol Safe signers carry out the result. The emergency stop is a Guardian role, assigned by the protocol Safe, that can call pause() on WorkerRegistry, JobRegistry and FeePool. The protocol Safe can also pause directly. While paused, the affected contracts reject:
  • New worker registration
  • New session creation
  • New job submission
  • Fee distribution
That is the full scope of Guardian authority. The Guardian cannot:
  • Modify any protocol parameter
  • Add or remove models
  • Move treasury funds
  • Upgrade any contract
  • Unpause: only the owner (the protocol Safe) can call unpause(), and it can reassign the Guardian via setGuardian or retire the role via sunsetGuardian()
sunsetGuardian() is irreversible: once it is called, the Guardian role can never be reassigned.

Model whitelisting and removal

Of all the owner-controlled surfaces above, model lifecycle is the one the team is most often asked about, so it warrants explicit treatment. There are two layered gates a model passes through to be servable on Lightchain. Both are owned by the protocol Safe: any change needs 3 of its 5 signers.

Gate 1 — Protocol-wide registration (AIConfig)

CodeSOLIDITY
Registration sets the canonical fee and output limit and flips the model to enabled. disableModel flips the flag back to false without removing the registration (workers still on the eligible set are immediately rejected by JobRegistry when they try to ack a job for that model).

Gate 2 — Per-worker whitelist (WorkerRegistry)

CodeSOLIDITY
A worker can only register support for a model if it is on this whitelist. Removing a model from the whitelist immediately removes it from every worker's supported-model set, so already-active workers stop receiving jobs for that model.

What this means in practice

  • Adding a new model requires calls to AIConfig.registerModel and WorkerRegistry.addWhitelistedModel (typically batched in one Safe transaction), signed by 3 of the 5 Safe signers.
  • Removing a model requires a Safe transaction calling WorkerRegistry.removeWhitelistedModel and/or AIConfig.disableModel, with the same signatures.
  • A delisted model can be re-whitelisted later. Delisting is reversible, not permanent.
The Beta DAO approved the protocol Safe as owner so that a harmful or broken model can be disabled quickly. Every change is public: it is a transaction from the Safe 0xf737…8c57 that anyone can review on Lightscan.