A Proposal Builder (also known as a block builder) is a critical component in modern blockchain architectures, particularly those utilizing Proposer-Builder Separation (PBS). Its primary function is to assemble an optimized set of pending transactions—known as a block payload or block body—from the mempool. The builder's goal is to create the most valuable block possible for the block proposer (or validator), typically by maximizing transaction fee revenue through sophisticated algorithms that include MEV (Maximal Extractable Value) extraction strategies such as arbitrage and liquidation bundling.
Proposal Builder
What is a Proposal Builder?
A specialized software agent in blockchain ecosystems that constructs and submits transaction bundles to validators for inclusion in a new block.
The builder operates in a competitive marketplace. Multiple builders bid in an auction, submitting their constructed block along with a payment to the proposer. The winning bid's block is the one the proposer commits to the chain. This separation of roles enhances network decentralization and censorship resistance, as the entity proposing the block (often a solo staker) is distinct from the entity choosing the transactions. Key technical implementations include mev-boost on Ethereum, which facilitates this auction via relays, and SUAVE (Single Unifying Auction for Value Expression), a dedicated decentralized network for block building.
Builders employ complex software to maximize profitability. This involves simulating transaction execution, searching for profitable MEV opportunities like DEX arbitrage or NFT minting bundles, and optimizing gas usage and transaction ordering. They must also consider censorship resistance lists and regulatory compliance. The builder's output is a complete, executable block header and body that is cryptographically committed to before the auction concludes.
The rise of Proposal Builders has created a specialized block-building market dominated by entities with advanced infrastructure and capital. This has led to concerns about centralization in the building layer, prompting research into builder decentralization solutions. Alternatives like enshrined PBS aim to formalize the separation within the protocol itself, while MEV smoothing and MEV burn mechanisms seek to redistribute the captured value more evenly across the network or destroy it to benefit all token holders.
How a Proposal Builder Works
A proposal builder is a specialized software tool that streamlines the creation, simulation, and submission of governance proposals for on-chain decentralized autonomous organizations (DAOs).
A proposal builder is a user interface that abstracts the complexity of crafting raw, executable blockchain transactions for DAO governance. It allows a community member—the proposer—to define an action, such as transferring treasury funds or upgrading a smart contract, through a structured form. The builder then encodes this intent into the precise calldata and target addresses required for the on-chain vote, significantly reducing technical barriers and the risk of proposal errors that could lead to failed execution or lost funds.
The core function involves transaction simulation and gas estimation. Before submission, the builder often runs a local simulation of the proposed transaction using tools like Tenderly or a forked network. This dry-run verifies the proposal will execute as intended without reverting, estimates the gas cost, and previews the resulting state changes. This step is critical for complex proposals involving smart contract interactions, as it provides transparency and security assurances to both the proposer and future voters.
Advanced builders integrate governance frameworks and template libraries. They are configured for specific DAO platforms like Compound Governor, OpenZeppelin Governor, or Aragon OSx, ensuring proposal formatting meets the protocol's exact requirements. Many offer pre-built templates for common actions—treasury disbursements, parameter adjustments, delegate calls—further simplifying the process. This standardization helps maintain consistency across proposals and reduces the learning curve for new community participants.
Finally, the builder handles the submission transaction. After the proposer provides the necessary details and passes simulations, the tool constructs the final transaction to the DAO's governance contract, typically invoking a function like propose(). The proposer signs and broadcasts this transaction, paying the associated gas fee and often a proposal deposit. Once confirmed on-chain, the proposal enters a timelock or voting period, becoming a formal item for the DAO's tokenholders to debate and decide upon.
Key Features of a Proposal Builder
A proposal builder is a specialized interface that standardizes the creation, simulation, and submission of on-chain governance actions. It abstracts technical complexity to enable structured, secure, and transparent proposal workflows.
Structured Proposal Templates
Pre-configured templates enforce a standard format for different governance actions, such as parameter changes, treasury allocations, or smart contract upgrades. This ensures all required fields (e.g., title, description, on-chain actions) are populated, reducing errors and improving proposal clarity for voters.
On-Chain Action Encoding
The core function is translating human-readable intent into executable on-chain transactions. The builder encodes proposal logic—like a specific calldata payload for a contract call—into the correct format for the governance module (e.g., creating a proposalId on a Governor contract).
Transaction Simulation & Preview
Advanced builders integrate gas estimation and state simulation tools (e.g., Tenderly, OpenZeppelin Defender). This allows proposers to preview the outcome and cost of their proposed transactions before submission, identifying potential failures or unintended consequences.
Voting Strategy Configuration
Proposers can define the voting mechanism, including:
- Voting delay and voting period
- Quorum requirements
- Vote types (e.g., single-choice, approval voting)
- Token-weighted or NFT-based voting power This configuration is critical for aligning the proposal with the DAO's governance framework.
Proposal Lifecycle Management
The tool tracks a proposal through its entire lifecycle: Draft, Active, Succeeded/Failed, Queued, and Executed. It may provide interfaces for proposal cancellation, queueing successful votes on a Timelock, and finally executing the approved transactions.
Integration with Snapshot & On-Chain Systems
Builders often support both gasless off-chain voting (via Snapshot) and on-chain execution. They handle the signature generation for Snapshot proposals and can prepare the subsequent on-chain transaction batch for execution if the vote passes, bridging the gap between signaling and execution.
Examples and Ecosystem Usage
Proposal builders are implemented across major governance platforms, each offering specialized interfaces and features for creating, simulating, and submitting on-chain proposals.
Simulation & Security Tools
Critical companion tools used alongside proposal builders to prevent errors:
- Tenderly and OpenZeppelin Defender simulate transaction effects on forked mainnet state.
- Safe Transaction Builder crafts multi-signature executions for Gnosis Safe-based DAOs.
- These tools help verify calldata and prevent unintended contract interactions.
Builder SDKs & APIs
Developer frameworks that enable custom proposal builder creation:
- OpenZeppelin Governor provides the underlying smart contract standard and helper libraries.
- Tally's SDK offers utilities for interacting with on-chain Governor contracts.
- These allow teams to build tailored governance interfaces for their specific protocol parameters and processes.
Proposal Builder
A Proposal Builder is a specialized software tool or interface that enables users to construct, simulate, and submit governance proposals for on-chain protocols in a structured and error-resistant manner.
A Proposal Builder standardizes the complex process of creating governance actions by providing a guided form or wizard. Users input key parameters—such as the target smart contract, function to call, and arguments—into predefined fields. The builder then compiles this data into a properly formatted transaction payload, often generating the necessary calldata. This abstraction is critical because directly crafting proposal transactions requires deep technical knowledge of the protocol's ABI and low-level encoding, making the builder an essential accessibility layer for decentralized governance.
Beyond simple creation, advanced builders integrate simulation and validation engines. Before submission, a proposal can be dry-run against a forked version of the mainnet or a testnet to verify its on-chain effects, estimate gas costs, and catch potential errors or unintended consequences. This simulation step is a vital risk mitigation tool, preventing the submission of proposals that could fail execution or cause protocol damage. Some builders also check for compliance with the DAO's own governance rules, such as minimum proposal deposits or voting durations.
For integration, Proposal Builders are typically accessed via a DAO's dedicated governance front-end or third-party platforms like Tally or Sybil. They interact directly with the protocol's governance smart contracts, such as Governor Bravo or custom implementations. The final output is a transaction ready for submission, which often requires a proposal deposit. The builder's role concludes once the signed transaction is broadcast, with subsequent voting and execution managed by the core governance module. This separation of concerns allows builders to focus on usability and safety during the creation phase.
Security and Governance Considerations
Proposal builders are powerful tools that streamline governance, but they introduce critical security vectors and centralization risks that must be managed.
Smart Contract Risk
The proposal builder's underlying smart contract is a primary attack surface. Vulnerabilities like reentrancy, logic errors, or improper access controls can lead to the theft of treasury funds or malicious proposal execution. Rigorous audits and formal verification are essential before deployment. Example: A bug could allow a malicious actor to bypass quorum checks and execute a fraudulent proposal.
Front-End Centralization
While the blockchain protocol is decentralized, the proposal builder's front-end interface is often a centralized point of failure. It can be censored, serve malicious code, or go offline, blocking legitimate governance participation. Mitigations include IPFS hosting, decentralized front-ends, and encouraging direct contract interaction. This highlights the difference between protocol and interface security.
Proposal Spam & Sybil Attacks
Builders that lower the proposal submission cost can enable governance spam, flooding the system with low-quality proposals to drown out legitimate ones. Combined with Sybil attacks (creating many fake identities), this can disrupt governance. Countermeasures include:
- Proposal deposits that are slashed for failed votes
- Reputation-based systems or whitelists
- Minimum token threshold for submission
Vote Delegation & Meta-Governance
Builders often integrate vote delegation, where users lend their voting power to delegates or governance-as-a-service providers. This creates meta-governance risks, concentrating power in a few large delegates who may act against individual voter interests or be compromised. Transparency into delegate platforms and policies is critical for informed delegation.
Parameter Manipulation & Upgrade Risks
A proposal builder can be used to craft proposals that alter core governance parameters (e.g., quorum, voting delay, treasury withdrawal limits) or upgrade critical protocol contracts. A successful malicious proposal of this type can compromise the entire system. This necessitates timelocks on execution, allowing the community time to react to dangerous changes.
Transparency & Audit Trail
A secure proposal builder must provide a complete, immutable, and verifiable audit trail. Every action—draft creation, edits, sponsorship, and submission—should be recorded on-chain or in a verifiable manner. This prevents hidden alterations and ensures accountability. Lack of transparency in the drafting process can lead to governance attacks hidden in complex proposal text.
Proposal Builder vs. Manual Proposal Submission
A comparison of automated and manual approaches for constructing and submitting blocks to a blockchain network.
| Feature / Metric | Proposal Builder (e.g., MEV-Boost) | Manual Submission |
|---|---|---|
Primary Actor | Specialized third-party service (Builder) | Validator's own node |
Block Construction | Optimized for Maximal Extractable Value (MEV) | Local transaction pool (mempool) |
Revenue Source | Builder payment (bid) + standard rewards | Standard block rewards + transaction fees |
Execution Payload Source | External builder network via relay | Validator's local execution client |
Implementation Complexity | Low (integrates with client software) | High (requires custom software/configuration) |
Censorship Resistance | Lower (dependent on builder/relay policies) | Higher (direct control over tx inclusion) |
Time to Propose | < 1 second (pre-built payload) | 1-12 seconds (must construct block) |
MEV Capture Efficiency | High (access to specialized orderflow) | Low to Moderate (limited to public mempool) |
Frequently Asked Questions (FAQ)
Common questions about the Chainscore Proposal Builder, a tool for creating, simulating, and optimizing on-chain governance proposals.
A Proposal Builder is a specialized tool that streamlines the creation of on-chain governance proposals by providing a structured interface, simulation capabilities, and cost optimization. It works by guiding users through a step-by-step process: defining the proposal's executable calldata, setting parameters like the voting delay and voting period, simulating the transaction's on-chain effects and gas costs, and finally generating the formatted proposal for submission to the governance contract. This reduces errors and increases the likelihood of proposal success by allowing for pre-execution testing.
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.