Comment on page

Gov

The Gov Contract contains logic for holding polls and Mirror Token (MIR) staking, and allows the Mirror Protocol to be governed by its users in a decentralized manner. After the initial bootstrapping of Mirror Protocol contracts, the Gov Contract is assigned to be the owner of itself and Mirror Factory.​
New proposals for change are submitted as polls, and are voted on by MIR stakers through the voting procedure. Polls can contain messages that can be executed directly without changing the Mirror Protocol code.
The Gov Contract keeps a balance of MIR tokens, which it uses to reward stakers with funds it receives from trading fees sent by the Mirror Collector and user deposits from creating new governance polls. This balance is separate from the Community Pool, which is held by the Community contract (owned by the Gov contract).

Config

Key
Type
Description
mirror_token
HumanAddr
Contract address of Mirror Token (MIR)
quorum
Decimal
Minimum percentage of participation required for a poll to pass
threshold
Decimal
Minimum percentage of yes votes required for a poll to pass
voting_period
u64
Number of seconds during which votes can be cast
proposal_deposit
Uint128
MIR deposit required for a new poll to be submitted
effective_delay
u64
Number of seconds after a poll passes to apply changes
voter_weight
Decimal
Ratio of protocol fee which will be distributed among the governance poll voters
snapshot_period
u64
Minimum number of blocks before the end of voting period which snapshot could be taken to lock the current quorum for a poll
admin_manager
String
Address of the admin manager contract
poll_gas_limit
u64
Maximum amount of gas which a poll can consume during its execution

InitMsg

Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct InstantiateMsg {
pub mirror_token: String,
pub effective_delay: u64,
pub default_poll_config: PollConfig,
pub migration_poll_config: PollConfig,
pub auth_admin_poll_config: PollConfig,
pub voter_weight: Decimal,
pub snapshot_period: u64,
pub admin_manager: String,
pub poll_gas_limit: u64,
}
​
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub struct PollConfig {
pub proposal_deposit: Uint128,
pub voting_period: u64,
pub quorum: Decimal,
pub threshold: Decimal,
}
{
"mirror_token": "terra1...",
"effective_delay": 8
"default_poll_config": {
"quorum": "0.1",
"threshold": "0.5",
"voting_period": 8
"proposal_deposit": "100000000"
},
"migration_poll_config": {
"quorum": "0.1",
"threshold": "0.5",
"voting_period": 8
"proposal_deposit": "100000000"
},
"auth_admin_poll_config": {
"quorum": "0.1",
"threshold": "0.5",
"voting_period": 8
"proposal_deposit": "100000000"
},
"voter_weight": "0.5",
"snapshot_period": 8,
"admin_manager": "terra1...",
"poll_gas_limit": 8
}
Key
Type
Description
mirror_token
HumanAddr
Contract address of Mirror Token (MIR)
effective_delay
u64
Minimum percentage of participation required for a poll to pass
default_poll_config
PollConfig
PollConfig for default poll types
migration_poll_config
PollConfig
PollConfig for migration poll types
auth_admin_poll_config
PollConfig
PollConfig for governance configuration change and admin key transfer polls
effective_delay
u64
Number of blocks after a poll passes to apply changes
voter_weight
Decimal
Ratio of protocol fee which will be distributed among the governance poll voters
snapshot_period
u64
Minimum number of blocks before the end of voting period which snapshot could be taken to lock the current quorum for a poll
admin_manager
String
Address of the admin manager contract
poll_gas_limit
u64
Maximum amount of gas which a poll can consume during its execution

PollConfig

Key
Type
Description
proposal_deposit
Uint128
MIR deposit required for new polls to be submitted
voting_period
u64
Number of seconds during which votes can be cast
quorum
Decimal
Minimum percentage of participation required for a poll to pass
threshold
Decimal
Minimum percentage of yes votes required for a poll to pass

ExecuteMsg

Receive

Can be called during a CW20 token transfer when the Gov contract is the recipient. Allows the token transfer to execute a Receive Hook as a subsequent action within the same transaction.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum HandleMsg {
Receive {
amount: Uint128,
sender: HumanAddr,
msg: Option<Binary>,
}
}
{
"receive": {
"amount": "10000000",
"sender": "terra1...",
"msg": "eyAiZXhlY3V0ZV9tc2ciOiAiYmxhaCBibGFoIiB9"
}
}
Key
Type
Description
amount
Uint128
Amount of tokens received
sender
HumanAddr
Sender of token transfer
msg*
Binary
Base64-encoded JSON of Receive Hook​
* = optional

UpdateConfig

