타임락과 실행

A timelock is a mandatory delay between when a proposal passes and when it executes.

It protects users by giving them time to react to changes they disagree with — for example, withdrawing funds before a risky upgrade.

OpenZeppelin's TimelockController is a contract that schedules, delays, and then executes operations.

The Governor proposes and queues actions into the timelock, which actually owns the protocol's admin rights.

Operations flow through three steps:

• schedule — queue the action with a delay
• wait — the minDelay must elapse
• execute — run the action after the delay

The minDelay sets how long every scheduled operation must wait. Common values range from 1 to 7 days.

Longer delays mean more safety but slower governance — a deliberate trade-off each DAO must tune.

The timelock uses access roles:

• PROPOSER — can schedule operations (the Governor)
• EXECUTOR — can run them after the delay
• ADMIN — manages roles (often renounced)

For governance to be meaningful, the timelock contract should hold the protocol's admin and ownership rights — not any individual.

This ensures every privileged change must pass through the full govern-then-delay pipeline.

If an attacker sneaks a harmful proposal through voting, the timelock delay is the last line of defense.

The community can spot the queued action and exit or coordinate a response before it executes.

Each scheduled operation can specify a predecessor (an operation that must run first) and a salt to make its identifier unique.

These let DAOs order dependent operations and avoid hash collisions between similar actions.

A scheduled operation can be cancelled before execution by an address with the canceller role.

This provides an emergency brake if a queued action is found to be dangerous during the delay window.

Combining Governor + Timelock + a proxy pattern lets DAOs upgrade contracts safely: vote, queue, delay, then execute the upgrade.

Every step is transparent and reversible up until execution, balancing flexibility with security.

The timelock enforces a delay between approval and execution, owns the protocol's privileges, and uses roles plus cancellation to keep upgrades safe.

It is the crucial buffer that makes on-chain governance trustworthy.

You learned that:

• A timelock delays execution after a proposal passes
• TimelockController schedules, waits, then executes
• minDelay tunes the safety vs speed trade-off
• The timelock should own the protocol; roles control access
• Operations can be cancelled during the delay

Course complete! Next course: Layer 2 and Scaling.