add support for cw20 alliances and ginkou usdc proxy

Author: 0xphilipp

Cargo.lock

@@ -1,6 +1,7 @@
 [workspace]
 members = [
     "contracts/amp-governance/*",
+    "contracts/proxies/*",
     "contracts/dao-lst",
     "contracts/alliance-hub-lst",
     "contracts/lst-factory",

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "eris-alliance-hub-lst-terra"
+name = "eris-alliance-hub-lst-whitewhale"
 version = "1.2.0"
 authors = ["devs <devs@erisprotocol.com>"]
 edition = "2018"
@@ -17,7 +17,7 @@ X-injective-X = []
 X-osmosis-X = []
 X-sei-X = []
 X-terra-X = []
-default = ["X-terra-X"]
+default = ["X-whitewhale-X"]
 
 [dependencies]
 cosmwasm-std = { version = "1.1.3", features = ["staking"] }

contracts/alliance-hub-lst/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "eris-dao-lst-terra"
+name = "eris-dao-lst-whitewhale"
 version = "1.0.1"
 authors = ["devs <devs@erisprotocol.com>"]
 edition = "2018"
@@ -17,7 +17,7 @@ X-injective-X = []
 X-osmosis-X = []
 X-sei-X = []
 X-terra-X = []
-default = ["X-terra-X"]
+default = ["X-whitewhale-X"]
 
 [dependencies]
 cosmwasm-std = { version = "1.1.3", features = ["staking"] }

contracts/dao-lst/Cargo.toml

@@ -0,0 +1,4 @@
+[alias]
+wasm = "build --release --lib --target wasm32-unknown-unknown"
+unit-test = "test --lib"
+schema = "run --example schema_ginkou_usdc_proxy"

contracts/proxies/ginkou_usdc_proxy/.cargo/config

@@ -0,0 +1,41 @@
+[package]
+name = "eris-ginkou-usdc-proxy"
+version = "1.0.0"
+authors = ["devs <devs@erisprotocol.com>"]
+edition = "2021"
+
+exclude = [
+  # Those files are rust-optimizer artifacts. You might want to commit them for convenience but they should not be part of the source code publication.
+  "contract.wasm",
+  "hash.txt",
+]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+
+[features]
+# for more explicit tests, cargo test --features=backtraces
+backtraces = ["cosmwasm-std/backtraces"]
+# use library feature to disable all instantiate/execute/query exports
+library = []
+
+
+[dependencies]
+cosmwasm-std = "1.1.3"
+cosmwasm-schema = "1.1.3"
+cw2 = "0.13.2"
+cw20 = "1.1.0"
+cw-storage-plus = "0.15.1"
+cw-ownable = "0.5.1"
+schemars = "0.8.10"
+serde = { version = "1.0.145", default-features = false, features = ["derive"] }
+thiserror = { version = "1.0.31" }
+eris = { git = "https://github.com/erisprotocol/contracts-tokenfactory.git", default-features = false, rev = "f38bd370400dd9873e6872538ee10e3602b19684" }
+astroport = { git = "https://github.com/astroport-fi/astroport-core.git", default-features = false, rev = "3b44a4044b823a145730f66ffaf7ae4205b2cd35" }
+
+
+[dev-dependencies]
+cw-multi-test = "0.15.1"

contracts/proxies/ginkou_usdc_proxy/Cargo.toml

@@ -0,0 +1,4 @@
+# Ginkou USDC Swap Proxy
+
+This proxy is for using the swap interface to swap between mUSDC and USDC on Migaloo through Ginkou.
+It is used for auto compounding WHALE -> USDC -> mUSDC on Migaloo.

contracts/proxies/ginkou_usdc_proxy/README.md

@@ -0,0 +1,11 @@
+use cosmwasm_schema::write_api;
+use eris_ginkou_usdc_proxy::msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
+
+fn main() {
+    write_api! {
+        instantiate: InstantiateMsg,
+        query: QueryMsg,
+        execute: ExecuteMsg,
+        migrate: MigrateMsg
+    }
+}

contracts/proxies/ginkou_usdc_proxy/examples/schema_ginkou_usdc_proxy.rs

@@ -0,0 +1,171 @@
+const CONTRACT_NAME: &str = "eris-ginkou-usdc-proxy";
+const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+use crate::{
+    error::{ContractError, ContractResult, CustomResult},
+    ginkou::Ginkou,
+    msg::{CallbackMsg, Config, ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg, ReceiveMsg},
+    state::CONFIG,
+};
+use astroport::asset::{native_asset_info, token_asset_info, AssetInfoExt, PairInfo};
+
+#[cfg(not(feature = "library"))]
+use cosmwasm_std::entry_point;
+use cosmwasm_std::{
+    from_binary, to_binary, Binary, CosmosMsg, Deps, DepsMut, Env, MessageInfo, Response,
+    StdResult, Storage, WasmMsg,
+};
+use cw2::set_contract_version;
+use cw20::Cw20ReceiveMsg;
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn instantiate(
+    deps: DepsMut,
+    _env: Env,
+    _info: MessageInfo,
+    msg: InstantiateMsg,
+) -> ContractResult {
+    set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
+
+    CONFIG.save(
+        deps.storage,
+        &Config {
+            ginkou: Ginkou {
+                contract: deps.api.addr_validate(&msg.ginkou)?,
+                usdc_denom: msg.usdc_denom,
+                musdc_addr: deps.api.addr_validate(&msg.musdc_addr)?,
+            },
+        },
+    )?;
+    Ok(Response::default())
+}
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> ContractResult {
+    match msg {
+        ExecuteMsg::Receive(cw20_msg) => receive(deps, env, info, cw20_msg),
+        ExecuteMsg::Swap {
+            offer_asset,
+            to,
+            ..
+        } => {
+            offer_asset.assert_sent_native_token_balance(&info)?;
+            let config = CONFIG.load(deps.storage)?;
+
+            if offer_asset.info != native_asset_info(config.ginkou.usdc_denom.clone()) {
+                return Err(ContractError::ExpectingUsdcToken(offer_asset.info.to_string()));
+            }
+
+            Ok(Response::new()
+                .add_attribute("action", "virtual-swap")
+                .add_message(config.ginkou.deposit_usdc(offer_asset.amount.u128())?)
+                .add_message(send_to(
+                    deps,
+                    &env,
+                    to.unwrap_or(info.sender.to_string()),
+                    token_asset_info(config.ginkou.musdc_addr),
+                )?))
+        },
+        ExecuteMsg::Callback(callback_msg) => callback(deps, env, info, callback_msg),
+    }
+}
+
+fn receive(deps: DepsMut, env: Env, info: MessageInfo, cw20_msg: Cw20ReceiveMsg) -> ContractResult {
+    match from_binary(&cw20_msg.msg)? {
+        ReceiveMsg::Swap {
+            to,
+            ..
+        } => {
+            let config = CONFIG.load(deps.storage)?;
+
+            if info.sender != config.ginkou.musdc_addr {
+                return Err(ContractError::ExpectingMusdcToken(info.sender.into()));
+            }
+
+            Ok(Response::new()
+                .add_attribute("action", "virtual-swap_receive")
+                .add_message(config.ginkou.withdraw_msg(cw20_msg.amount)?)
+                .add_message(send_to(
+                    deps,
+                    &env,
+                    to.unwrap_or(info.sender.to_string()),
+                    native_asset_info(config.ginkou.usdc_denom),
+                )?))
+        },
+    }
+}
+
+fn send_to(
+    deps: DepsMut,
+    env: &Env,
+    to: String,
+    asset_info: astroport::asset::AssetInfo,
+) -> CustomResult<CosmosMsg> {
+    let receiver = deps.api.addr_validate(&to)?;
+    Ok(CosmosMsg::Wasm(WasmMsg::Execute {
+        contract_addr: env.contract.address.to_string(),
+        msg: to_binary(&ExecuteMsg::Callback(CallbackMsg::SendTo {
+            to: receiver,
+            asset_info,
+        }))?,
+        funds: vec![],
+    }))
+}
+
+fn callback(
+    deps: DepsMut,
+    env: Env,
+    info: MessageInfo,
+    callback_msg: CallbackMsg,
+) -> ContractResult {
+    if env.contract.address != info.sender {
+        return Err(ContractError::CallbackOnlyCalledByContract {});
+    }
+
+    match callback_msg {
+        CallbackMsg::SendTo {
+            to: receiver,
+            asset_info: token,
+        } => {
+            let amount = token.query_pool(&deps.querier, env.contract.address)?;
+            let send = token.with_balance(amount).into_msg(receiver)?;
+
+            Ok(Response::new().add_attribute("action", "callback-send_to").add_message(send))
+        },
+    }
+}
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
+    match msg {
+        QueryMsg::Config {} => to_binary(&get_config(deps.storage)?),
+        QueryMsg::Pair {} => to_binary(&query_pair(deps, env)?),
+    }
+}
+
+pub fn query_pair(deps: Deps, env: Env) -> StdResult<PairInfo> {
+    let config = CONFIG.load(deps.storage)?;
+
+    Ok(PairInfo {
+        asset_infos: vec![
+            native_asset_info(config.ginkou.usdc_denom),
+            token_asset_info(config.ginkou.musdc_addr),
+        ],
+        contract_addr: env.contract.address.clone(),
+        liquidity_token: env.contract.address,
+        pair_type: astroport::factory::PairType::Custom("virtual".to_string()),
+    })
+}
+
+fn get_config(store: &dyn Storage) -> StdResult<Config> {
+    CONFIG.load(store)
+}
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn migrate(deps: DepsMut, _env: Env, _msg: MigrateMsg) -> ContractResult {
+    set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
+
+    Ok(Response::new()
+        .add_attribute("new_contract_name", CONTRACT_NAME)
+        .add_attribute("new_contract_version", CONTRACT_VERSION))
+}

contracts/proxies/ginkou_usdc_proxy/src/contract.rs

@@ -0,0 +1,33 @@
+use std::num::TryFromIntError;
+
+use cosmwasm_std::{Response, StdError};
+use cw_ownable::OwnershipError;
+use thiserror::Error;
+
+pub type ContractResult = Result<Response, ContractError>;
+pub type CustomResult<T> = Result<T, ContractError>;
+
+/// This enum describes hub contract errors
+#[derive(Error, Debug, PartialEq)]
+pub enum ContractError {
+    #[error("{0}")]
+    Std(#[from] StdError),
+
+    #[error("{0}")]
+    TryFromInt(#[from] TryFromIntError),
+
+    #[error("{0}")]
+    Ownership(#[from] OwnershipError),
+
+    #[error("not supported")]
+    NotSupported,
+
+    #[error("callback only callable by contract")]
+    CallbackOnlyCalledByContract,
+
+    #[error("Expecting USDC coin, received {0}")]
+    ExpectingUsdcToken(String),
+
+    #[error("Expecting mUSDC token, received {0}")]
+    ExpectingMusdcToken(String),
+}