From 6a9be39b6b5302b74816dfe2cbc3a37be4cd89ec Mon Sep 17 00:00:00 2001 From: emidev98 Date: Fri, 19 Jan 2024 17:09:41 +0200 Subject: [PATCH] feat: refact the smart contact stores --- contracts/alliance-lp-hub/src/contract.rs | 126 ++++++++++-------- contracts/alliance-lp-hub/src/models.rs | 70 ++-------- contracts/alliance-lp-hub/src/query.rs | 91 ++++++------- contracts/alliance-lp-hub/src/state.rs | 23 +++- .../alliance-lp-hub/src/tests/helpers.rs | 7 +- .../alliance-lp-hub/src/tests/instantiate.rs | 2 - packages/alliance-protocol/src/error.rs | 3 + 7 files changed, 152 insertions(+), 170 deletions(-) diff --git a/contracts/alliance-lp-hub/src/contract.rs b/contracts/alliance-lp-hub/src/contract.rs index 7c6bcb9..53d11d7 100644 --- a/contracts/alliance-lp-hub/src/contract.rs +++ b/contracts/alliance-lp-hub/src/contract.rs @@ -1,3 +1,11 @@ +use crate::{ + astro_models::{Cw20Msg, ExecuteAstroMsg, QueryAstroMsg, RewardInfo}, + models::{Config, ExecuteMsg, InstantiateMsg, ModifyAssetPair, PendingRewardsRes}, + state::{ + ASSET_REWARD_RATE, BALANCES, CONFIG, TEMP_BALANCE, TOTAL_BALANCES, UNCLAIMED_REWARDS, + USER_ASSET_REWARD_RATE, VALIDATORS, WHITELIST, + }, +}; use alliance_protocol::alliance_oracle_types::EmissionsDistribution; use alliance_protocol::{ alliance_protocol::{ @@ -18,23 +26,12 @@ use cw_asset::{Asset, AssetInfo, AssetInfoKey, AssetInfoUnchecked}; use cw_utils::parse_instantiate_response_data; use std::str::FromStr; use std::{collections::HashSet, env}; -use terra_proto_rs::cosmos::evidence; use terra_proto_rs::{ alliance::alliance::{MsgClaimDelegationRewards, MsgDelegate, MsgRedelegate, MsgUndelegate}, cosmos::base::v1beta1::Coin, traits::Message, }; -use crate::models::{AssetRewardRate, AssetUnclaimedRewards}; -use crate::{ - astro_models::{Cw20Msg, ExecuteAstroMsg, QueryAstroMsg, RewardInfo}, - models::{Config, ExecuteMsg, InstantiateMsg, ModifyAsset, PendingRewardsRes}, - state::{ - ASSET_REWARD_RATE, BALANCES, CONFIG, TEMP_BALANCE, TOTAL_BALANCES, UNCLAIMED_REWARDS, - USER_ASSET_REWARD_RATE, VALIDATORS, WHITELIST, - }, -}; - // version info for migration info const CONTRACT_NAME: &str = "crates.io:terra-alliance-lp-hub"; const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION"); @@ -57,7 +54,6 @@ pub fn instantiate( set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?; let governance_address = deps.api.addr_validate(msg.governance.as_str())?; let controller_address = deps.api.addr_validate(msg.controller.as_str())?; - deps.api.addr_validate(msg.astro_reward_denom.as_str())?; let astro_incentives_address = deps .api .addr_validate(msg.astro_incentives_address.as_str())?; @@ -72,7 +68,6 @@ pub fn instantiate( let config = Config { governance: governance_address, controller: controller_address, - astro_reward_denom: msg.astro_reward_denom, fee_collector: fee_collector_address, astro_incentives: astro_incentives_address, alliance_token_denom: "".to_string(), @@ -96,7 +91,7 @@ pub fn execute( msg: ExecuteMsg, ) -> Result { match msg { - ExecuteMsg::ModifyAssets(assets) => modify_assets(deps, info, assets), + ExecuteMsg::ModifyAssetPairs(assets) => modify_assets(deps, info, assets), ExecuteMsg::Receive(cw20_msg) => { let sender = deps.api.addr_validate(&cw20_msg.sender)?; @@ -139,7 +134,7 @@ pub fn execute( fn modify_assets( deps: DepsMut, info: MessageInfo, - assets: Vec, + assets: Vec, ) -> Result { let config = CONFIG.load(deps.storage)?; is_governance(&info, &config)?; @@ -155,12 +150,21 @@ fn modify_assets( ]); } else { let asset_key = AssetInfoKey::from(asset.asset_info.clone()); + let reward_asset_info_key = match asset.reward_asset_info { + Some(reward_asset_info) => AssetInfoKey::from(reward_asset_info), + None => { + return Err(ContractError::MissingRewardAsset( + asset.asset_info.to_string(), + )) + } + }; + WHITELIST.save(deps.storage, asset_key.clone(), &Decimal::zero())?; ASSET_REWARD_RATE.update( deps.storage, - asset_key, + (asset_key, reward_asset_info_key), |asset_reward_rate| -> StdResult<_> { - Ok(asset_reward_rate.unwrap_or(AssetRewardRate::zero())) + Ok(asset_reward_rate.unwrap_or(Decimal::zero())) }, )?; attrs.extend_from_slice(&[("asset".to_string(), asset.asset_info.to_string())]); @@ -183,20 +187,25 @@ fn stake( WHITELIST .load(deps.storage, asset_key.clone()) .map_err(|_| ContractError::AssetNotWhitelisted(received_asset.info.to_string()))?; - - let rewards = _claim_reward(deps.storage, sender.clone(), received_asset.info.clone())?; + let config = CONFIG.load(deps.storage)?; + let reward_token = AssetInfoKey::from(AssetInfo::Native(config.alliance_token_denom)); + let rewards = _claim_alliance_rewards( + deps.storage, + sender.clone(), + received_asset.info.clone(), + reward_token, + )?; if !rewards.is_zero() { UNCLAIMED_REWARDS.update( deps.storage, (sender.clone(), asset_key.clone()), |balance| -> Result<_, ContractError> { - let mut unclaimed_rewards = balance.unwrap_or(AssetUnclaimedRewards::zero()); - unclaimed_rewards.alliance_reward_rate += rewards; + let mut unclaimed_rewards = balance.unwrap_or(Uint128::zero()); + unclaimed_rewards += rewards; Ok(unclaimed_rewards) }, )?; } - let config = CONFIG.load(deps.storage)?; // Query astro incentives, to do so we must first remove the prefix // from the asset info e.g. cw20:asset1 -> asset1 or native:uluna -> uluna @@ -279,7 +288,8 @@ fn stake( let asset_reward_rate = ASSET_REWARD_RATE .load(deps.storage, asset_key.clone()) - .unwrap_or(AssetRewardRate::zero()); + .unwrap_or_default(); + USER_ASSET_REWARD_RATE.save( deps.storage, (sender.clone(), asset_key), @@ -295,15 +305,21 @@ fn unstake(deps: DepsMut, info: MessageInfo, asset: Asset) -> Result Result<_, ContractError> { - let mut unclaimed_rewards = balance.unwrap_or(AssetUnclaimedRewards::zero()); - unclaimed_rewards.alliance_reward_rate += rewards; + let mut unclaimed_rewards = balance.unwrap_or_default(); + unclaimed_rewards += rewards; Ok(unclaimed_rewards) }, )?; @@ -355,14 +371,15 @@ fn claim_rewards( ) -> Result { let user = info.sender; let config = CONFIG.load(deps.storage)?; - let rewards = _claim_reward(deps.storage, user.clone(), asset.clone())?; + let reward_token = AssetInfoKey::from(AssetInfo::Native(config.alliance_token_denom)); + let rewards = _claim_alliance_rewards(deps.storage, user.clone(), asset.clone(), reward_token)?; let unclaimed_rewards = UNCLAIMED_REWARDS .load( deps.storage, (user.clone(), AssetInfoKey::from(asset.clone())), ) - .unwrap_or(AssetUnclaimedRewards::zero()); - let final_rewards = rewards + unclaimed_rewards.alliance_reward_rate; + .unwrap_or_default(); + let final_rewards = rewards + unclaimed_rewards; UNCLAIMED_REWARDS.remove( deps.storage, (user.clone(), AssetInfoKey::from(asset.clone())), @@ -384,32 +401,31 @@ fn claim_rewards( } } -fn _claim_reward( +fn _claim_alliance_rewards( storage: &mut dyn Storage, user: Addr, - asset: AssetInfo, + staked_asset: AssetInfo, + reward_denom: AssetInfoKey, ) -> Result { - let asset_key = AssetInfoKey::from(&asset); - let user_reward_rate = USER_ASSET_REWARD_RATE.load(storage, (user.clone(), asset_key.clone())); - let asset_reward_rate = ASSET_REWARD_RATE.load(storage, asset_key.clone())?; + let asset_key = AssetInfoKey::from(&staked_asset); + let asset_reward_rate = ASSET_REWARD_RATE.load(storage, (asset_key.clone(), reward_denom))?; + let user_staked = BALANCES.load(storage, (user.clone(), asset_key.clone()))?; + let user_staked = Decimal::from_atomics(user_staked, 0)?; + let user_reward_rate = USER_ASSET_REWARD_RATE.load(storage, (user, asset_key, reward_denom)); if let Ok(user_reward_rate) = user_reward_rate { - let user_staked = BALANCES.load(storage, (user.clone(), asset_key.clone()))?; - let rewards = ((asset_reward_rate.alliance_reward_rate - - user_reward_rate.alliance_reward_rate) - * Decimal::from_atomics(user_staked, 0)?) - .to_uint_floor(); + + let rewards = ((asset_reward_rate - user_reward_rate) * user_staked).to_uint_floor(); if rewards.is_zero() { - Ok(Uint128::zero()) + return Ok(Uint128::zero()) } else { - USER_ASSET_REWARD_RATE.save(storage, (user, asset_key), &asset_reward_rate)?; - Ok(rewards) + USER_ASSET_REWARD_RATE.save(storage, (user, asset_key, reward_denom), &asset_reward_rate)?; + return Ok(rewards) } } else { - // If cannot find user_reward_rate, assume this is the first time they are staking and set it to the current asset_reward_rate - USER_ASSET_REWARD_RATE.save(storage, (user, asset_key), &asset_reward_rate)?; - - Ok(Uint128::zero()) + USER_ASSET_REWARD_RATE.save(storage, (user, asset_key, reward_denom), &asset_reward_rate)?; + return Ok(Uint128::zero()) + } } @@ -587,7 +603,7 @@ fn _update_astro_rewards( for (asset_info, _) in whitelist { let lp_token = String::from_utf8(asset_info.0)?; - let pending_rewards: Vec = deps + let pending_rewards: Vec = deps .querier .query_wasm_smart( astro_incentives.to_string(), @@ -599,7 +615,7 @@ fn _update_astro_rewards( .unwrap_or_default(); for pr in pending_rewards { - if !pr.astro_rewards.is_zero() { + if !pr.amount.is_zero() { lp_tokens_list.push(lp_token.clone()) } } @@ -634,10 +650,11 @@ fn update_reward_callback( // This is because the reward distribution only affects alliance rewards. LP rewards are directly distributed to LP holders // and not pooled together and shared let reward_asset = AssetInfo::native(config.reward_denom.clone()); + let reward_asset_info_key = AssetInfoKey::from(AssetInfo::Native(config.reward_denom.to_string())); let current_balance = reward_asset.query_balance(&deps.querier, env.contract.address)?; let previous_balance = TEMP_BALANCE.load( deps.storage, - AssetInfoKey::from(AssetInfo::Native(config.reward_denom.to_string())), + reward_asset_info_key.clone(), )?; let rewards_collected = current_balance - previous_balance; @@ -685,10 +702,9 @@ fn update_reward_callback( // Update reward rates for each asset let rate_to_update = total_reward_distributed / Decimal::from_atomics(total_balance, 0)?; if rate_to_update > Decimal::zero() { - ASSET_REWARD_RATE.update(deps.storage, asset_key.clone(), |rate| -> StdResult<_> { - let mut reward_rate = rate.unwrap_or(AssetRewardRate::zero()); - reward_rate.alliance_reward_rate = - reward_rate.alliance_reward_rate + rate_to_update; + ASSET_REWARD_RATE.update(deps.storage, (asset_key.clone(),reward_asset_info_key), |rate| -> StdResult<_> { + let mut reward_rate = rate.unwrap_or_default(); + reward_rate = reward_rate + rate_to_update; Ok(reward_rate) })?; } @@ -856,7 +872,7 @@ fn reply_astro_rewards( event_key, even_value, )); } - + for attr in event.attributes.clone() { if attr.key == "claimed_position" { // TODO : find the claimed_rewards diff --git a/contracts/alliance-lp-hub/src/models.rs b/contracts/alliance-lp-hub/src/models.rs index 843b961..b4d8114 100644 --- a/contracts/alliance-lp-hub/src/models.rs +++ b/contracts/alliance-lp-hub/src/models.rs @@ -2,7 +2,7 @@ use alliance_protocol::alliance_protocol::{ AllianceDelegateMsg, AllianceRedelegateMsg, AllianceUndelegateMsg, AssetDistribution, }; use cosmwasm_schema::{cw_serde, QueryResponses}; -use cosmwasm_std::{Addr, Uint128, Decimal}; +use cosmwasm_std::{Addr, Uint128}; use cw20::Cw20ReceiveMsg; use cw_asset::{Asset, AssetInfo}; use std::collections::{HashMap, HashSet}; @@ -19,7 +19,6 @@ pub struct Config { pub alliance_token_denom: String, pub alliance_token_supply: Uint128, pub reward_denom: String, - pub astro_reward_denom: String } #[cw_serde] @@ -29,7 +28,6 @@ pub struct InstantiateMsg { pub fee_collector_address: String, pub astro_incentives_address: String, pub reward_denom: String, - pub astro_reward_denom: String, } #[cw_serde] @@ -48,7 +46,7 @@ pub enum ExecuteMsg { UpdateRewardsCallback {}, // Privileged functions - ModifyAssets(Vec), + ModifyAssetPairs(Vec), AllianceDelegate(AllianceDelegateMsg), AllianceUndelegate(AllianceUndelegateMsg), @@ -58,15 +56,17 @@ pub enum ExecuteMsg { } #[cw_serde] -pub struct ModifyAsset { +pub struct ModifyAssetPair { pub asset_info: AssetInfo, + pub reward_asset_info: Option, pub delete: bool, } -impl ModifyAsset { - pub fn new(asset_info: AssetInfo, delete: bool) -> Self { - ModifyAsset { +impl ModifyAssetPair { + pub fn new(asset_info: AssetInfo, reward_asset_info: Option, delete: bool) -> Self { + ModifyAssetPair { asset_info, + reward_asset_info, delete, } } @@ -116,64 +116,20 @@ pub struct AllStakedBalancesQuery { #[cw_serde] pub struct PendingRewardsRes { - pub staked_asset: AssetInfo, + pub deposit_asset: AssetInfo, pub reward_asset: AssetInfo, - pub alliance_rewards: Uint128, - pub astro_rewards: Uint128, + pub rewards: Uint128, } #[cw_serde] pub struct AssetQuery { pub address: String, - pub asset: AssetInfo, + pub deposit_asset: AssetInfo, + pub reward_asset: AssetInfo, } #[cw_serde] pub struct StakedBalanceRes { - pub asset: AssetInfo, + pub deposit_asset: AssetInfo, pub balance: Uint128, -} - -#[cw_serde] -pub struct AssetRewardRate { - pub alliance_reward_rate: Decimal, - pub astro_reward_rate: Decimal, -} - -impl AssetRewardRate { - pub fn new(alliance_reward_rate: Decimal, astro_reward_rate: Decimal) -> Self { - AssetRewardRate { - alliance_reward_rate, - astro_reward_rate, - } - } - - pub fn zero() -> Self { - AssetRewardRate { - alliance_reward_rate: Decimal::zero(), - astro_reward_rate: Decimal::zero(), - } - } -} - -#[cw_serde] -pub struct AssetUnclaimedRewards { - pub alliance_reward_rate: Uint128, - pub astro_reward_rate: Uint128, -} - -impl AssetUnclaimedRewards { - pub fn new(alliance_reward_rate: Uint128, astro_reward_rate: Uint128) -> Self { - AssetUnclaimedRewards { - alliance_reward_rate, - astro_reward_rate, - } - } - - pub fn zero() -> Self { - AssetUnclaimedRewards { - alliance_reward_rate: Uint128::zero(), - astro_reward_rate: Uint128::zero(), - } - } } \ No newline at end of file diff --git a/contracts/alliance-lp-hub/src/query.rs b/contracts/alliance-lp-hub/src/query.rs index ab58320..6aa38d8 100644 --- a/contracts/alliance-lp-hub/src/query.rs +++ b/contracts/alliance-lp-hub/src/query.rs @@ -1,18 +1,18 @@ use crate::models::{ - AllPendingRewardsQuery, AllStakedBalancesQuery, AssetQuery, PendingRewardsRes, QueryMsg, - StakedBalanceRes, WhitelistedAssetsResponse, AssetUnclaimedRewards, + AllPendingRewardsQuery, AllStakedBalancesQuery, AssetQuery, + PendingRewardsRes, QueryMsg, StakedBalanceRes, WhitelistedAssetsResponse, }; +use alliance_protocol::alliance_oracle_types::EmissionsDistribution; +use alliance_protocol::signed_decimal::{Sign, SignedDecimal}; #[cfg(not(feature = "library"))] use cosmwasm_std::entry_point; -use cosmwasm_std::{to_json_binary, Binary, Deps, Env, Order, StdResult, Uint128, Decimal}; +use cosmwasm_std::{to_json_binary, Binary, Decimal, Deps, Env, Order, StdResult, Uint128}; use cw_asset::{AssetInfo, AssetInfoKey, AssetInfoUnchecked}; use std::collections::HashMap; -use alliance_protocol::alliance_oracle_types::EmissionsDistribution; -use alliance_protocol::signed_decimal::{Sign, SignedDecimal}; use crate::state::{ - ASSET_REWARD_RATE, BALANCES, CONFIG, TOTAL_BALANCES, - UNCLAIMED_REWARDS, USER_ASSET_REWARD_RATE, VALIDATORS, WHITELIST, + ASSET_REWARD_RATE, BALANCES, CONFIG, TOTAL_BALANCES, UNCLAIMED_REWARDS, USER_ASSET_REWARD_RATE, + VALIDATORS, WHITELIST, }; #[cfg_attr(not(feature = "library"), entry_point)] @@ -64,23 +64,21 @@ fn get_rewards_distribution(deps: Deps) -> StdResult { let reward_distribution: Vec = whitelist .iter() - .map(|(asset_info, distribution) | - EmissionsDistribution { - denom: asset_info.check( deps.api, None).unwrap().to_string(), - distribution: SignedDecimal::from_decimal(*distribution, Sign::Positive), - } - ) + .map(|(asset_info, distribution)| EmissionsDistribution { + denom: asset_info.check(deps.api, None).unwrap().to_string(), + distribution: SignedDecimal::from_decimal(*distribution, Sign::Positive), + }) .collect(); to_json_binary(&reward_distribution) } fn get_staked_balance(deps: Deps, asset_query: AssetQuery) -> StdResult { let addr = deps.api.addr_validate(&asset_query.address)?; - let key = (addr, asset_query.asset.clone().into()); + let key = (addr, asset_query.deposit_asset.clone().into()); let balance = BALANCES.load(deps.storage, key)?; to_json_binary(&StakedBalanceRes { - asset: asset_query.asset, + deposit_asset: asset_query.deposit_asset, balance, }) } @@ -88,22 +86,24 @@ fn get_staked_balance(deps: Deps, asset_query: AssetQuery) -> StdResult fn get_pending_rewards(deps: Deps, asset_query: AssetQuery) -> StdResult { let config = CONFIG.load(deps.storage)?; let addr = deps.api.addr_validate(&asset_query.address)?; - let key = (addr, AssetInfoKey::from(asset_query.asset.clone())); - let user_reward_rate = USER_ASSET_REWARD_RATE.load(deps.storage, key.clone())?; - let asset_reward_rate = - ASSET_REWARD_RATE.load(deps.storage, AssetInfoKey::from(asset_query.asset.clone()))?; - let user_balance = BALANCES.load(deps.storage, key.clone())?; + let reward_asset = AssetInfoKey::from(asset_query.reward_asset.clone()); + let deposit_asset = AssetInfoKey::from(asset_query.deposit_asset.clone()); + + let key = (addr, deposit_asset, reward_asset); + let user_reward_rate = USER_ASSET_REWARD_RATE.load(deps.storage, key)?; + + let asset_reward_rate = ASSET_REWARD_RATE.load(deps.storage, (deposit_asset, reward_asset))?; + let user_balance = BALANCES.load(deps.storage, (addr, deposit_asset).clone())?; let unclaimed_rewards = UNCLAIMED_REWARDS - .load(deps.storage, key) - .unwrap_or(AssetUnclaimedRewards::zero()); - let alliance_pending_rewards = (asset_reward_rate.alliance_reward_rate - user_reward_rate.alliance_reward_rate) * user_balance; - let astro_pending_rewards = (asset_reward_rate.astro_reward_rate - user_reward_rate.astro_reward_rate) * user_balance; + .load(deps.storage, (addr, reward_asset)) + .unwrap_or_default(); + + let alliance_pending_rewards = (asset_reward_rate - user_reward_rate) * user_balance; to_json_binary(&PendingRewardsRes { - alliance_rewards: unclaimed_rewards.alliance_reward_rate + alliance_pending_rewards, - astro_rewards: unclaimed_rewards.astro_reward_rate + astro_pending_rewards, - staked_asset: asset_query.asset, - reward_asset: AssetInfo::Native(config.reward_denom), + deposit_asset: asset_query.deposit_asset, + reward_asset: asset_query.reward_asset, + rewards: alliance_pending_rewards + unclaimed_rewards, }) } @@ -124,7 +124,7 @@ fn get_all_staked_balances(deps: Deps, asset_query: AllStakedBalancesQuery) -> S // Append the request res.push(StakedBalanceRes { - asset: checked_asset_info, + deposit_asset: checked_asset_info, balance, }) } @@ -136,30 +136,25 @@ fn get_all_pending_rewards(deps: Deps, query: AllPendingRewardsQuery) -> StdResu let config = CONFIG.load(deps.storage)?; let addr = deps.api.addr_validate(&query.address)?; let all_pending_rewards: StdResult> = USER_ASSET_REWARD_RATE - .prefix(addr.clone()) + .sub_prefix(addr.clone()) .range(deps.storage, None, None, Order::Ascending) .map(|item| { - let (asset, user_reward_rate) = item?; - let asset = asset.check(deps.api, None)?; + let (assets, user_reward_rate) = item?; + + let deposit_asset = AssetInfoKey::from(assets.0.check(deps.api, None)?); + let reward_asset = AssetInfoKey::from(assets.1.check(deps.api, None)?); + let asset_reward_rate = - ASSET_REWARD_RATE.load(deps.storage, AssetInfoKey::from(asset.clone()))?; - let user_balance = BALANCES.load( - deps.storage, - (addr.clone(), AssetInfoKey::from(asset.clone())), - )?; + ASSET_REWARD_RATE.load(deps.storage, (deposit_asset, reward_asset))?; + let user_balance = BALANCES.load(deps.storage, (addr.clone(), deposit_asset))?; let unclaimed_rewards = UNCLAIMED_REWARDS - .load( - deps.storage, - (addr.clone(), AssetInfoKey::from(asset.clone())), - ) - .unwrap_or(AssetUnclaimedRewards::zero()); - let alliance_pending_rewards = (asset_reward_rate.alliance_reward_rate - user_reward_rate.alliance_reward_rate) * user_balance; - let astro_pending_rewards = (asset_reward_rate.astro_reward_rate - user_reward_rate.astro_reward_rate) * user_balance; + .load(deps.storage, (addr.clone(), deposit_asset)) + .unwrap_or_default(); + let alliance_pending_rewards = (asset_reward_rate - user_reward_rate) * user_balance; Ok(PendingRewardsRes { - alliance_rewards: alliance_pending_rewards + unclaimed_rewards.alliance_reward_rate, - astro_rewards: astro_pending_rewards + unclaimed_rewards.astro_reward_rate, - staked_asset: asset, + rewards: alliance_pending_rewards + unclaimed_rewards, + deposit_asset: assets.0.check(deps.api, None)?, reward_asset: AssetInfo::Native(config.reward_denom.to_string()), }) }) @@ -174,7 +169,7 @@ fn get_total_staked_balances(deps: Deps) -> StdResult { .map(|total_balance| -> StdResult { let (asset, balance) = total_balance?; Ok(StakedBalanceRes { - asset: asset.check(deps.api, None)?, + deposit_asset: asset.check(deps.api, None)?, balance, }) }) diff --git a/contracts/alliance-lp-hub/src/state.rs b/contracts/alliance-lp-hub/src/state.rs index 25a5fb4..e573e35 100644 --- a/contracts/alliance-lp-hub/src/state.rs +++ b/contracts/alliance-lp-hub/src/state.rs @@ -1,4 +1,4 @@ -use crate::models::{Config, AssetRewardRate, AssetUnclaimedRewards}; +use crate::models::Config; use cosmwasm_std::{Addr, Decimal, Uint128}; use cw_asset::AssetInfoKey; use cw_storage_plus::{Item, Map}; @@ -12,9 +12,24 @@ pub const TOTAL_BALANCES: Map = Map::new("total_balances" pub const VALIDATORS: Item> = Item::new("validators"); -pub const ASSET_REWARD_RATE: Map = Map::new("asset_reward_rate"); -pub const USER_ASSET_REWARD_RATE: Map<(Addr, AssetInfoKey), AssetRewardRate> = +// The following map is used to store the rewards +// with the following structure: +// - AssetInfoKey: is the asset that is being deposited, +// - AssetInfoKey: is the asset that is being rewarded, +// - Decimal: is the reward rate, +pub const ASSET_REWARD_RATE: Map<(AssetInfoKey, AssetInfoKey), Decimal> = + Map::new("asset_reward_rate"); + +// The following map is used to store the user rewards +// with the following structure: +// - Addr: is the address of the user, +// - AssetInfoKey: is the asset that is being deposited, +// - AssetInfoKey: is the asset that is being rewarded, +// - Decimal: is the reward rate, +pub const USER_ASSET_REWARD_RATE: Map<(Addr, AssetInfoKey, AssetInfoKey), Decimal> = Map::new("user_asset_reward_rate"); -pub const UNCLAIMED_REWARDS: Map<(Addr, AssetInfoKey), AssetUnclaimedRewards> = Map::new("unclaimed_rewards"); + +// The following map is used to keep track of the unclaimed rewards +pub const UNCLAIMED_REWARDS: Map<(Addr, AssetInfoKey), Uint128> = Map::new("unclaimed_rewards"); pub const TEMP_BALANCE: Map = Map::new("temp_balance"); diff --git a/contracts/alliance-lp-hub/src/tests/helpers.rs b/contracts/alliance-lp-hub/src/tests/helpers.rs index 4d28ab4..d9da30d 100644 --- a/contracts/alliance-lp-hub/src/tests/helpers.rs +++ b/contracts/alliance-lp-hub/src/tests/helpers.rs @@ -1,7 +1,7 @@ use crate::contract::{execute, instantiate}; use crate::models::{ AllPendingRewardsQuery, AssetQuery, Config, ExecuteMsg, InstantiateMsg, PendingRewardsRes, - QueryMsg, StakedBalanceRes, ModifyAsset, + QueryMsg, StakedBalanceRes, ModifyAssetPair, }; use crate::query::query; use crate::state::CONFIG; @@ -27,7 +27,6 @@ pub fn setup_contract(deps: DepsMut) -> Response { astro_incentives_address : "astro_incentives".to_string(), controller: "controller".to_string(), reward_denom: "uluna".to_string(), - astro_reward_denom: "uastro".to_string(), }; instantiate(deps, env, info, init_msg).unwrap() } @@ -44,11 +43,11 @@ pub fn set_alliance_asset(deps: DepsMut) { .unwrap(); } -pub fn modify_asset(deps: DepsMut, assets: Vec) -> Response { +pub fn modify_asset(deps: DepsMut, assets: Vec) -> Response { let info = mock_info("gov", &[]); let env = mock_env(); - let msg = ExecuteMsg::ModifyAssets(assets); + let msg = ExecuteMsg::ModifyAssetPairs(assets); execute(deps, env, info, msg).unwrap() } diff --git a/contracts/alliance-lp-hub/src/tests/instantiate.rs b/contracts/alliance-lp-hub/src/tests/instantiate.rs index 078b858..fd69241 100644 --- a/contracts/alliance-lp-hub/src/tests/instantiate.rs +++ b/contracts/alliance-lp-hub/src/tests/instantiate.rs @@ -40,7 +40,6 @@ fn test_setup_contract() { fee_collector: Addr::unchecked("collector_address"), astro_incentives: Addr::unchecked("astro_incentives"), reward_denom: "uluna".to_string(), - astro_reward_denom: "uastro".to_string(), alliance_token_denom: "".to_string(), alliance_token_supply: Uint128::new(0), } @@ -112,7 +111,6 @@ fn test_reply_create_token() { controller: Addr::unchecked("controller"), fee_collector: Addr::unchecked("collector_address"), astro_incentives: Addr::unchecked("astro_incentives"), - astro_reward_denom: "uastro".to_string(), reward_denom: "uluna".to_string(), alliance_token_denom: "factory/cosmos2contract/ualliancelp".to_string(), alliance_token_supply: Uint128::new(1000000000000), diff --git a/packages/alliance-protocol/src/error.rs b/packages/alliance-protocol/src/error.rs index c188eab..21aa588 100644 --- a/packages/alliance-protocol/src/error.rs +++ b/packages/alliance-protocol/src/error.rs @@ -47,4 +47,7 @@ pub enum ContractError { #[error("Invalid contract callback with key: {0} and type: {1}")] InvalidContractCallback(String, String), + + #[error("Missing reward asset info for asset {0}")] + MissingRewardAsset(String), }