The ProtocolDAO Token

The ProtocolDAO token is issued automatically to anyone who buys a community token, in proportion to the AE they spend. It is one platform-wide token, intended for protocol-level governance. Issuance is live; the governance it is named after is not yet built. There is no ProtocolDAO contract, no proposal mechanism and no staking.

It is not a community token. A community token governs one community's treasury through that community's DAO.

Properties

The factory holds the token in its state and exposes two entrypoints:

CommunityFactory.protocol_dao_token() : FungibleTokenFull
CommunityFactory.mint_protocol_dao_token(buy_value: int, receiver: address) : unit

protocol_dao_token() returns the AEX-9 contract, so you can look it up from the factory rather than hardcoding an address. mint_protocol_dao_token is declared on the ICommunityFactory interface, which is how a token sale calls back into its factory to mint on the buyer's behalf. Only a sale contract the factory itself deployed can mint:

stateful entrypoint mint_protocol_dao_token(buy_value : int, receiver : address) =
  require(Set.member(Call.caller, state.known_token_sales), "NOT_KNOWN_TOKEN_SALE")
  state.protocol_dao_token.mint(receiver, buy_value * protocol_dao_token_multiplier)

known_token_sales is populated by create_community and nothing else. There is no owner mint and no other issuance path, so ProtocolDAO supply is exactly 1,000 times the AE ever spent buying community tokens through the factory.

The token contract is an ordinary FungibleTokenFull with 18 decimals, so the whole AEX-9 surface applies: balance, total_supply, transfer, create_allowance and the rest. Its name and symbol are the same string, set once at factory deployment by CommunityFactory.init(protocol_token_name).

Addresses

protocol_dao_token() on the factory for that network returns the same address.

How much a buy mints

The chain mints 1,000× the AE paid. The sale contract passes the amount actually spent:

if (Call.caller != state.factory.address)
  state.factory.mint_protocol_dao_token(Call.value - overpaid_refund, Call.caller)
else ()

Call.value - overpaid_refund is the curve price plus the 0.5% affiliation fee, with any slippage buffer already refunded. A buy quoted at 1.000 AE of curve value costs 1.005 AE and mints 1005 ProtocolDAO tokens. Attaching a 3% slippage buffer does not mint 3% more: the refund happens first.

When create_community performs an initial buy, the caller of the sale is the factory, so the sale skips the callback and the factory mints directly, with the same multiplier.

The Mint event on the ProtocolDAO token contract carries the exact amount, and the app reads that event to report what you received.

What does not exist yet

• There is no ProtocolDAO governance contract. No deployed contract implements platform-wide proposals or voting for this token.
• There is no staking. No staking entrypoint exists on the token or the factory.
• The token does nothing in the app. No screen consumes a ProtocolDAO balance, and no feature is gated on holding one.
• It is not the æternity governance system. The polls at /voting are weighted by AE balance and delegation, not by ProtocolDAO tokens. See Governance and Voting.
• It is not a community DAO token. Community votes are weighted by that community's own AEX-9 token. See Voting.

The token is a standard FungibleTokenFull, so its transfer entrypoints work; it is not a bonding-curve token and has no protocol-native market.

Related

• Community DAOs: the per-community governance that exists today.
• Governance and Voting: æternity-wide polls, weighted by AE.
• Value flow: where ProtocolDAO issuance sits in what a buyer pays and receives.
• Community Factory contract reference: the factory entrypoints that mint it.
• AEX standards: the AEX-9 interface this token implements.