Governance

The Gov Contract contains logic for holding polls and Valkyrie Token (VKR) staking, and allows the Valkyrie Protocol to be governed by its users in a decentralized manner.

New proposals for change are submitted as polls, and are voted on by VKR stakers through the Poll Lifecycle. Polls can contain messages that can be executed directly without changing the Valkyrie Protocol code.

InstantiateMsg

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct InstantiateMsg {
    pub contract_config: ContractConfigInitMsg,
    pub poll_config: PollConfigInitMsg,
}

{
  "contract_config":{
      "governance_token": "terra1..."
  },
  "poll_config":{
      "quorum": "0.4",
      "threshold": "0.5",
      "voting_period": 8,
      "execution_delay_period": 0,
      "proposal_deposit": "1000000",
      "snapshot_period":0
  },
}

ContractConfigInitMsg

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct ContractConfigInitMsg {
    pub governance_token: String,
}

{
  "contract_config_init_msg":{
      "governance_token": "terra1..."
  }
}

PollConfigInitMsg

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct PollConfigInitMsg {
    pub quorum: Decimal,
    pub threshold: Decimal,
    pub voting_period: u64,
    pub execution_delay_period: u64,
    pub proposal_deposit: Uint128,
    pub snapshot_period: u64,
}

{
  "poll_config_init_msg":{
      "quorum": "0.4",
      "threshold": "0.5",
      "voting_period": 8,
      "execution_delay_period": 0,
      "proposal_deposit": "1000000",
      "snapshot_period":0
  }
}

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.

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    Receive {
        amount: Uint128,
        sender: Addr,
        msg: Option<Binary>,
    }
}

{
  "receive": {
    "amount": "10000000",
    "sender": "terra1...",
    "msg": "eyAiZXhlY3V0ZV9tc2ciOiAiYmxhaCBibGFoIiB9"
  }
}

* = optional

UpdatePollConfig

Updates the configuration for the Gov contract.

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    UpdatePollConfig {
        quorum: Option<Decimal>,
        threshold: Option<Decimal>,
        voting_period: Option<u64>,
        execution_delay_period: Option<u64>,
        proposal_deposit: Option<Uint128>,
        snapshot_period: Option<u64>,
    }
}

{
  "update_poll_config": {
    "quorum": "123.456789",
    "threshold": "123.456789",
    "voting_period": 8,
    "execution_delay_period": 8,
    "proposal_deposit": "10000000",    
    "snapshot_period": 8 
  }
}

* = 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.)

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    CastVote {
        amount: Uint128,
        poll_id: u64,
        vote: VoteOption,
    }
}

{
  "cast_vote": {
    "amount": "10000000",
    "poll_id": 8,
    "vote": "yes/no"
  }
}

UnstakeGovernanceToken

Removes deposited VKR tokens from a staking position and returns them to a user's balance.

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    UnstakeGovernanceToken {
        amount: Option<Uint128>,
    }
}

{
  "unstake_governance_token": {
    "amount": "10000000"
  }
}

* = optional

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.

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    EndPoll {
        poll_id: u64,
    }
}

{
  "end_poll": {
    "poll_id": 8
  }
}

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.

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    ExecutePoll {
        poll_id: u64,
    }
}

{
  "execute_poll": {
    "poll_id": 8
  }
}

SnapshotPoll

Snapshot of poll’s current quorum status is saved when the block height enters snapshot_period.

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    SnapshotPoll {
        poll_id: u64,
    }
}

{
  "snapshot_poll": {
    "poll_id": 8
  }
}

RunExecution

This ExecuteMsg is only used as sub messages to ExecutePoll

To execute or roll back all ExecutionMsgs together, ExecuteMsg executes executions of Poll through RunExecution.

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    RunExecution {
        executions: Vec<ExecutionMsg>
    }
}

{
  "run_execution": {
    "executions": [{}]
  }
}

Receive Hooks

StakeGovernanceToken

WARNING

If you send VKR 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 VKR tokens to the Gov contract to add them to their VKR staking position.

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum Cw20HookMsg {
    StakeGovernanceToken {}
}

{
  "stake_governance_token": {}
}

CreatePoll

Issued when sending VKR tokens to the Gov contract to create a new poll. Will only succeed if the amount of tokens sent meets the configured proposal_deposit amount. Contains a generic message to be issued by the Gov contract if it passes (can invoke messages in other contracts it owns).

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum Cw20HookMsg {
    CreatePoll {
        title: String,
        description: String,
        link: Option<String>,
        executions: Vec<ExecuteMsg>,
    }
}

{
  "create_poll": {
     "title": "..."
     "description": "...",
     "link": "...",
     "executions": [
      {
        "contract": "terra1...",
        "msg": "eyAiZXhlY3V0ZV9tc2ciOiAiYmxhaCBibGFoIiB9"
      }..
      ],


  }
}

* = optional

QueryMsg

ContractConfig

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    ContractConfig {}
}

