Staking

The Staking Contract contains the logic for LP Token staking and reward distribution. Staking rewards for LP stakers come from the new VKR tokens generated at each block by the Factory Contract and are split between all combined staking pools.

InstantiateMsg

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct InstantiateMsg {
    pub token: String,
    pub pair: String,
    pub lp_token: String,
}

Key	Type	Description
token	String	Contract address of the Valkyrie Token (VKR)
pair	String	Terraswap pairs (TerraUSD)
lp_token	String	Contract address of the LP token to be staked

ExecuteMsg

Receive

Can be called during a CW20 token transfer when the Mint contract is the recipient. Allows the token transfer to execute a Receive Hook as a subsequent action within the same transaction.

Rust

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

JSON

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

Key	Type	Description
amount	Uint128	Token amount received
sender	Addr	Sender of token transaction
msg*	Binary	Base64-encoded JSON of Receive Hook message

* = optional

Unbond

Users can issue the unbond message at any time to remove their staked LP tokens from a staking position.

Rust

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

JSON

{
  "unbond": {
    "amount": "10000000",
  }
}

Key	Type	Description
amount	Uint128	Amount of LP tokens to unbond

Withdraw

Withdraws a user's rewards for a specific staking position.

Rust

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

JSON

{
  "withdraw": { }
}

AutoStake

When providing liquidity in Valkyrie Protocol, asset pair is first sent to Staking contract, and it acts as a relay. When defined assets are sent to the contract, the contract provides liquidity to receive LP tokens and starts AutoStakeHook

Note: Executor of the transaction should first increase allowance to spend CW20 tokens

Rust

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

JSON

{
  "AutoStake": {
    "token_amount": 10000,
    "slippage_tolerance": 100,    
  }
}

Key	Type	Description
token_amount	Uint128	Amount of VKR token that are provided into liquidity pool
slippage_tolerance*	Decimal	Maximum price slippage allowed to execute this transaction

* = optional

AutoStakeHook

[INTERNAL]

Hook to stake the minted LP tokens from providing liquidity.

Rust

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    AutoStakeHook {
        staker_addr: String,
        prev_staking_token_amount: Uint128,
    }
}

JSON

{
  "auto_stake_hook": {
    "staker_addr": "terra1...",
    "already_staked_amount": 10000,    
  }
}

Key	Type	Description
staker_addr	String	Address of the staker
prev_staking_token_amount	Uint128	LP staking balance of the staker before this transaction

Receive Hooks

Bond

WARNING

If you send LP Tokens to the Staking contract without issuing this hook, they will not be staked and will BE LOST FOREVER.

Can be issued when the user sends LP Tokens to the Staking contract. The LP token must be recognized by the staking pool of the specified asset token.

Rust

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

JSON

{
  "bond": {
  }
}

DepositReward

Rust

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

JSON

{
  "deposit_reward": {
  }
}

QueryMsg

Config

Rust

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

JSON

{
  "config": {}
}

State

Rust

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

JSON

{
  "state": {}
}

StakerInfo

Rust

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

JSON

{
  "staker_info": {
    "staker_addr" : "terra1..."
  }
}

Key	Type	Description
staker_addr	String	Wallet address of Lp staker

Response

Rust

#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema)]
pub struct StakerInfoResponse {
    pub staker: String,
    pub bond_amount: Uint128,
    pub pending_reward: Uint128,
}

JSON

{
    "staker_info_response": {
        "staker":"terra1...",
        "bond_amount": 1000,        
        "pending_reward": 1000
    }
}

Key	Type	Description
staker	String	Address of the staker
bond_amount	Uint128	Amount of LP or sLP tokens staked
pending_reward	Uint128	Amount of reward that are not claimed