Concepts
Protocol Governance
Testnet, signalling only · Estimated read time: 8 minutes
1. Status
Governance is a system contract at ase1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr624k8e. It runs on the public testnet only.
It is a signalling contract. It records proposals, votes and a final result. Nothing is executed automatically: a passed proposal does not change a parameter, move treasury funds, or upgrade the protocol. The on-chain effect of a vote is the recorded result, and nothing more. Any real change still ships as a node release.
Governance v2 has been live since block 330,000 (node release 0.6.79, 1 October 2026). Proposing and voting are open on asentum.com/governance, and library proposals are disabled. See the upgrade note below.
2. Who can propose and vote
Anyone. Any address can create a proposal (with a 100 ASE bond) and any address can vote. You do not need to be a validator or a delegator.
Voting is lock-to-vote: your vote weight is exactly the ASE you send with the vote. Send 50 ASE, your vote counts 50. The ASE is locked until that vote's voting window ends, then you withdraw it.
Voting is not stake-weighted yet. Bonded or delegated stake gives you no votes. Each address can vote once per proposal, for or against. There is no abstain option.
You vote on asentum.com/governance with the Asentum Wallet browser extension. The Operator desktop app, the CLI and the SDK have no governance commands.
3. Exact parameters
There is one kind of proposal. There are no tiers. Every number below is fixed in the contract.
| Parameter | Value | Notes |
|---|---|---|
| Proposal bond | 100 ASE | Sent with propose(). Returned when quorum is met. |
| Voting window | 2,160 to 604,800 blocks | About 72 minutes to 14 days at 2 second blocks. |
| Default window | 43,200 blocks | About 24 hours. |
| Quorum | 1,000 ASE of votes | The proposer’s own vote does not count toward quorum. |
| Majority | More for than against | Simple majority. A tie is rejected. |
| Execution delay | 100 blocks | execute() opens 100 blocks after voting ends. Anyone can call it. |
| Amendments | Up to 16 per proposal | No bond. Own vote, 21,600 blocks at most. |
| Open votes per address | 32 | Withdraw finished votes to free slots. |
Windows are counted in blocks, not hours. If blocks slow down, the window takes longer in wall-clock time.
When execute() runs, the proposal ends in one of three outcomes: passed (quorum met, more for than against), rejected (quorum met, against greater than or equal to for), or no_quorum (less than 1,000 ASE of votes from people other than the proposer).
4. Where your ASE goes
The contract holds three kinds of ASE: vote weight that has not been withdrawn yet, bonds that have not been settled yet, and forfeited bonds.
- Vote weight becomes withdrawable as soon as voting on that proposal (or amendment) ends. You do not have to wait for execute().
withdraw()pays out every finished vote at once.withdrawVote(id)andwithdrawAmendmentVote(id, amendmentId)pay out one. - The bond goes back to the proposer when execute() runs and quorum was met, whether the result is passed or rejected.
- A forfeited bond is one from a proposal that ended with no_quorum. It stays in the contract and is tracked as
forfeitedBonds.
Methods that do not take ASE (execute, the withdraw methods, proposeAmendment and claimBond) revert if you send ASE with them. The support value on a vote must be true or false; anything else reverts.
Worked example
- Alice proposes with the default 43,200 block window and sends 100 ASE as the bond. The contract now holds 100 ASE.
- Bob votes for and sends 1,500 ASE. Carol votes against and sends 3 ASE. The contract holds 1,603 ASE.
- Voting ends. Bob and Carol can withdraw straight away. Bob calls withdraw() and gets 1,500 ASE back. Carol gets her 3 ASE back the same way. The contract holds Alice's 100 ASE bond.
- 100 blocks later, anyone calls execute(). Votes from people other than Alice total 1,503 ASE, which meets the 1,000 ASE quorum. For (1,500) beats against (3), so the result is passed. Alice's 100 ASE bond is sent back to her. The contract holds nothing for this proposal.
If Bob had sent 500 ASE instead, the counted votes would be 503 ASE, below quorum. The result would be no_quorum, Alice's 100 ASE would be forfeited, and Bob and Carol would still get their full vote weight back. Alice voting on her own proposal would not change this: her own vote counts in the for and against totals but not toward quorum.
5. Amendments
- Anyone can post an amendment to an active proposal. There is no bond.
- A proposal can have up to 16 amendments.
- Each amendment has its own lock-to-vote ballot, for or against. It runs for 21,600 blocks (about 12 hours) or until the parent's voting ends, whichever comes first.
- Amendments close when the parent is executed. Each is marked passed if it has more for than against, otherwise rejected. There is no quorum on amendments.
- Amendment vote weight is withdrawable once the amendment's voting ends, the same way as proposal votes.
Amendments are signalling only. They do not change the parent proposal's text and they do not reset its voting window.
6. Categories
Every proposal has a category. It is a label that helps people filter proposals. It does not change the bond, window, quorum or majority.
| Category | Use it for |
|---|---|
| general | Anything else: community questions, ecosystem ideas. This is the default. |
| parameter | Asking the network to change a protocol parameter. The change itself still needs a node release. |
| aip | An Asentum Improvement Proposal: a change to the protocol or its standards. |
The library category is disabled. Proposing with it reverts.
7. Library approval (disabled)
Governance v1 could approve a JavaScript library, which the node then injected into every contract as a global. That was unsafe: a library could take any name (including names contracts already rely on), it reached every contract including staking, and it ran without gas.
From block 330,000 the contract refuses library proposals and the node stops injecting libraries. The approved list is empty.
Bringing it back needs reserved names that a library cannot take, metered (gas-charged) evaluation, pinned versions so a contract knows exactly which code it gets, and a higher approval bar than a simple majority. That is future work. See Approved Libraries.
8. Endpoints and contract methods
Read endpoints on the node RPC at https://testnet.asentum.com:
| Endpoint | Returns |
|---|---|
| GET /governance/proposals | The newest 50 proposals. |
| GET /governance/proposal/<id> | One proposal with its amendments. |
| GET /governance/locked/<address> | ASE the address has locked in votes. |
| GET /governance/withdrawable/<address> | locked, withdrawable and the open positions. |
| GET /governance/libraries | Always an empty list now. |
There are no governance JSON-RPC methods. Use the endpoints above or call the contract's view methods directly.
| Method | What it does |
|---|---|
| propose(title, description, category, votingPeriod) | Create a proposal. Send at least 100 ASE as the bond. |
| vote(proposalId, support) | Vote for (true) or against (false). The ASE sent is the vote weight. |
| proposeAmendment(proposalId, title, description) | Post an amendment. No ASE. |
| voteOnAmendment(proposalId, amendmentId, support) | Vote on an amendment. The ASE sent is the vote weight. |
| execute(proposalId) | Settle the result and the bond, 100 blocks after voting ends. Anyone can call it. |
| withdraw() | Pay out every vote whose voting has ended. |
| withdrawVote(proposalId) | Pay out one proposal vote. |
| withdrawAmendmentVote(proposalId, amendmentId) | Pay out one amendment vote. |
| claimBond(proposalId) | Settle the bond of a proposal that was concluded before v2. |
| getProposal(id) | View: one proposal. |
| getProposals(offset, limit) | View: newest first, up to 50 per page. |
| getAmendments(proposalId) | View: amendments of one proposal. |
| proposalCount() | View: number of proposals. |
| getLockedBalance(address) | View: ASE locked in votes. |
| getWithdrawable(address) | View: locked, withdrawable, positions. |
| getForfeitedBonds() | View: total forfeited bonds held by the contract. |
9. Roadmap
None of the following is live. These are planned directions, and each will be announced when it ships:
- Stake-weighted voting. Bonded and delegated stake counting as voting power, instead of or alongside lock-to-vote.
- Percentage quorum. Quorum as a share of staked ASE instead of a fixed 1,000 ASE.
- Proposal tiers. Stricter bond, window and majority for high-impact proposals.
- Veto. A way to block harmful proposals that pass a simple majority.
- Treasury control. Proposals that move treasury funds on chain when they pass.
- Binding execution. Passed proposals that change parameters on chain, with a timelock.
Some things stay outside governance even then. The 1 billion ASE maximum supply, post-quantum signatures (ML-DSA-65) and the plain JavaScript contract model are enforced by the node itself, not by any contract. These are the hard floors: changing them would take a new node release that the network chooses to run, not a vote.
10. The 0.6.79 upgrade
Governance v1 took vote weight and bonds but never sent any ASE back. Its withdraw() only reset a counter. No ASE was lost to this on chain: the v1 contract never held any ASE.
Node 0.6.79 replaces the contract code at block 330,000 and keeps its storage, so every earlier proposal and vote is still there. v2 pays vote weight back when voting ends, returns bonds on quorum, ignores the proposer's own vote for quorum, rejects anything other than true or false as support, caps amendments at 16, and disables libraries. Votes made before v2 can be withdrawn with withdrawVote or withdrawAmendmentVote, and bonds of proposals concluded before v2 with claimBond.
The chain passed block 330,000 on 1 October 2026. Proposing and voting are open again on the site.
Read next