{
  "contract_config": {}
}

Response

#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
pub struct ContractConfigResponse {
    pub governance_token: String,
}

{
    "contract_config_response": {
        "governance_token": "terra1..."
    }
}

PollConfig

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    Pollconfig {}
}

{
  "poll_config": {}
}

Response

#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
pub struct PollConfigResponse {
    pub quorum: Decimal,
    pub threshold: Decimal,
    pub voting_period: u64,
    pub execution_delay_period: u64,
    pub proposal_deposit: Uint128,
    pub snapshot_period: u64,
}

{
    "poll_config_response": {
        "quorum": "0.1",
        "threshold": "0.5",
        "voting_period": 100000,
        "execution_delay_period": 13000,
        "proposal_deposit": "1000000",
        "snapshot_period": 1000
    }
}

* = optional

PollState

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    PollState {}
}

{
  "poll_state": {}
}

Response

#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
pub struct PollStateResponse {
    pub poll_count: u64,
    pub total_deposit: Uint128,
}

{
    "poll_state_response": {
        "poll_count": 100,
        "total_deposit": "1000000"
    }
}

Poll

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    Poll {
        poll_id: u64,
    }
}

{
  "poll": {
    "poll_id": 8
  }
}

Response

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
pub struct PollResponse {
    pub id: u64,
    pub title: String,
    pub description: String,
    pub link: Option<String>,
    pub executions: Option<Vec<ExecutionMsg>>,
    pub creator: String,
    pub deposit_amount: Uint128,
    pub yes_votes: Uint128,
    pub no_votes: Uint128,
    pub abstain_votes: Uint128,
    pub end_height: u64,
    pub status: PollStatus,
    pub staked_amount: Option<Uint128>,
    pub total_balance_at_end_poll: Option<Uint128>,
}

{
    "poll_response": {
        "id": 1,    
        "title": ".....",
        "description": "....",
        "link": "https://app.valkyrieprotocol.money",
        "executions": [{ExecutionMsg}],
        "creator": "terra1...",
        "deposit_amount": 1000000,
        "yes_votes": 1000000,
        "no_votes": 1000000,
        "abstain_votes": 1000000,
        "end_height": 1000000,
        "status": "in_progress",
        "staked_amount": 1000000
        "total_balance_at_end_poll": 1000000
    }
}

*=optional

Polls

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    Polls {
        filter: Option<PollStatus>,
        start_after: Option<u64>,
        limit: Option<u32>,
        order_by: Option<OrderBy>,
    }
}

{
  "polls": {
      "filter": "in_progress",
      "start_after": 8,      
      "limit": 8,
      "order_by": "dec"      
  }
}

*=optional

Response

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
pub struct PollsResponse {
    pub polls: Vec<PollResponse>,
}

{
    "polls_response": {
        "polls": [
            {
                "id": 1,    
                "title": ".....",
                "description": "....",
                "link": "https://valkyrie.money",
                "executions": [{ExecutionMsg}],
                "creator": "terra1...",
                "deposit_amount": "1000000",
                "yes_votes": "1000000",
                "no_votes": "1000000",
                "abstain_votes": "1000000",
                "end_height": 1000000,
                "status": "in_progress",
                "staked_amount": "1000000"
                "total_balance_at_end_poll": "1000000"
            },
            ...
        ]
    }
}

Voters

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    Voters {
        poll_id: u64,
        start_after: Option<String>,
        limit: Option<u32>,
        order_by: Option<OrderBy>,
    }
}

{
  "voters": {
        "poll_id": 3,
        "start_after": "  ",
        "limit": 3,
        "order_by": "dec",
  }
}

*=optional

Response

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema)]
pub struct VotersResponse {
    pub voters: Vec<VoteInfoMsg>,
}

{
    "voters_response": {
        "voters": [{
            "voter": "terra1...",
            "option": "yes",
            "amount": 100,
        },...
        ]
    }
}

StakingState

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    StakingState {}
}

{
  "staking_state": {}
}

Response

#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
pub struct StakingStateResponse {
    pub total_share: Uint128,
}

{
    "staking_state_response": {
        "total_share": 1
    }
}

StakerState

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    StakerState { 
        address: String 
    }
}

{
  "staker_state": {
    "address" : "...."
  }
}

Response

#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
pub struct StakerStateResponse {
    pub balance: Uint128,
    pub share: Uint128,
    pub votes: Vec<(u64, VoteInfoMsg)>,
}

{
    "staker_state_response": {
        "balance": 100,
        "share": 100000,
        "votes":[(1,{"voter":"terra1...","option":"yes","amount": 100,})...]
    }
}

VotingPower

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    VotingPower { 
        address: String 
    }
}

{
  "voting_power": {
    "address" : "...."
  }
}

Response

#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
pub struct VotingPowerResponse {
    pub voting_power: Decimal
}

{
    "voting_power_response": {
        "voting_power": 100
    }
}

PreviousCampaign NextCommunity

Last updated 2 years ago