init: alliance lp hub

.gitignore

@@ -16,6 +16,8 @@ node_modules
 .idea
 .env
 
+.vscode
+
 # Metadata from deployments
 scripts/.oracle_address.log
 scripts/.hub_address.log

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "contracts/alliance-hub",
     "contracts/alliance-oracle",
+    "contracts/alliance-lp-hub",
     "packages/alliance-protocol",
 ]
 exclude = []

contracts/alliance-hub/examples/schema.rs

@@ -1,4 +1,4 @@
-use alliance_protocol::alliance_protocol::{ExecuteMsg, InstantiateMsg, QueryMsg};
+use alliance_hub::models::{ExecuteMsg, InstantiateMsg, QueryMsg};
 use cosmwasm_schema::write_api;
 
 fn main() {

contracts/alliance-hub/schema/alliance-hub.json

@@ -1,6 +1,6 @@
 {
   "contract_name": "alliance-hub",
-  "contract_version": "0.1.0",
+  "contract_version": "0.1.1",
   "idl_version": "1.0.0",
   "instantiate": {
     "$schema": "http://json-schema.org/draft-07/schema#",

contracts/alliance-hub/src/contract.rs

@@ -3,8 +3,8 @@ use cosmwasm_std::entry_point;
 
 use alliance_protocol::alliance_oracle_types::QueryMsg as OracleQueryMsg;
 use alliance_protocol::alliance_protocol::{
-    AllianceDelegateMsg, AllianceRedelegateMsg, AllianceUndelegateMsg, AssetDistribution, Config,
-    ExecuteMsg, InstantiateMsg, MigrateMsg,
+    AllianceDelegateMsg, AllianceRedelegateMsg, AllianceUndelegateMsg, AssetDistribution,
+    MigrateMsg,
 };
 use cosmwasm_std::{
     to_json_binary, Addr, Binary, Coin as CwCoin, CosmosMsg, Decimal, DepsMut, Empty, Env,
@@ -15,20 +15,22 @@ use cw2::set_contract_version;
 use cw_asset::{Asset, AssetInfo, AssetInfoBase, AssetInfoKey, AssetInfoUnchecked};
 use cw_utils::parse_instantiate_response_data;
 use std::collections::{HashMap, HashSet};
-
-use alliance_protocol::alliance_oracle_types::{AssetStaked, ChainId, EmissionsDistribution};
+use alliance_protocol::{
+    alliance_oracle_types::{AssetStaked, ChainId, EmissionsDistribution},
+    token_factory::{CustomExecuteMsg, DenomUnit, Metadata, TokenExecuteMsg},
+    error::ContractError,
+};
 use terra_proto_rs::alliance::alliance::{
     MsgClaimDelegationRewards, MsgDelegate, MsgRedelegate, MsgUndelegate,
 };
 use terra_proto_rs::cosmos::base::v1beta1::Coin;
 use terra_proto_rs::traits::Message;
 
-use crate::error::ContractError;
+use crate::models::{InstantiateMsg, Config, ExecuteMsg};
 use crate::state::{
     ASSET_REWARD_DISTRIBUTION, ASSET_REWARD_RATE, BALANCES, CONFIG, TEMP_BALANCE, TOTAL_BALANCES,
     UNCLAIMED_REWARDS, USER_ASSET_REWARD_RATE, VALIDATORS, WHITELIST,
 };
-use crate::token_factory::{CustomExecuteMsg, DenomUnit, Metadata, TokenExecuteMsg};
 
 // version info for migration info
 const CONTRACT_NAME: &str = "crates.io:terra-alliance-protocol";
@@ -94,6 +96,7 @@ pub fn execute(
         ExecuteMsg::AllianceDelegate(msg) => alliance_delegate(deps, env, info, msg),
         ExecuteMsg::AllianceUndelegate(msg) => alliance_undelegate(deps, env, info, msg),
         ExecuteMsg::AllianceRedelegate(msg) => alliance_redelegate(deps, env, info, msg),
+
         ExecuteMsg::UpdateRewards {} => update_rewards(deps, env, info),
         ExecuteMsg::RebalanceEmissions {} => rebalance_emissions(deps, env, info),
 

contracts/alliance-hub/src/lib.rs

@@ -1,7 +1,6 @@
 pub mod contract;
-pub mod error;
 pub mod query;
 pub mod state;
+pub mod models;
 #[cfg(test)]
 mod tests;
-mod token_factory;

contracts/alliance-hub/src/models.rs

@@ -0,0 +1,112 @@
+use std::collections::{HashMap,HashSet};
+use alliance_protocol::{
+    alliance_oracle_types::ChainId, alliance_protocol::{
+        AllianceDelegateMsg, 
+        AllianceUndelegateMsg, 
+        AllianceRedelegateMsg,
+        AssetDistribution
+    },
+};
+use cosmwasm_schema::{QueryResponses, cw_serde};
+use cosmwasm_std::{Addr, Timestamp, Uint128};
+use cw_asset::{AssetInfo, Asset};
+
+
+#[cw_serde]
+pub struct Config {
+    pub governance: Addr,
+    pub controller: Addr,
+    pub oracle: Addr,
+    pub last_reward_update_timestamp: Timestamp,
+    pub alliance_token_denom: String,
+    pub alliance_token_supply: Uint128,
+    pub reward_denom: String,
+}
+
+#[cw_serde]
+pub struct InstantiateMsg {
+    pub governance: String,
+    pub controller: String,
+    pub oracle: String,
+    pub reward_denom: String,
+}
+
+#[cw_serde]
+pub enum ExecuteMsg {
+    // Public functions
+    Stake {},
+    Unstake(Asset),
+    ClaimRewards(AssetInfo),
+    UpdateRewards {},
+
+    // Privileged functions
+    WhitelistAssets(HashMap<ChainId, Vec<AssetInfo>>),
+    RemoveAssets(Vec<AssetInfo>),
+    UpdateRewardsCallback {},
+    AllianceDelegate(AllianceDelegateMsg),
+    AllianceUndelegate(AllianceUndelegateMsg),
+    AllianceRedelegate(AllianceRedelegateMsg),
+    RebalanceEmissions {},
+    RebalanceEmissionsCallback {},
+}
+
+#[cw_serde]
+#[derive(QueryResponses)]
+pub enum QueryMsg {
+    #[returns(Config)]
+    Config {},
+
+    #[returns(HashSet<Addr>)]
+    Validators {},
+
+    #[returns(WhitelistedAssetsResponse)]
+    WhitelistedAssets {},
+
+    #[returns(Vec<AssetDistribution>)]
+    RewardDistribution {},
+
+    #[returns(StakedBalanceRes)]
+    StakedBalance(AssetQuery),
+
+    #[returns(PendingRewardsRes)]
+    PendingRewards(AssetQuery),
+
+    #[returns(Vec<StakedBalanceRes>)]
+    AllStakedBalances(AllStakedBalancesQuery),
+
+    #[returns(Vec<PendingRewardsRes>)]
+    AllPendingRewards(AllPendingRewardsQuery),
+
+    #[returns(Vec<StakedBalanceRes>)]
+    TotalStakedBalances {},
+}
+pub type WhitelistedAssetsResponse = HashMap<ChainId, Vec<AssetInfo>>;
+
+#[cw_serde]
+pub struct AllPendingRewardsQuery {
+    pub address: String,
+}
+
+#[cw_serde]
+pub struct AllStakedBalancesQuery {
+    pub address: String,
+}
+
+#[cw_serde]
+pub struct PendingRewardsRes {
+    pub staked_asset: AssetInfo,
+    pub reward_asset: AssetInfo,
+    pub rewards: Uint128,
+}
+
+#[cw_serde]
+pub struct AssetQuery {
+    pub address: String,
+    pub asset: AssetInfo,
+}
+
+#[cw_serde]
+pub struct StakedBalanceRes {
+    pub asset: AssetInfo,
+    pub balance: Uint128,
+}

contracts/alliance-hub/src/query.rs

@@ -1,17 +1,13 @@
-use alliance_protocol::alliance_protocol::{
-    AllPendingRewardsQuery, AllStakedBalancesQuery, AssetQuery, PendingRewardsRes, QueryMsg,
-    StakedBalanceRes, WhitelistedAssetsResponse,
-};
 #[cfg(not(feature = "library"))]
 use cosmwasm_std::entry_point;
 use cosmwasm_std::{to_json_binary, Binary, Deps, Env, Order, StdResult, Uint128};
 use cw_asset::{AssetInfo, AssetInfoKey};
 use std::collections::HashMap;
 
-use crate::state::{
+use crate::{state::{
     ASSET_REWARD_DISTRIBUTION, ASSET_REWARD_RATE, BALANCES, CONFIG, TOTAL_BALANCES,
     UNCLAIMED_REWARDS, USER_ASSET_REWARD_RATE, VALIDATORS, WHITELIST,
-};
+}, models::{QueryMsg, WhitelistedAssetsResponse, StakedBalanceRes, AssetQuery, PendingRewardsRes, AllStakedBalancesQuery, AllPendingRewardsQuery}};
 
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {

contracts/alliance-hub/src/state.rs

@@ -1,10 +1,12 @@
 use alliance_protocol::alliance_oracle_types::ChainId;
-use alliance_protocol::alliance_protocol::{AssetDistribution, Config};
+use alliance_protocol::alliance_protocol::AssetDistribution;
 use cosmwasm_std::{Addr, Decimal, Uint128};
 use cw_asset::AssetInfoKey;
 use cw_storage_plus::{Item, Map};
 use std::collections::HashSet;
 
+use crate::models::Config;
+
 pub const CONFIG: Item<Config> = Item::new("config");
 pub const WHITELIST: Map<AssetInfoKey, ChainId> = Map::new("whitelist");
 

contracts/alliance-hub/src/tests/alliance.rs

@@ -1,11 +1,12 @@
 use crate::contract::execute;
-use crate::error::ContractError;
+use crate::models::{Config, ExecuteMsg};
+use alliance_protocol::error::ContractError;
 use crate::state::{CONFIG, VALIDATORS};
 use crate::tests::helpers::{
     alliance_delegate, alliance_redelegate, alliance_undelegate, setup_contract,
 };
 use alliance_protocol::alliance_protocol::{
-    AllianceDelegateMsg, AllianceDelegation, AllianceUndelegateMsg, Config, ExecuteMsg,
+    AllianceDelegateMsg, AllianceDelegation, AllianceUndelegateMsg
 };
 use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
 use cosmwasm_std::{Binary, CosmosMsg, StdResult, SubMsg, Uint128};

contracts/alliance-hub/src/tests/assets.rs

@@ -1,9 +1,9 @@
 use crate::contract::execute;
-use crate::error::ContractError;
+use alliance_protocol::error::ContractError;
 use crate::query::query;
 use crate::state::WHITELIST;
 use crate::tests::helpers::{remove_assets, setup_contract, whitelist_assets};
-use alliance_protocol::alliance_protocol::{ExecuteMsg, QueryMsg, WhitelistedAssetsResponse};
+use crate::models::{ExecuteMsg, QueryMsg, WhitelistedAssetsResponse};
 use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
 use cosmwasm_std::{from_json, Response};
 use cw_asset::{AssetInfo, AssetInfoKey};