Timelock UI: an open source interface to operate TimelockController from the browser

In many Web3 protocols, important decisions are not executed immediately. Contract upgrades, parameter changes, treasury movements, or governance actions often go through a waiting period before they can be executed on-chain.

That delay is not accidental: it is a security layer.

Timelocks allow an operation to be scheduled on-chain before execution, giving teams time to review the action, detect errors, react to unexpected changes, or cancel an operation if something does not look right.

To make this process easier, the Stakely team has developed Timelock UI, a minimal, open source, chain-agnostic interface to operate any OpenZeppelin TimelockController directly from the browser.

The tool is available at timelock.stakely.io, and the code can be reviewed in the public Stakely/timelock-ui repository.

Timelock UI is a frontend application that lets teams schedule, monitor, execute, and cancel timelocked operations on EVM networks.

The idea is simple: connect a wallet, enter the address of a TimelockController contract, and operate from a clear interface without a backend, complex setup, or predefined deployments.

The tool is designed for teams working with governance contracts, multisigs, DAOs, protocols, or any system that uses an OpenZeppelin TimelockController as a security layer for sensitive operations.

The classic timelock flow may look simple on paper:

schedule -> wait delay -> execute 

In practice, however, operating these contracts often means reviewing calldata, checking operation states, tracking waiting periods, confirming roles, and coordinating execution with the relevant wallet or multisig.

Timelock UI reduces that friction by providing a visual interface to follow the full lifecycle of an operation:

• Schedule: schedule an operation by sending a schedule() transaction with the target contract, calldata, and corresponding delay.

• Wait: monitor the waiting period until the operation moves from Waiting to Ready.

• Execute: execute the operation once the delay has elapsed, as long as the connected account has the required role.

• Cancel: cancel an operation if the connected account has CANCELLER_ROLE.

This makes timelock operations clearer, especially when several team members need to review or coordinate actions before execution.

One of the most important aspects of Timelock UI is that it is not limited to a specific network or hardcoded contracts.

The interface can be used with:

• Ethereum mainnet.

• Sepolia.

• Hoodi.

• EVM-compatible L2s.

• Custom networks through RPC configuration.

• Any contract compatible with OpenZeppelin TimelockController.

This makes it useful for teams operating on mainnet, as well as protocols working on testnets, staging environments, or less common EVM networks.

Instead of relying on a closed integration, users can add the network and contract they need to operate.

Timelock UI runs entirely in the browser.

There is no proprietary backend storing operations or managing credentials. State is stored in localStorage under the tl-ui:* namespace, and all on-chain interactions are performed through the connected wallet.

This means that:

• The application never custodies private keys.

• Every transaction must be signed by the user wallet.

• Local state can be reset by clearing site data.

• The tool can be self-hosted on a team-owned instance.

This approach is especially useful for teams that want to reduce external dependencies when operating critical infrastructure or governance contracts.

Although Stakely maintains a public demo at timelock.stakely.io, Timelock UI can also be deployed on a team-owned infrastructure.

The project is a frontend application built with Vite, React, TypeScript, wagmi, viem, RainbowKit, and TailwindCSS. It does not include Solidity or a backend, which makes both technical review and deployment simpler.

A team can clone the repository, install dependencies, build the production version, and serve the resulting folder through Vercel, Netlify, Nginx, IPFS, or another static hosting provider.

Another important feature is the ability to sync operations that were not created through the interface itself.

Using the Sync chain button, Timelock UI scans CallScheduled events from the contract to detect operations scheduled directly on-chain or through other tools.

This means the interface can be used not only to create new operations, but also to monitor existing timelocks even if the team did not use Timelock UI from the beginning.

Timelock UI can be useful for:

• DAOs executing actions through timelocks.

• Protocols with on-chain governance.

• Technical teams managing contract upgrades.

• Multisigs coordinating sensitive operations.

• Infra teams that need to monitor scheduled operations.

• Builders working with OpenZeppelin TimelockController across different EVM networks.

In all these cases, the tool helps make a process that is often spread across scripts, explorers, calldata, and internal documentation more visible and easier to operate.

At Stakely, we operate blockchain infrastructure across multiple Proof-of-Stake networks, but we also believe adoption depends on building practical tools for other teams in the ecosystem.

Timelock UI follows that same logic: a small, specific, open tool designed to solve a real need for teams working with critical contracts.

It does not replace a protocol’s internal security processes, but it does provide a visual and accessible layer to operate timelocks with more clarity.

You can try the tool at timelock.stakely.io or review the code on GitHub.