Updates the configuration for the Gov contract.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum HandleMsg {
UpdateConfig {
owner: Option<HumanAddr>,
quorum: Option<Decimal>,
threshold: Option<Decimal>,
voting_period: Option<u64>,
effective_delay: Option<u64>,
expiration_period: Option<u64>,
proposal_deposit: Option<Uint128>,
voter_weight: Option<Decimal>,
snapshot_period: Option<u64>,
}
}
{
"update_config": {
"owner": "terra...1",
"mirror_token": "terra1...",
"quorum": "0.1",
"threshold": "0.5",
"voting_period": 8,
"effective_delay": 8,
"expiration_period": 8,
"proposal_deposit": "100000",
"voter_weight": "0.5",
"snapshot_period": 8
}
}
Key
Type
Description
owner*
HumanAddr
Address of owner of governance contract
quorum*
Decimal
Minimum percentage of participation required for a poll to pass
threshold*
Decimal
Minimum percentage of yes votes required for a poll to pass
voting_period*
u64
Number of blocks during which votes can be cast
effective_delay*
u64
Number of blocks after a poll passes to apply changes
expiration_period*
u64
Number of blocks after a poll's voting period during which the poll can be executed
proposal_deposit*
Uint128
Minimum MIR deposit required for a new poll to be submitted
voter_weight*
Decimal
Ratio of protocol fee which will be distributed among the governance poll voters
snapshot_period*
u64
Minimum number of blocks before end of voting period which snapshot could be taken to lock the current quorum for a poll
* = optional

CastVote

Submits a user's vote for an active poll. Once a user has voted, they cannot change their vote with subsequent messages (increasing voting power, changing vote option, cancelling vote, etc.)
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum HandleMsg {
CastVote {
poll_id: u64,
vote: VoteOption,
amount: Uint128,
},
}
{
"cast_vote": {
"amount": "1000000",
"poll_id": 8,
"vote": "yes/no/abstain"
}
}
Key
Type
Description
amount
Uint128
Amount of voting power (staked MIR) to allocate
poll_id
u64
Poll ID
vote
VoteOption
Can be yes,no or abstain

WithdrawVotingTokens

Removes deposited MIR tokens from a staking position and returns them to a user's balance.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum HandleMsg {
WithdrawVotingTokens {
amount: Option<Uint128>,
}
}
{
"withdraw_voting_tokens": {
"amount": "10000000"
}
}
Key
Type
Description
amount*
Uint128
Amount of MIR tokens to withdraw. If empty, all staked MIR tokens are withdrawn.
* = optional

WithdrawVotingRewards

Withdraws a user’s voting reward for user’s voted governance poll after end_poll has happened.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum HandleMsg {
WithdrawVotingRewards {},
}
{
"withdraw_voting_rewards": {}
}

StakeVotingRewards

Immediately re-stakes user's voting rewards to Gov Contract.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum HandleMsg {
StakeVotingRewards {},
}
{
"stake_voting_rewards": {}
}

EndPoll

Can be issued by anyone to end the voting for an active poll. Triggers tally the results to determine whether the poll has passed. The current block height must exceed the end height of voting phase.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum HandleMsg {
EndPoll {
poll_id: u64,
}
}
{
"end_poll": {
"poll_id": 8
}
}
Key
Type
Description
poll_id
u64
Poll ID

ExecutePoll

Can be issued by anyone to implement into action the contents of a passed poll. The current block height must exceed the end height of the poll's effective delay.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum HandleMsg {
ExecutePoll {
poll_id: u64,
}
}
{
"execute_poll": {
"poll_id": 8
}
}
Key
Type
Description
poll_id
u64
Poll ID

SnapshotPoll

Snapshot of poll’s current quorum status is saved when the block height enters snapshot_period.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum HandleMsg {
SnapshotPoll {
poll_id: u64,
}
}
{
"snapshot_poll": {
"poll_id": 8
}
}
Key
Type
Description
poll_id
u64
Poll ID

Receive Hooks

StakeVotingTokens

WARNING
If you send MIR tokens to the Gov contract without issuing this hook, they will not be staked and will be irrevocably donated to the reward pool for stakers.
Issued when sending MIR tokens to the Gov contract to add them to their MIR staking position.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum Cw20HookMsg {
StakeVotingTokens {}
}
{
"stake_voting_tokens": {}
}

CreatePoll

