> For the complete documentation index, see [llms.txt](https://zokyo-auditing-tutorials.gitbook.io/zokyo-tutorials/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://zokyo-auditing-tutorials.gitbook.io/zokyo-tutorials/tutorial-48-governance-and-voting/missing-payable-keyword-in-governance-execute-function.md).

# Missing payable Keyword in Governance Execute Function

In decentralized governance systems, the ability to execute proposals is a critical feature, allowing community-approved decisions to be implemented on-chain. However, if the governance contract’s `execute` function is not marked as `payable`, it will not be able to accept Ether or other native tokens as part of the execution process. This can lead to failed transactions when proposals involve sending or receiving funds, disrupting the governance process.

Moreover, even if the `execute` function can receive funds (e.g., through an unintentional fallback mechanism or implicit acceptance of funds), failing to handle excess Ether in the transaction can result in users overspending, leading to inefficiencies or loss of assets.

**Case 1: The `execute` Function Is Not Payable**

When a governance proposal involves sending funds as part of its execution, the contract’s `execute` function must be marked with the `payable` keyword. If the function is not `payable`, any attempt to send Ether alongside the execution will result in the transaction being reverted, preventing the proposal from being successfully executed. This is particularly problematic for proposals that involve transferring funds or interacting with contracts that require payments.

**Impact**

* **Failed Proposal Execution**: Any proposal requiring the transfer of Ether or tokens will fail, rendering certain governance actions impossible.
* **Governance Stalemate**: The governance system may become ineffective if proposals requiring payments cannot be executed, leading to stalled decision-making and a lack of progress in the protocol’s development.

**Case 2: The Contract Can Receive Funds but Doesn't Return Excess Ether**

Another common issue arises when the `execute` function or similar mechanisms can receive funds, but do not handle excess Ether properly. In some cases, users may send more Ether than necessary, especially when the exact amount needed for a proposal is uncertain or dynamically calculated. If the contract fails to return the excess funds to the sender, the user may end up overpaying for the transaction, leading to unintended financial loss.