An on-chain proposal is a formal, executable transaction or set of instructions submitted to a blockchain's governance system to enact changes or make decisions. Unlike informal discussions, an on-chain proposal is a concrete, code-based object—often a smart contract—that contains the specific parameters of the proposed action, such as adjusting a protocol's fee, upgrading its core contracts, or allocating treasury funds. Its lifecycle is managed entirely by the blockchain's consensus rules, ensuring transparency and immutability throughout the process.
On-Chain Proposal
What is an On-Chain Proposal?
A formal mechanism for decentralized decision-making where governance actions are submitted, voted on, and executed directly on a blockchain.
The proposal process typically follows a structured workflow: submission, where a proposer stakes a required deposit; a voting period, where token holders cast weighted votes; and finally execution or timelock, where the approved proposal's code is automatically enacted after a security delay. This automated execution distinguishes it from off-chain governance, where decisions are made through social consensus and require manual implementation. Key technical components include the proposal's calldata (the function calls to execute), a description hash, and its on-chain state (e.g., Pending, Active, Defeated, Executed).
On-chain proposals are foundational to Decentralized Autonomous Organizations (DAOs) and protocols like Compound, Uniswap, and Aave. For example, a proposal might call the _setReserveFactor function in a lending protocol to change an asset's interest rate model. The security of this system relies on careful design: proposal thresholds prevent spam, quorums ensure sufficient participation, and timelocks allow users to exit if a malicious proposal passes. This creates a trust-minimized framework for upgrading and managing decentralized systems without relying on a central party.
Key Features of On-Chain Proposals
On-chain proposals are governance actions encoded directly into a blockchain's state, distinguished by several core technical features that ensure transparency, security, and programmability.
Immutable & Transparent Record
Once submitted, an on-chain proposal's code, parameters, and voting data are recorded on the public ledger. This creates a permanent, tamper-proof audit trail. Every transaction, vote, and state change is visible to all network participants, ensuring complete transparency in the governance process.
Programmable Execution
The proposal's logic and its execution are defined in smart contract code. If the vote passes, the encoded actions (e.g., transferring treasury funds, upgrading a protocol parameter) are executed automatically and permissionlessly by the network, removing the need for manual intervention and reducing execution risk.
Token-Weighted Voting
Voting power is typically derived from ownership of the protocol's governance token (e.g., UNI, COMP, MKR). Common mechanisms include:
- One-token-one-vote: Simple weight based on token balance.
- Vote delegation: Users can delegate voting power to representatives.
- Time-weighted voting: Power is based on tokens locked for a duration (ve-token model).
Formalized Proposal Lifecycle
Proposals follow a strict, code-enforced sequence of states:
- Temperature Check/Discussion (off-chain forum).
- Submission & On-Chain Queuing.
- Voting Period (fixed blockchain blocks or time).
- Timelock & Execution (delay allows for review before code runs).
- Implementation (success) or Expiration (failure).
Resistance to Censorship
Because the proposal and voting mechanism reside on a decentralized blockchain, no single entity can prevent a valid proposal from being submitted or censor votes. This property is fundamental to credible neutrality and aligns with the permissionless nature of the underlying protocol.
Composability with DeFi Primitives
On-chain proposals can interact with other DeFi building blocks. Examples include:
- Using flash loans to acquire voting power for a single block (governance attacks).
- Vote escrow systems that lock tokens for increased power.
- Forking a protocol's state, including its treasury and governance decisions, if a proposal is contentious.
How an On-Chain Proposal Works
An on-chain proposal is a formal, executable governance mechanism where protocol changes are submitted, voted on, and implemented directly through smart contracts on the blockchain.
The lifecycle of an on-chain proposal begins with submission. A proposer, typically a token holder who meets a minimum stake or deposit requirement, creates a transaction that encodes the proposed change into a smart contract. This proposal contract contains the executable code or parameters for the change, such as adjusting a fee, upgrading a contract, or allocating treasury funds. The proposal is then recorded on-chain, becoming immutable and publicly verifiable, initiating a predefined voting period.
During the voting phase, governance token holders cast their votes by signing transactions that interact with the proposal contract. Voting power is usually proportional to the amount of governance tokens held or delegated, with common models including token-weighted voting and quadratic voting. Key parameters like the quorum (minimum participation threshold) and passing threshold (required majority) are enforced by the smart contract. This phase ensures that all decisions are transparent, tamper-proof, and directly reflect the will of the token-holding community.
Once the voting period concludes, the smart contract autonomously executes the proposal if it meets all predefined success conditions. Successful execution might involve a contract upgrade via a Timelock, a treasury transfer, or a parameter change. If the proposal fails—due to insufficient votes, a failed quorum, or a security check—it is simply closed with no state change. This end-to-end automation eliminates the need for manual intervention, creating a trust-minimized system for decentralized governance, as seen in protocols like Compound, Uniswap, and Arbitrum.
Examples & Use Cases
On-chain proposals are the formal mechanism for enacting changes within a decentralized protocol. These examples illustrate the diverse range of actions they can initiate.
On-Chain vs. Off-Chain Proposals
A comparison of two primary methods for proposing and discussing changes to a decentralized protocol.
| Feature | On-Chain Proposal | Off-Chain Proposal (e.g., Snapshot) |
|---|---|---|
Execution Binding | ||
Voting Cost | Gas fees required | Gasless (signature-based) |
Consensus Layer | Native blockchain (e.g., L1, L2) | Third-party service or sidechain |
Finality | Automated execution upon approval | Requires separate execution transaction |
Voter Sybil Resistance | Native token weight or stake | Often uses token snapshots or delegated proof |
Typical Use Case | Parameter changes, treasury spends, upgrades | Temperature checks, signaling, community sentiment |
Time to Resolution | Governance delay + voting period (e.g., 1-2 weeks) | Voting period only (e.g., 3-7 days) |
Technical Overhead | Requires smart contract deployment/upgrade | Minimal; front-end configuration |
Ecosystem Usage
An on-chain proposal is a formal, executable transaction submitted to a blockchain's governance system to enact changes. This section details its core mechanics, lifecycle, and real-world applications across decentralized ecosystems.
Core Governance Mechanism
An on-chain proposal is the primary mechanism for decentralized decision-making. It is a smart contract transaction that, if approved, automatically executes its encoded logic. This contrasts with off-chain signaling, which requires manual implementation. Key components include:
- Proposal ID: A unique on-chain identifier.
- Executable Calldata: The code or parameters for the change.
- Voting Period: A defined time window for token holders to cast votes.
The Proposal Lifecycle
A proposal follows a strict, transparent path from creation to execution.
- Submission: A proposer deposits funds (a proposal deposit) and submits the transaction.
- Voting Delay: A period for discussion before voting begins.
- Active Voting: Token holders vote using mechanisms like token-weighted voting or delegate voting.
- Timelock & Execution: If the quorum and majority threshold are met, the proposal may enter a timelock delay for review before final, automatic execution.
Common Proposal Types
Proposals can enact various levels of change within a protocol.
- Parameter Change: Adjusting system variables (e.g., interest rates, fee percentages).
- Treasury Spend: Authorizing payments from the community treasury.
- Smart Contract Upgrade: Deploying or migrating to a new protocol implementation via a proxy contract.
- Governance Meta-Change: Modifying the governance system's own rules (e.g., voting period length).
Key Technical Concepts
Understanding these terms is essential for evaluating proposals.
- Quorum: The minimum percentage of voting power that must participate for a result to be valid.
- Timelock: A mandatory delay between approval and execution, allowing users to exit if they disagree.
- Proposal Threshold: The minimum token balance required to submit a proposal, preventing spam.
- Snapshot: A common off-chain tool for gas-free voting signaling that often precedes an on-chain proposal.
Real-World Examples
Major DAOs use on-chain proposals for critical upgrades.
- Uniswap: Proposals to deploy to new chains, adjust fee structures, and allocate treasury funds.
- Compound: Proposals to add new collateral assets and adjust risk parameters like collateral factors.
- Aave: Proposals to activate new safety modules, upgrade the protocol, and manage the Aave Grants DAO. These demonstrate the mechanism's role in managing DeFi protocol risk and evolution.
Security & Best Practices
Robust proposal design mitigates risks in decentralized governance.
- Multisig Execution: Requiring a multisignature wallet to execute approved proposals adds a final human review layer.
- Emergency Procedures: Protocols often have separate emergency shutdown or pause guardian mechanisms for critical bugs, bypassing the slower proposal process.
- Code Audits & Forks: All upgrade proposals should have undergone extensive smart contract audits. The threat of a protocol fork acts as a final check on governance power.
On-Chain Proposal
An on-chain proposal is a formal, executable transaction submitted to a blockchain's governance system to enact a protocol change, allocate funds, or modify parameters. Its lifecycle, from submission to execution, is secured and recorded on the ledger itself.
Lifecycle & State Machine
An on-chain proposal follows a deterministic state machine defined by the protocol's smart contracts. Key states include:
- Submitted/Deposited: Proposal is created, often requiring a deposit.
- Voting Period: Token holders cast votes with their stake.
- Passed/Rejected: Outcome is determined by quorum and majority thresholds.
- Executed: If passed, the encoded transaction is automatically executed on-chain.
- Failed: Can fail due to insufficient quorum, veto, or execution errors.
Security Model & Attack Vectors
On-chain governance introduces specific security considerations:
- Proposal Spam: Malicious actors may flood the system with proposals, requiring deposit requirements and spam prevention mechanisms.
- Timelocks: A critical security feature that delays execution after a vote passes, allowing users time to react to malicious changes.
- Governance Capture: The risk that a large token holder (or cartel) can consistently pass proposals against the network's interest.
- Parameter Exploits: A proposal that maliciously changes a critical system parameter (e.g., fee recipient) can be catastrophic.
Voting Mechanisms & Sybil Resistance
Voting power is typically derived from a governance token, with mechanisms to prevent Sybil attacks:
- Token-Weighted Voting: One token equals one vote. Simple but favors wealth concentration.
- Quadratic Voting: Cost of votes scales quadratically, aiming to reduce whale dominance.
- Delegation: Users can delegate voting power to representatives or "validators."
- Quorum Requirements: A minimum percentage of total voting power must participate for the vote to be valid, preventing low-turnout attacks.
Execution & Upgrade Paths
A passed proposal contains code or parameters for on-chain execution.
- Direct Execution: The proposal payload is a transaction that modifies protocol contracts directly (e.g., changing a fee).
- Social Consensus / Off-Chain Signaling: For major upgrades (hard forks), an on-chain vote may signal community sentiment, but execution requires validators to adopt new client software separately.
- Multisig Fallback: Some systems use a multisig wallet as a failsafe to execute or veto proposals in emergencies.
Key Governance Parameters
The security and responsiveness of the system are governed by tunable parameters, often set by prior proposals:
- Voting Period: Duration of the voting window (e.g., 3-7 days).
- Quorum: Minimum percentage of total voting power required for a valid vote.
- Threshold: Majority required to pass (e.g., >50% for simple majority, >66.6% for supermajority).
- Proposal Deposit: Amount of tokens locked to submit a proposal, slashed if it fails.
- Timelock Delay: Time between a proposal passing and its execution.
Real-World Examples & Protocols
Different blockchains implement on-chain proposals with distinct flavors:
- Compound & Uniswap: Use token-weighted voting for treasury management and parameter changes on Ethereum.
- Cosmos Hub: Uses a Text Proposal for signaling and a Parameter Change Proposal for direct, on-chain updates to module parameters.
- MakerDAO: Complex Executive Votes bundle multiple spell contract changes into a single proposal, executed via the DS-Chief system.
- Tezos: A self-amending ledger where passed proposals are automatically tested on a testnet fork before final upgrade.
Technical Details
An on-chain proposal is a formal, executable transaction submitted to a blockchain's governance system to modify the protocol's parameters, treasury, or code. This section details its lifecycle, technical components, and execution mechanisms.
An on-chain proposal is a cryptographically signed transaction submitted to a blockchain's governance smart contract, containing executable code or parameter changes that are voted on and executed automatically by the network. The process follows a defined lifecycle: a proposer deposits a required stake to prevent spam, the proposal enters a voting period where token holders cast weighted votes, and if the proposal meets predefined quorum and approval thresholds, the encoded actions are executed autonomously on-chain. This mechanism enables decentralized, transparent, and trust-minimized upgrades to protocols like Compound, Uniswap, and Aave without requiring a centralized operator.
Common Misconceptions
Clarifying frequent misunderstandings about how governance proposals are executed and recorded on a blockchain.
No, an on-chain proposal and a governance vote are distinct, sequential phases in the governance lifecycle. A proposal is the formal submission of executable code or a parameter change for community consideration. The vote is the subsequent process where token holders cast their ballots for or against that specific proposal. The proposal defines the what, while the vote determines the if. For example, on Compound or Uniswap, a proposal (e.g., Proposal #123) is created first, then a voting period opens where holders of governance tokens like COMP or UNI can signal their support.
Frequently Asked Questions
On-chain proposals are the formal mechanism for enacting changes to a decentralized protocol. This FAQ addresses common questions about how they function, their lifecycle, and their critical role in governance.
An on-chain proposal is a formal, executable transaction submitted to a blockchain network to modify its protocol parameters, treasury, or smart contract logic, contingent upon approval by the network's governance token holders. The process typically follows a structured lifecycle: a proposal is drafted and submitted, often requiring a deposit of tokens; it enters a voting period where token holders cast weighted votes; if the proposal meets predefined quorum and approval thresholds, it is queued for execution, where the encoded changes are automatically applied to the blockchain's state. This mechanism enables decentralized, transparent, and permissionless coordination for protocol upgrades.
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.