Issued when sending MIR tokens to the Gov contract to create a new poll. Will only succeed if the amount of tokens sent meets the configuredproposal_depositamount. Contains a generic message to be issued by the Gov contract if it passes (can invoke messages in other contracts it owns).
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
#[allow(clippy::large_enum_variant)]
pub enum Cw20HookMsg {
CreatePoll {
title: String,
description: String,
link: Option<String>,
execute_msg: Option<PollExecuteMsg>,
admin_action: Option<PollAdminAction>,
},
​
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub struct PollExecuteMsg {
pub contract: String,
pub msg: Binary,
}
{
"create_poll": {
"description": "...",
"execute_msg": {
"contract": "terra1...",
"msg": "eyAiZXhlY3V0ZV9tc2ciOiAiYmxhaCBibGFoIiB9"
},
"link": "...",
"title": "...",
"admin_action": {
"contract": "terra1...",
"msg": "eyAiZXhlY3V0ZV9tc2ciOiAiYmxhaCBibGFoIiB9"
}
}
}
Key
Type
Description
description
string
Poll description
execute_msg*
ExecuteMsg
Message to be executed by Gov contract
link*
string
URL to external post about poll (forum, PDF, etc.)
title
string
Poll title
admin_action*
PollAdminAction
Messages to be executed for migration and authorize polls
* = optional

DepositReward

Reward is distributed between MIR stakers and governance poll voters based on voter_weight when rewards are sent from Mirror Collector.
Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum Cw20HookMsg {
DepositReward {},
}
{
"deposit_reward": {}
}

QueryMsg

Config

Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
Config {}
}
Response
#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
pub struct ConfigResponse {
pub owner: String,
pub mirror_token: String,
pub effective_delay: u64,
pub default_poll_config: PollConfig,
pub migration_poll_config: PollConfig,
pub auth_admin_poll_config: PollConfig,
pub voter_weight: Decimal,
pub snapshot_period: u64,
pub admin_manager: String,
pub poll_gas_limit: u64,
}
Key
Type
Description
mirror_token
HumanAddr
Contract address of Mirror Token (MIR)
default_poll_config
PollConfig
PollConfig for default polls
migration_poll_config
PollConfig
PollConfig for migration polls
auth_admin_poll_config
PollConfig
PollConfig for Authorize polls
effective_delay
u64
Number of blocks after a poll passes to apply changes
proposal_deposit
Uint128
Minimum MIR deposit required for a new poll to be submitted
voter_weight
Decimal
Ratio of protocol fee which will be distributed among the governance poll voters
snapshot_period
u64
Minimum number of blocks before end of voting period which snapshot could be taken to lock the current quorum for a poll
admin_manager
String
Address of admin manager contract
poll_gas_limit
u64
Maximum amount of gas which a poll can consume during its execution
{
"config": {}
}
Response
{
"config_response": {
"mirror_token": "terra1...",
"effective_delay": 8
"default_poll_config": {
"quorum": "0.1",
"threshold": "0.5",
"voting_period": 8
"proposal_deposit": "100000000"
},
"migration_poll_config": {
"quorum": "0.1",
"threshold": "0.5",
"voting_period": 8
"proposal_deposit": "100000000"
},
"auth_admin_poll_config": {
"quorum": "0.1",
"threshold": "0.5",
"voting_period": 8
"proposal_deposit": "100000000"
},
"voter_weight": "0.5",
"snapshot_period": 8,
"admin_manager": "terra1...",
"poll_gas_limit": 8
}
}
Key
Type
Description
mirror_token
HumanAddr
Contract address of Mirror Token (MIR)
default_poll_config
PollConfig
PollConfig of default polls
migration_poll_config
PollConfig
PollConfig of migration polls
auth_admin_poll_config
PollConfig
PollConfig of Authorize polls
quorum
Decimal
Minimum percentage of participation required for a poll to pass
threshold
Decimal
Minimum percentage of yes votes required for a poll to pass
voting_period
u64
Number of blocks during which votes can be cast
effective_delay
u64
Number of blocks after a poll passes to apply changes
proposal_deposit
Uint128
Minimum MIR deposit required for a new poll to be submitted
voter_weight
Decimal
Ratio of protocol fee which will be distributed among the governance poll voters
snapshot_period
u64
Minimum number of blocks before end of voting period which snapshot could be taken to lock the current quorum for a poll
admin_manager
String
Address of admin manager contract
poll_gas_limit
u64
Maximum amount of gas which a poll can consume during its execution

State

Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
State {}
}
Response
#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
pub struct StateResponse {
pub poll_count: u64,
pub total_share: Uint128,
pub total_deposit: Uint128,
pub pending_voting_rewards: Uint128,
}
Key
Type
Description
poll_count
u64
Total number of polls that have been created on Mirror Protocol
total_share
Uint128
Amount of staked MIR to governance contract
total_deposit
Uint128
Amount of locked MIR to governance polls
pending_voting_rewards
Uint128
Amount of voting rewards that are not claimed yet
{
"state": {}
}
Response
{
"state_response": {
"poll_count": 100,
"total_share": "1000000",
"total_deposit": "1000000",
"pending_voting_rewards": "1000000"
}
}
Key
Type
Description
poll_count
u64
Total number of polls that have been created on Mirror Protocol
total_share
Uint128
Amount of staked MIR to governance contract
total_deposit
Uint128
Amount of locked MIR to governance polls
pending_voting_rewards
Uint128
Amount of voting rewards that are not claimed yet

Staker

Rust
JSON
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
Staker {
address: HumanAddr,
}
}
Key
Type
Description
address
HumanAddr
Address of staker
Response
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
pub struct StakerResponse {
pub balance: Uint128,
pub share: Uint128,