diff --git a/Cargo.lock b/Cargo.lock index ba11fd58..a81d56a4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -566,6 +566,19 @@ dependencies = [ "thiserror", ] +[[package]] +name = "oraiswap-converter" +version = "0.0.0" +dependencies = [ + "cosmwasm-schema", + "cosmwasm-std", + "cosmwasm-storage", + "cw20", + "oraiswap", + "schemars", + "serde", +] + [[package]] name = "oraiswap-factory" version = "0.0.0" @@ -620,6 +633,19 @@ dependencies = [ "thiserror", ] +[[package]] +name = "oraiswap-rewarder" +version = "0.0.0" +dependencies = [ + "cosmwasm-schema", + "cosmwasm-std", + "cosmwasm-storage", + "cw20", + "oraiswap", + "schemars", + "serde", +] + [[package]] name = "oraiswap-router" version = "0.0.0" @@ -640,6 +666,24 @@ dependencies = [ "serde", ] +[[package]] +name = "oraiswap-staking" +version = "2.1.1" +dependencies = [ + "cosmwasm-schema", + "cosmwasm-std", + "cosmwasm-storage", + "cw-multi-test", + "cw20", + "oraiswap", + "oraiswap-factory", + "oraiswap-oracle", + "oraiswap-pair", + "oraiswap-token", + "schemars", + "serde", +] + [[package]] name = "oraiswap-token" version = "0.0.0" diff --git a/Cargo.toml b/Cargo.toml index b5ae1883..aacc5f50 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -members = ["packages/*", "contracts/oraiswap_token","contracts/oraiswap_oracle","contracts/oraiswap_pair","contracts/oraiswap_factory","contracts/oraiswap_router"] +members = ["packages/*", "contracts/*"] [profile.release] opt-level = 3 diff --git a/contracts/oraiswap_converter/src/contract.rs b/contracts/oraiswap_converter/src/contract.rs index ee315941..287b5ee2 100644 --- a/contracts/oraiswap_converter/src/contract.rs +++ b/contracts/oraiswap_converter/src/contract.rs @@ -58,7 +58,7 @@ pub fn update_config(deps: DepsMut, info: MessageInfo, owner: Addr) -> StdResult store_config(deps.storage, &config)?; - Ok(Response::new().add_attribute(("action", "update_config"))) + Ok(Response::new().add_attribute("action", "update_config")) } fn div_ratio_decimal(nominator: Uint128, denominator: Decimal) -> Uint128 { @@ -93,8 +93,8 @@ pub fn receive_cw20( Ok(Response::new().add_message(message).add_attributes(vec![ ("action", "convert_token"), - ("from_amount", cw20_msg.amount), - ("to_amount", amount), + ("from_amount", &cw20_msg.amount.to_string()), + ("to_amount", &amount.to_string()), ])) } Ok(Cw20HookMsg::ConvertReverse { from }) => { @@ -120,8 +120,8 @@ pub fn receive_cw20( Ok(Response::new().add_message(message).add_attributes(vec![ ("action", "convert_token_reverse"), - ("from_amount", cw20_msg.amount), - ("to_amount", amount), + ("from_amount", &cw20_msg.amount.to_string()), + ("to_amount", &amount.to_string()), ])) } else { return Err(StdError::generic_err("invalid cw20 hook message")); @@ -154,7 +154,7 @@ pub fn update_pair( store_token_ratio(deps.storage, &asset_key, &token_ratio)?; - Ok(Response::new().add_attribute(("action", "update_pair"))) + Ok(Response::new().add_attribute("action", "update_pair")) } pub fn unregister_pair(deps: DepsMut, info: MessageInfo, from: TokenInfo) -> StdResult { @@ -167,25 +167,23 @@ pub fn unregister_pair(deps: DepsMut, info: MessageInfo, from: TokenInfo) -> Std token_ratio_remove(deps.storage, &asset_key); - Ok(Response::new().add_attribute(("action", "unregister_convert_info"))) + Ok(Response::new().add_attribute("action", "unregister_convert_info")) } pub fn convert(deps: DepsMut, _env: Env, info: MessageInfo) -> StdResult { let mut messages: Vec = vec![]; let mut attributes: Vec = vec![]; - attributes.push(("action", "convert_token")); + attributes.push(("action", "convert_token").into()); for native_coin in info.funds { let asset_key = native_coin.denom.as_bytes(); let amount = native_coin.amount; - attributes.extend(vec![ - ("denom", native_coin.denom.clone()), - ("from_amount", amount.clone()), - ]); + attributes.push(("denom", native_coin.denom.clone()).into()); + attributes.push(("from_amount", amount.to_string()).into()); let token_ratio = read_token_ratio(deps.storage, asset_key)?; let to_amount = amount * token_ratio.ratio; - attributes.push(("to_amount", to_amount)); + attributes.push(("to_amount", to_amount).into()); let message = Asset { info: token_ratio.info, @@ -226,9 +224,9 @@ pub fn convert_reverse( Ok(Response::new().add_message(message).add_attributes(vec![ ("action", "convert_token_reverse"), - ("denom", native_coin.denom.clone()), - ("from_amount", native_coin.amount.clone()), - ("to_amount", amount), + ("denom", native_coin.denom.as_str()), + ("from_amount", &native_coin.amount.to_string()), + ("to_amount", &amount.to_string()), ])) } else { return Err(StdError::generic_err("invalid cw20 hook message")); @@ -270,7 +268,7 @@ pub fn withdraw_tokens( return Err(StdError::generic_err("unauthorized")); } let mut messages: Vec = vec![]; - let mut attributes: Vec = vec![("action", "withdraw_tokens")]; + let mut attributes: Vec = vec![("action", "withdraw_tokens").into()]; for asset in asset_infos { let balance = asset.query_pool(&deps.querier, env.contract.address.clone())?; @@ -280,7 +278,7 @@ pub fn withdraw_tokens( } .into_msg(None, &deps.querier, owner.clone())?; messages.push(message); - attributes.push(("amount", balance.to_string())) + attributes.push(("amount", balance.to_string()).into()) } Ok(Response::new() diff --git a/contracts/oraiswap_factory/README.md b/contracts/oraiswap_factory/README.md index 187ae196..e11879c1 100644 --- a/contracts/oraiswap_factory/README.md +++ b/contracts/oraiswap_factory/README.md @@ -7,11 +7,7 @@ The factory contract can perform creation of oraiswap pair contract and also be ```json { "paid_code_id": "123", - "token_code_id": "123", - "init_hook": { - "msg": "123", - "contract_addr": "orai..." - } + "token_code_id": "123" } ``` @@ -109,7 +105,6 @@ Register verified pair contract and token contract for pair contract creation. T /// Pair contract code ID, which is used to pub pair_code_id: u64, pub token_code_id: u64, - pub init_hook: Option, } ``` diff --git a/contracts/oraiswap_factory/src/contract.rs b/contracts/oraiswap_factory/src/contract.rs index b531b36f..a213d0f2 100644 --- a/contracts/oraiswap_factory/src/contract.rs +++ b/contracts/oraiswap_factory/src/contract.rs @@ -55,13 +55,13 @@ pub fn execute( owner, token_code_id, pair_code_id, - } => handle_update_config(deps, env, info, owner, token_code_id, pair_code_id), - ExecuteMsg::CreatePair { asset_infos } => handle_create_pair(deps, env, info, asset_infos), + } => execute_update_config(deps, env, info, owner, token_code_id, pair_code_id), + ExecuteMsg::CreatePair { asset_infos } => execute_create_pair(deps, env, info, asset_infos), } } // Only owner can execute it -pub fn handle_update_config( +pub fn execute_update_config( deps: DepsMut, _env: Env, info: MessageInfo, @@ -94,7 +94,7 @@ pub fn handle_update_config( } // Anyone can execute it to create swap pair -pub fn handle_create_pair( +pub fn execute_create_pair( deps: DepsMut, env: Env, _info: MessageInfo, diff --git a/contracts/oraiswap_oracle/Cargo.toml b/contracts/oraiswap_oracle/Cargo.toml index 6ac460d8..a971875f 100644 --- a/contracts/oraiswap_oracle/Cargo.toml +++ b/contracts/oraiswap_oracle/Cargo.toml @@ -17,7 +17,7 @@ crate-type = ["cdylib", "rlib"] [features] # for more explicit tests, cargo test --features=backtraces backtraces = ["cosmwasm-std/backtraces"] -# use library feature to disable all init/handle/query exports +# use library feature to disable all init/execute/query exports library = [] [dependencies] diff --git a/contracts/oraiswap_oracle/src/contract.rs b/contracts/oraiswap_oracle/src/contract.rs index 0175bbee..6adb11db 100644 --- a/contracts/oraiswap_oracle/src/contract.rs +++ b/contracts/oraiswap_oracle/src/contract.rs @@ -67,15 +67,15 @@ pub fn execute( ExecuteMsg::UpdateExchangeRate { denom, exchange_rate, - } => handle_update_exchange_rate(deps, info, denom, exchange_rate), - ExecuteMsg::DeleteExchangeRate { denom } => handle_delete_exchange_rate(deps, info, denom), - ExecuteMsg::UpdateTaxCap { cap, denom } => handle_update_tax_cap(deps, info, denom, cap), - ExecuteMsg::UpdateTaxRate { rate } => handle_update_tax_rate(deps, info, rate), - ExecuteMsg::UpdateAdmin { admin } => handle_update_admin(deps, info, admin), + } => execute_update_exchange_rate(deps, info, denom, exchange_rate), + ExecuteMsg::DeleteExchangeRate { denom } => execute_delete_exchange_rate(deps, info, denom), + ExecuteMsg::UpdateTaxCap { cap, denom } => execute_update_tax_cap(deps, info, denom, cap), + ExecuteMsg::UpdateTaxRate { rate } => execute_update_tax_rate(deps, info, rate), + ExecuteMsg::UpdateAdmin { admin } => execute_update_admin(deps, info, admin), } } -pub fn handle_update_tax_cap( +pub fn execute_update_tax_cap( deps: DepsMut, info: MessageInfo, denom: String, @@ -96,7 +96,7 @@ pub fn handle_update_tax_cap( Ok(Response::default()) } -pub fn handle_update_tax_rate( +pub fn execute_update_tax_rate( deps: DepsMut, info: MessageInfo, rate: Decimal, @@ -117,7 +117,7 @@ pub fn handle_update_tax_rate( Ok(Response::default()) } -pub fn handle_update_admin( +pub fn execute_update_admin( deps: DepsMut, info: MessageInfo, admin: Addr, @@ -138,7 +138,7 @@ pub fn handle_update_admin( Ok(Response::default()) } -pub fn handle_update_exchange_rate( +pub fn execute_update_exchange_rate( deps: DepsMut, info: MessageInfo, denom: String, @@ -157,7 +157,7 @@ pub fn handle_update_exchange_rate( Ok(Response::default()) } -pub fn handle_delete_exchange_rate( +pub fn execute_delete_exchange_rate( deps: DepsMut, info: MessageInfo, denom: String, diff --git a/contracts/oraiswap_pair/README.md b/contracts/oraiswap_pair/README.md index 637aac31..230fddf1 100644 --- a/contracts/oraiswap_pair/README.md +++ b/contracts/oraiswap_pair/README.md @@ -6,7 +6,7 @@ This is mainly used from oraiswap factory contract to create new oraiswap pair. It initialize all swap created parameters which can be updated later with owner key. -It creates liquidity token contract as init response, and execute init hook to register created liquidity token contract to self. +It creates liquidity token contract as init response, and execute reply on success to register created liquidity token contract to self. ```rust { @@ -16,8 +16,7 @@ It creates liquidity token contract as init response, and execute init hook to r pub token_code_id: u64, /// Oracle contract address for global parameters pub oracle_addr: Addr, - /// Hook for post initalization, such as update the instance contract address to proxy contract map - pub init_hook: Option, + } ``` diff --git a/contracts/oraiswap_rewarder/src/contract.rs b/contracts/oraiswap_rewarder/src/contract.rs index 067a0666..3cde4e0f 100644 --- a/contracts/oraiswap_rewarder/src/contract.rs +++ b/contracts/oraiswap_rewarder/src/contract.rs @@ -83,11 +83,11 @@ pub fn update_config( store_config(deps.storage, &config)?; - Ok(Response::new().add_attribute(("action", "update_config"))) + Ok(Response::new().add_attribute("action", "update_config")) } /// Distribute -/// Anyone can handle distribute operation to distribute +/// Anyone can execute distribute operation to distribute pub fn distribute(deps: DepsMut, env: Env, asset_infos: Vec) -> StdResult { let config: Config = read_config(deps.storage)?; let staking_contract = deps.api.addr_humanize(&config.staking_contract)?; @@ -128,7 +128,7 @@ pub fn distribute(deps: DepsMut, env: Env, asset_infos: Vec) -> StdRe msg: to_binary(&StakingExecuteMsg::DepositReward { rewards })?, funds: vec![], })) - .add_attribute(("action", "distribute"))) + .add_attribute("action", "distribute")) } #[cfg_attr(not(feature = "library"), entry_point)] diff --git a/contracts/oraiswap_router/README.md b/contracts/oraiswap_router/README.md index ac059652..2c759b57 100644 --- a/contracts/oraiswap_router/README.md +++ b/contracts/oraiswap_router/README.md @@ -24,7 +24,7 @@ If the token is ow20 Orai, we can convert it to native first ``` { - "handle_swap_operations":{ + "execute_swap_operations":{ "operations":[ { "orai_swap":{ diff --git a/contracts/oraiswap_router/src/contract.rs b/contracts/oraiswap_router/src/contract.rs index 9a1288d3..c438eec8 100644 --- a/contracts/oraiswap_router/src/contract.rs +++ b/contracts/oraiswap_router/src/contract.rs @@ -7,7 +7,7 @@ use cosmwasm_std::{ }; use oraiswap::error::ContractError; -use crate::operations::{handle_swap_operation, handle_swap_operations}; +use crate::operations::{execute_swap_operation, execute_swap_operations}; use crate::state::{Config, CONFIG}; use cw20::Cw20ReceiveMsg; @@ -50,9 +50,9 @@ pub fn execute( operations, minimum_receive, to, - } => handle_swap_operations(deps, env, info.sender, operations, minimum_receive, to), + } => execute_swap_operations(deps, env, info.sender, operations, minimum_receive, to), ExecuteMsg::ExecuteSwapOperation { operation, to } => { - handle_swap_operation(deps, env, info, operation, to) + execute_swap_operation(deps, env, info, operation, to) } ExecuteMsg::AssertMinimumReceive { @@ -85,11 +85,8 @@ pub fn receive_cw20( minimum_receive, to, } => { - let receiver = match to { - Some(addr) => deps.api.addr_validate(addr.as_str()).ok(), - None => None, - }; - handle_swap_operations(deps, env, sender, operations, minimum_receive, receiver) + let receiver = to.map_or(None, |addr| deps.api.addr_validate(addr.as_str()).ok()); + execute_swap_operations(deps, env, sender, operations, minimum_receive, receiver) } } } diff --git a/contracts/oraiswap_router/src/operations.rs b/contracts/oraiswap_router/src/operations.rs index 4712b0b5..0dc8463d 100644 --- a/contracts/oraiswap_router/src/operations.rs +++ b/contracts/oraiswap_router/src/operations.rs @@ -17,7 +17,7 @@ use oraiswap::router::{ExecuteMsg, SwapOperation}; /// Execute swap operation /// swap all offer asset to ask asset -pub fn handle_swap_operation( +pub fn execute_swap_operation( deps: DepsMut, env: Env, info: MessageInfo, @@ -74,7 +74,7 @@ pub fn handle_swap_operation( Ok(Response::new().add_messages(messages)) } -pub fn handle_swap_operations( +pub fn execute_swap_operations( deps: DepsMut, env: Env, sender: Addr, diff --git a/contracts/oraiswap_router/src/testing.rs b/contracts/oraiswap_router/src/testing.rs index 342e30be..e1a120fb 100644 --- a/contracts/oraiswap_router/src/testing.rs +++ b/contracts/oraiswap_router/src/testing.rs @@ -125,7 +125,7 @@ fn simulate_swap_operations_test() { } #[test] -fn handle_swap_operations() { +fn execute_swap_operations() { let mut app = MockApp::new(&[( &"addr0000".to_string(), &[ diff --git a/contracts/oraiswap_staking/examples/schema.rs b/contracts/oraiswap_staking/examples/schema.rs deleted file mode 100644 index 15dc708a..00000000 --- a/contracts/oraiswap_staking/examples/schema.rs +++ /dev/null @@ -1,24 +0,0 @@ -use std::env::current_dir; -use std::fs::create_dir_all; - -use cosmwasm_schema::{export_schema, remove_schemas, schema_for}; -use oraiswap::staking::{ - ConfigResponse, Cw20HookMsg, ExecuteMsg, InstantiateMsg, MigrateMsg, PoolInfoResponse, - QueryMsg, RewardInfoResponse, -}; - -fn main() { - let mut out_dir = current_dir().unwrap(); - out_dir.push("artifacts/schema"); - create_dir_all(&out_dir).unwrap(); - remove_schemas(&out_dir).unwrap(); - - export_schema(&schema_for!(InstantiateMsg), &out_dir); - export_schema(&schema_for!(ExecuteMsg), &out_dir); - export_schema(&schema_for!(Cw20HookMsg), &out_dir); - export_schema(&schema_for!(QueryMsg), &out_dir); - export_schema(&schema_for!(MigrateMsg), &out_dir); - export_schema(&schema_for!(ConfigResponse), &out_dir); - export_schema(&schema_for!(RewardInfoResponse), &out_dir); - export_schema(&schema_for!(PoolInfoResponse), &out_dir); -} diff --git a/contracts/oraiswap_staking/schema/config_response.json b/contracts/oraiswap_staking/schema/config_response.json deleted file mode 100644 index ea05e987..00000000 --- a/contracts/oraiswap_staking/schema/config_response.json +++ /dev/null @@ -1,43 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "ConfigResponse", - "type": "object", - "required": [ - "base_denom", - "mint_contract", - "rewarder", - "oracle_contract", - "owner", - "premium_min_update_interval", - "short_reward_contract", - "oraiswap_factory" - ], - "properties": { - "base_denom": { - "type": "string" - }, - "mint_contract": { - "type": "string" - }, - "rewarder": { - "type": "string" - }, - "oracle_contract": { - "type": "string" - }, - "owner": { - "type": "string" - }, - "premium_min_update_interval": { - "type": "integer", - "format": "uint64", - "minimum": 0.0 - }, - "short_reward_contract": { - "type": "string" - }, - "oraiswap_factory": { - "type": "string" - } - } -} diff --git a/contracts/oraiswap_staking/schema/cw20_hook_msg.json b/contracts/oraiswap_staking/schema/cw20_hook_msg.json deleted file mode 100644 index 93f23a4c..00000000 --- a/contracts/oraiswap_staking/schema/cw20_hook_msg.json +++ /dev/null @@ -1,65 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "Cw20HookMsg", - "oneOf": [ - { - "type": "object", - "required": [ - "bond" - ], - "properties": { - "bond": { - "type": "object", - "required": [ - "asset_token" - ], - "properties": { - "asset_token": { - "type": "string" - } - } - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": [ - "deposit_reward" - ], - "properties": { - "deposit_reward": { - "type": "object", - "required": [ - "rewards" - ], - "properties": { - "rewards": { - "type": "array", - "items": { - "type": "array", - "items": [ - { - "type": "string" - }, - { - "$ref": "#/definitions/Uint128" - } - ], - "maxItems": 2, - "minItems": 2 - } - } - } - } - }, - "additionalProperties": false - } - ], - "definitions": { - "Uint128": { - "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", - "type": "string" - } - } -} diff --git a/contracts/oraiswap_staking/schema/execute_msg.json b/contracts/oraiswap_staking/schema/execute_msg.json deleted file mode 100644 index 8dcca464..00000000 --- a/contracts/oraiswap_staking/schema/execute_msg.json +++ /dev/null @@ -1,321 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "HandleMsg", - "oneOf": [ - { - "type": "object", - "required": ["receive"], - "properties": { - "receive": { - "$ref": "#/definitions/Cw20ReceiveMsg" - } - }, - "additionalProperties": false - }, - { - "description": "Owner operations ///", - "type": "object", - "required": ["update_config"], - "properties": { - "update_config": { - "type": "object", - "properties": { - "owner": { - "type": ["string", "null"] - }, - "premium_min_update_interval": { - "type": ["integer", "null"], - "format": "uint64", - "minimum": 0.0 - }, - "short_reward_contract": { - "type": ["string", "null"] - } - } - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": ["register_asset"], - "properties": { - "register_asset": { - "type": "object", - "required": ["asset_token", "staking_token"], - "properties": { - "asset_token": { - "type": "string" - }, - "staking_token": { - "type": "string" - } - } - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": ["deprecate_staking_token"], - "properties": { - "deprecate_staking_token": { - "type": "object", - "required": ["asset_token", "new_staking_token"], - "properties": { - "asset_token": { - "type": "string" - }, - "new_staking_token": { - "type": "string" - } - } - } - }, - "additionalProperties": false - }, - { - "description": "User operations ///", - "type": "object", - "required": ["unbond"], - "properties": { - "unbond": { - "type": "object", - "required": ["amount", "asset_token"], - "properties": { - "amount": { - "$ref": "#/definitions/Uint128" - }, - "asset_token": { - "type": "string" - } - } - } - }, - "additionalProperties": false - }, - { - "description": "Withdraw pending rewards", - "type": "object", - "required": ["withdraw"], - "properties": { - "withdraw": { - "type": "object", - "properties": { - "asset_token": { - "type": ["string", "null"] - } - } - } - }, - "additionalProperties": false - }, - { - "description": "Provides liquidity and automatically stakes the LP tokens", - "type": "object", - "required": ["auto_stake"], - "properties": { - "auto_stake": { - "type": "object", - "required": ["assets"], - "properties": { - "assets": { - "type": "array", - "items": { - "$ref": "#/definitions/Asset" - }, - "maxItems": 2, - "minItems": 2 - }, - "slippage_tolerance": { - "anyOf": [ - { - "$ref": "#/definitions/Decimal" - }, - { - "type": "null" - } - ] - } - } - } - }, - "additionalProperties": false - }, - { - "description": "Hook to stake the minted LP tokens", - "type": "object", - "required": ["auto_stake_hook"], - "properties": { - "auto_stake_hook": { - "type": "object", - "required": [ - "asset_token", - "prev_staking_token_amount", - "staker_addr", - "staking_token" - ], - "properties": { - "asset_token": { - "type": "string" - }, - "prev_staking_token_amount": { - "$ref": "#/definitions/Uint128" - }, - "staker_addr": { - "type": "string" - }, - "staking_token": { - "type": "string" - } - } - } - }, - "additionalProperties": false - }, - { - "description": "Permission-less operations ///", - "type": "object", - "required": ["adjust_premium"], - "properties": { - "adjust_premium": { - "type": "object", - "required": ["asset_tokens"], - "properties": { - "asset_tokens": { - "type": "array", - "items": { - "type": "string" - } - } - } - } - }, - "additionalProperties": false - }, - { - "description": "Mint contract operations ///", - "type": "object", - "required": ["increase_short_token"], - "properties": { - "increase_short_token": { - "type": "object", - "required": ["amount", "asset_token", "staker_addr"], - "properties": { - "amount": { - "$ref": "#/definitions/Uint128" - }, - "asset_token": { - "type": "string" - }, - "staker_addr": { - "type": "string" - } - } - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": ["decrease_short_token"], - "properties": { - "decrease_short_token": { - "type": "object", - "required": ["amount", "asset_token", "staker_addr"], - "properties": { - "amount": { - "$ref": "#/definitions/Uint128" - }, - "asset_token": { - "type": "string" - }, - "staker_addr": { - "type": "string" - } - } - } - }, - "additionalProperties": false - } - ], - "definitions": { - "Asset": { - "type": "object", - "required": ["amount", "info"], - "properties": { - "amount": { - "$ref": "#/definitions/Uint128" - }, - "info": { - "$ref": "#/definitions/AssetInfo" - } - } - }, - "AssetInfo": { - "description": "AssetInfo contract_addr is usually passed from the cw20 hook so we can trust the contract_addr is properly validated.", - "oneOf": [ - { - "type": "object", - "required": ["token"], - "properties": { - "token": { - "type": "object", - "required": ["contract_addr"], - "properties": { - "contract_addr": { - "type": "string" - } - } - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": ["native_token"], - "properties": { - "native_token": { - "type": "object", - "required": ["denom"], - "properties": { - "denom": { - "type": "string" - } - } - } - }, - "additionalProperties": false - } - ] - }, - "Binary": { - "description": "Binary is a wrapper around Vec to add base64 de/serialization with serde. It also adds some helper methods to help encode inline.\n\nThis is only needed as serde-json-{core,wasm} has a horrible encoding for Vec", - "type": "string" - }, - "Cw20ReceiveMsg": { - "description": "Cw20ReceiveMsg should be de/serialized under `Receive()` variant in a HandleMsg", - "type": "object", - "required": ["amount", "msg", "sender"], - "properties": { - "amount": { - "$ref": "#/definitions/Uint128" - }, - "msg": { - "$ref": "#/definitions/Binary" - }, - "sender": { - "type": "string" - } - } - }, - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, - "Uint128": { - "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", - "type": "string" - } - } -} diff --git a/contracts/oraiswap_staking/schema/instantiate_msg.json b/contracts/oraiswap_staking/schema/instantiate_msg.json deleted file mode 100644 index 875e3819..00000000 --- a/contracts/oraiswap_staking/schema/instantiate_msg.json +++ /dev/null @@ -1,43 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "InitMsg", - "type": "object", - "required": [ - "base_denom", - "mint_contract", - "rewarder", - "oracle_contract", - "owner", - "premium_min_update_interval", - "short_reward_contract", - "oraiswap_factory" - ], - "properties": { - "base_denom": { - "type": "string" - }, - "mint_contract": { - "type": "string" - }, - "rewarder": { - "type": "string" - }, - "oracle_contract": { - "type": "string" - }, - "owner": { - "type": "string" - }, - "premium_min_update_interval": { - "type": "integer", - "format": "uint64", - "minimum": 0.0 - }, - "short_reward_contract": { - "type": "string" - }, - "oraiswap_factory": { - "type": "string" - } - } -} diff --git a/contracts/oraiswap_staking/schema/migrate_msg.json b/contracts/oraiswap_staking/schema/migrate_msg.json deleted file mode 100644 index c6036545..00000000 --- a/contracts/oraiswap_staking/schema/migrate_msg.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "MigrateMsg", - "description": "We currently take no arguments for migrations", - "type": "object", - "required": [ - "asset_token_to_deprecate", - "new_staking_token" - ], - "properties": { - "asset_token_to_deprecate": { - "type": "string" - }, - "new_staking_token": { - "type": "string" - } - } -} diff --git a/contracts/oraiswap_staking/schema/pool_info_response.json b/contracts/oraiswap_staking/schema/pool_info_response.json deleted file mode 100644 index 94c28929..00000000 --- a/contracts/oraiswap_staking/schema/pool_info_response.json +++ /dev/null @@ -1,81 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "PoolInfoResponse", - "type": "object", - "required": [ - "asset_token", - "pending_reward", - "premium_rate", - "premium_updated_time", - "reward_index", - "short_pending_reward", - "short_reward_index", - "short_reward_weight", - "staking_token", - "total_bond_amount", - "total_short_amount" - ], - "properties": { - "asset_token": { - "type": "string" - }, - "migration_deprecated_staking_token": { - "type": [ - "string", - "null" - ] - }, - "migration_index_snapshot": { - "anyOf": [ - { - "$ref": "#/definitions/Decimal" - }, - { - "type": "null" - } - ] - }, - "pending_reward": { - "$ref": "#/definitions/Uint128" - }, - "premium_rate": { - "$ref": "#/definitions/Decimal" - }, - "premium_updated_time": { - "type": "integer", - "format": "uint64", - "minimum": 0.0 - }, - "reward_index": { - "$ref": "#/definitions/Decimal" - }, - "short_pending_reward": { - "$ref": "#/definitions/Uint128" - }, - "short_reward_index": { - "$ref": "#/definitions/Decimal" - }, - "short_reward_weight": { - "$ref": "#/definitions/Decimal" - }, - "staking_token": { - "type": "string" - }, - "total_bond_amount": { - "$ref": "#/definitions/Uint128" - }, - "total_short_amount": { - "$ref": "#/definitions/Uint128" - } - }, - "definitions": { - "Decimal": { - "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", - "type": "string" - }, - "Uint128": { - "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", - "type": "string" - } - } -} diff --git a/contracts/oraiswap_staking/schema/query_msg.json b/contracts/oraiswap_staking/schema/query_msg.json deleted file mode 100644 index 06447627..00000000 --- a/contracts/oraiswap_staking/schema/query_msg.json +++ /dev/null @@ -1,64 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "QueryMsg", - "oneOf": [ - { - "type": "object", - "required": [ - "config" - ], - "properties": { - "config": { - "type": "object" - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": [ - "pool_info" - ], - "properties": { - "pool_info": { - "type": "object", - "required": [ - "asset_token" - ], - "properties": { - "asset_token": { - "type": "string" - } - } - } - }, - "additionalProperties": false - }, - { - "type": "object", - "required": [ - "reward_info" - ], - "properties": { - "reward_info": { - "type": "object", - "required": [ - "staker_addr" - ], - "properties": { - "asset_token": { - "type": [ - "string", - "null" - ] - }, - "staker_addr": { - "type": "string" - } - } - } - }, - "additionalProperties": false - } - ] -} diff --git a/contracts/oraiswap_staking/schema/reward_info_response.json b/contracts/oraiswap_staking/schema/reward_info_response.json deleted file mode 100644 index a8661a26..00000000 --- a/contracts/oraiswap_staking/schema/reward_info_response.json +++ /dev/null @@ -1,55 +0,0 @@ -{ - "$schema": "http://json-schema.org/draft-07/schema#", - "title": "RewardInfoResponse", - "type": "object", - "required": [ - "reward_infos", - "staker_addr" - ], - "properties": { - "reward_infos": { - "type": "array", - "items": { - "$ref": "#/definitions/RewardInfoResponseItem" - } - }, - "staker_addr": { - "type": "string" - } - }, - "definitions": { - "RewardInfoResponseItem": { - "type": "object", - "required": [ - "asset_token", - "bond_amount", - "is_short", - "pending_reward" - ], - "properties": { - "asset_token": { - "type": "string" - }, - "bond_amount": { - "$ref": "#/definitions/Uint128" - }, - "is_short": { - "type": "boolean" - }, - "pending_reward": { - "$ref": "#/definitions/Uint128" - }, - "should_migrate": { - "type": [ - "boolean", - "null" - ] - } - } - }, - "Uint128": { - "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", - "type": "string" - } - } -} diff --git a/contracts/oraiswap_staking/src/bin/schema.rs b/contracts/oraiswap_staking/src/bin/schema.rs new file mode 100644 index 00000000..7935161e --- /dev/null +++ b/contracts/oraiswap_staking/src/bin/schema.rs @@ -0,0 +1,11 @@ +use cosmwasm_schema::write_api; + +use oraiswap::staking::{ExecuteMsg, InstantiateMsg, QueryMsg}; + +fn main() { + write_api! { + instantiate: InstantiateMsg, + execute: ExecuteMsg, + query: QueryMsg, + } +} diff --git a/contracts/oraiswap_staking/src/contract.rs b/contracts/oraiswap_staking/src/contract.rs index 1038516c..719ba4ab 100644 --- a/contracts/oraiswap_staking/src/contract.rs +++ b/contracts/oraiswap_staking/src/contract.rs @@ -1,4 +1,7 @@ -use crate::migration::migrate_rewards_store; +#[cfg(not(feature = "library"))] +use cosmwasm_std::entry_point; + +// use crate::migration::migrate_rewards_store; use crate::rewards::{ deposit_reward, process_reward_assets, query_all_reward_infos, query_reward_info, withdraw_reward, withdraw_reward_others, @@ -10,8 +13,8 @@ use crate::state::{ }; use cosmwasm_std::{ - attr, from_binary, to_binary, Addr, Binary, CanonicalAddr, Decimal, Deps, DepsMut, Env, - MessageInfo, Order, Response, Response, Response, StdError, StdResult, Uint128, + from_binary, to_binary, Addr, Binary, CanonicalAddr, Decimal, Deps, DepsMut, Env, MessageInfo, + Order, Response, StdError, StdResult, Uint128, }; use oraiswap::asset::{Asset, AssetInfo, AssetRaw, ORAI_DENOM}; use oraiswap::staking::{ @@ -21,6 +24,7 @@ use oraiswap::staking::{ use cw20::Cw20ReceiveMsg; +#[cfg_attr(not(feature = "library"), entry_point)] pub fn instantiate( deps: DepsMut, _env: Env, @@ -32,10 +36,10 @@ pub fn instantiate( &Config { owner: deps .api - .addr_canonicalize(&msg.owner.unwrap_or(info.sender.clone()))?, - rewarder: deps.api.addr_canonicalize(&msg.rewarder)?, + .addr_canonicalize(msg.owner.unwrap_or(info.sender.clone()).as_str())?, + rewarder: deps.api.addr_canonicalize(msg.rewarder.as_str())?, oracle_addr: deps.api.addr_canonicalize(msg.oracle_addr.as_str())?, - factory_addr: deps.api.addr_canonicalize(&msg.factory_addr)?, + factory_addr: deps.api.addr_canonicalize(msg.factory_addr.as_str())?, // default base_denom pass to factory is orai token base_denom: msg.base_denom.unwrap_or(ORAI_DENOM.to_string()), }, @@ -44,6 +48,7 @@ pub fn instantiate( Ok(Response::default()) } +#[cfg_attr(not(feature = "library"), entry_point)] pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> StdResult { match msg { ExecuteMsg::Receive(msg) => receive_cw20(deps, info, msg), @@ -98,7 +103,7 @@ pub fn receive_cw20( info: MessageInfo, cw20_msg: Cw20ReceiveMsg, ) -> StdResult { - match from_binary(&cw20_msg.msg.unwrap_or(Binary::default())) { + match from_binary(&cw20_msg.msg) { Ok(Cw20HookMsg::Bond { asset_info }) => { // check permission let asset_key = asset_info.to_vec(deps.api)?; @@ -122,7 +127,12 @@ pub fn receive_cw20( return Err(StdError::generic_err("unauthorized")); } - bond(deps, cw20_msg.sender, asset_info, cw20_msg.amount) + bond( + deps, + Addr::unchecked(cw20_msg.sender), + asset_info, + cw20_msg.amount, + ) } Err(_) => Err(StdError::generic_err("invalid cw20 hook message")), } @@ -145,15 +155,11 @@ pub fn update_config( } if let Some(rewarder) = rewarder { - config.rewarder = deps.api.addr_canonicalize(&rewarder)?; + config.rewarder = deps.api.addr_canonicalize(rewarder.as_str())?; } store_config(deps.storage, &config)?; - Ok(Response { - messages: vec![], - attributes: vec![attr("action", "update_config")], - data: None, - }) + Ok(Response::new().add_attribute("action", "update_config")) } // need to withdraw all rewards of the stakers belong to the pool @@ -201,11 +207,7 @@ fn update_rewards_per_sec( store_rewards_per_sec(deps.storage, &asset_key, raw_assets)?; - Ok(Response { - messages: vec![], - attributes: vec![attr("action", "update_rewards_per_sec")], - data: None, - }) + Ok(Response::new().add_attribute("action", "update_rewards_per_sec")) } fn register_asset( @@ -230,7 +232,7 @@ fn register_asset( deps.storage, &asset_key, &PoolInfo { - staking_token: deps.api.addr_canonicalize(&staking_token)?, + staking_token: deps.api.addr_canonicalize(staking_token.as_str())?, total_bond_amount: Uint128::zero(), reward_index: Decimal::zero(), pending_reward: Uint128::zero(), @@ -238,14 +240,10 @@ fn register_asset( }, )?; - Ok(Response { - messages: vec![], - attributes: vec![ - attr("action", "register_asset"), - attr("asset_info", asset_info), - ], - data: None, - }) + Ok(Response::new().add_attributes([ + ("action", "register_asset"), + ("asset_info", &asset_info.to_string()), + ])) } fn deprecate_staking_token( @@ -276,25 +274,22 @@ fn deprecate_staking_token( index_snapshot: pool_info.reward_index, deprecated_staking_token: pool_info.staking_token, }); - pool_info.staking_token = deps.api.addr_canonicalize(&new_staking_token)?; + pool_info.staking_token = deps.api.addr_canonicalize(new_staking_token.as_str())?; store_pool_info(deps.storage, &asset_key, &pool_info)?; - Ok(Response { - messages: vec![], - attributes: vec![ - attr("action", "depcrecate_staking_token"), - attr("asset_info", asset_info), - attr( - "deprecated_staking_token", - deprecated_token_addr.to_string(), - ), - attr("new_staking_token", new_staking_token.to_string()), - ], - data: None, - }) + Ok(Response::new().add_attributes([ + ("action", "depcrecate_staking_token"), + ("asset_info", &asset_info.to_string()), + ( + "deprecated_staking_token", + &deprecated_token_addr.to_string(), + ), + ("new_staking_token", &new_staking_token.to_string()), + ])) } +#[cfg_attr(not(feature = "library"), entry_point)] pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult { match msg { QueryMsg::Config {} => to_binary(&query_config(deps)?), @@ -371,15 +366,11 @@ pub fn query_rewards_per_sec( } // migrate contract -pub fn migrate( - deps: DepsMut, - _env: Env, - _info: MessageInfo, - msg: MigrateMsg, -) -> StdResult { +#[cfg_attr(not(feature = "library"), entry_point)] +pub fn migrate(_deps: DepsMut, _env: Env, _msg: MigrateMsg) -> StdResult { // migrate_pool_infos(deps.storage)?; // migrate_config(deps.storage)?; - migrate_rewards_store(deps.storage, deps.api, msg.staker_addrs)?; + // migrate_rewards_store(deps.storage, deps.api, msg.staker_addrs)?; // migrate_total_reward_amount(deps.storage, deps.api, msg.amount_infos)?; // when the migration is executed, deprecate directly the MIR pool diff --git a/contracts/oraiswap_staking/src/migration.rs b/contracts/oraiswap_staking/src/migration.rs index 188481ef..9254f34d 100644 --- a/contracts/oraiswap_staking/src/migration.rs +++ b/contracts/oraiswap_staking/src/migration.rs @@ -31,6 +31,7 @@ pub struct LegacyRewardInfo { /// returns a bucket with all rewards owned by this owner (query it by owner) /// (read-only version for queries) +#[allow(dead_code)] pub fn legacy_rewards_read<'a>( storage: &'a dyn Storage, owner: &CanonicalAddr, @@ -38,6 +39,7 @@ pub fn legacy_rewards_read<'a>( ReadonlyBucket::multilevel(storage, &[PREFIX_REWARD, owner.as_slice()]) } +#[allow(dead_code)] pub fn migrate_rewards_store( store: &mut dyn Storage, api: &dyn Api, @@ -45,7 +47,7 @@ pub fn migrate_rewards_store( ) -> StdResult<()> { let list_staker_addrs: Vec = staker_addrs .iter() - .map(|addr| Ok(api.addr_canonicalize(addr)?)) + .map(|addr| Ok(api.addr_canonicalize(addr.as_str())?)) .collect::>>()?; for staker_addr in list_staker_addrs { let rewards_bucket = legacy_rewards_read(store, &staker_addr); diff --git a/contracts/oraiswap_staking/src/rewards.rs b/contracts/oraiswap_staking/src/rewards.rs index 590f3ca7..c3f925f1 100644 --- a/contracts/oraiswap_staking/src/rewards.rs +++ b/contracts/oraiswap_staking/src/rewards.rs @@ -5,8 +5,8 @@ use crate::state::{ rewards_read, rewards_store, stakers_read, store_pool_info, PoolInfo, RewardInfo, }; use cosmwasm_std::{ - attr, Addr, Api, CanonicalAddr, CosmosMsg, Decimal, Deps, DepsMut, Env, MessageInfo, Order, - Response, StdError, StdResult, Storage, Uint128, + Addr, Api, CanonicalAddr, CosmosMsg, Decimal, Deps, DepsMut, Env, MessageInfo, Order, Response, + StdError, StdResult, Storage, Uint128, }; use oraiswap::asset::{Asset, AssetInfo, AssetRaw}; use oraiswap::staking::{RewardInfoResponse, RewardInfoResponseItem}; @@ -52,20 +52,16 @@ pub fn deposit_reward( rewards_amount += asset.amount; } - Ok(Response { - messages: vec![], - data: None, - attributes: vec![ - attr("action", "deposit_reward"), - attr("rewards_amount", rewards_amount.to_string()), - ], - }) + Ok(Response::new().add_attributes([ + ("action", "deposit_reward"), + ("rewards_amount", &rewards_amount.to_string()), + ])) } // withdraw all rewards or single reward depending on asset_token pub fn withdraw_reward( deps: DepsMut, - env: Env, + _env: Env, info: MessageInfo, asset_info: Option, ) -> StdResult { @@ -77,20 +73,15 @@ pub fn withdraw_reward( let messages = reward_assets .into_iter() .map(|ra| { - Ok(ra.to_normal(deps.api)?.into_msg( - None, - &deps.querier, - env.contract.address.clone(), - info.sender.clone(), - )?) + Ok(ra + .to_normal(deps.api)? + .into_msg(None, &deps.querier, info.sender.clone())?) }) .collect::>>()?; - Ok(Response { - messages, - attributes: vec![attr("action", "withdraw_reward")], - data: None, - }) + Ok(Response::new() + .add_messages(messages) + .add_attribute("action", "withdraw_reward")) } pub fn withdraw_reward_others( @@ -112,15 +103,11 @@ pub fn withdraw_reward_others( // withdraw reward for each staker for staker_addr in staker_addrs { - let staker_addr_raw = deps.api.addr_canonicalize(&staker_addr)?; + let staker_addr_raw = deps.api.addr_canonicalize(staker_addr.as_str())?; process_reward_assets(deps.storage, &staker_addr_raw, &asset_key.clone(), false)?; } - Ok(Response { - messages: vec![], - attributes: vec![attr("action", "withdraw_reward_others")], - data: None, - }) + Ok(Response::new().add_attribute("action", "withdraw_reward_others")) } fn update_reward_assets_amount(reward_assets: &mut Vec, rw: AssetRaw, amount: Uint128) { @@ -222,10 +209,8 @@ pub fn process_reward_assets( // withdraw reward to pending reward pub fn before_share_change(pool_index: Decimal, reward_info: &mut RewardInfo) -> StdResult<()> { - let pending_reward = Asset::checked_sub( - reward_info.bond_amount * pool_index, - reward_info.bond_amount * reward_info.index, - )?; + let pending_reward = (reward_info.bond_amount * pool_index) + .checked_sub(reward_info.bond_amount * reward_info.index)?; reward_info.index = pool_index; reward_info.pending_reward += pending_reward; @@ -237,7 +222,7 @@ pub fn query_reward_info( staker_addr: Addr, asset_info: Option, ) -> StdResult { - let staker_addr_raw = deps.api.addr_canonicalize(&staker_addr)?; + let staker_addr_raw = deps.api.addr_canonicalize(staker_addr.as_str())?; let reward_infos: Vec = _read_reward_infos_response(deps.api, deps.storage, &staker_addr_raw, &asset_info)?; @@ -259,7 +244,7 @@ pub fn query_all_reward_infos( let order_by = Order::try_from(order.unwrap_or(1))?; let asset_key = asset_info.to_vec(deps.api)?; let start_after = start_after - .map_or(None, |a| deps.api.addr_canonicalize(&a).ok()) + .map_or(None, |a| deps.api.addr_canonicalize(a.as_str()).ok()) .map(|c| c.to_vec()); let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT) as usize; diff --git a/contracts/oraiswap_staking/src/staking.rs b/contracts/oraiswap_staking/src/staking.rs index 936a78c1..0a4decc5 100644 --- a/contracts/oraiswap_staking/src/staking.rs +++ b/contracts/oraiswap_staking/src/staking.rs @@ -20,7 +20,7 @@ pub fn bond( asset_info: AssetInfo, amount: Uint128, ) -> StdResult { - let staker_addr_raw: CanonicalAddr = deps.api.addr_canonicalize(&staker_addr)?; + let staker_addr_raw: CanonicalAddr = deps.api.addr_canonicalize(staker_addr.as_str())?; _increase_bond_amount( deps.storage, deps.api, @@ -29,26 +29,22 @@ pub fn bond( amount, )?; - Ok(Response { - messages: vec![], - attributes: vec![ - attr("action", "bond"), - attr("staker_addr", staker_addr.as_str()), - attr("asset_info", asset_info), - attr("amount", amount.to_string()), - ], - data: None, - }) + Ok(Response::new().add_attributes([ + ("action", "bond"), + ("staker_addr", staker_addr.as_str()), + ("asset_info", &asset_info.to_string()), + ("amount", &amount.to_string()), + ])) } pub fn unbond( deps: DepsMut, - env: Env, + _env: Env, staker_addr: Addr, asset_info: AssetInfo, amount: Uint128, ) -> StdResult { - let staker_addr_raw: CanonicalAddr = deps.api.addr_canonicalize(&staker_addr)?; + let staker_addr_raw: CanonicalAddr = deps.api.addr_canonicalize(staker_addr.as_str())?; let (staking_token, reward_assets) = _decrease_bond_amount( deps.storage, deps.api, @@ -58,12 +54,12 @@ pub fn unbond( )?; let staking_token_addr = deps.api.addr_humanize(&staking_token)?; let mut messages = vec![WasmMsg::Execute { - contract_addr: staking_token_addr.clone(), + contract_addr: staking_token_addr.to_string(), msg: to_binary(&Cw20ExecuteMsg::Transfer { - recipient: staker_addr.clone(), + recipient: staker_addr.to_string(), amount, })?, - send: vec![], + funds: vec![], } .into()]; @@ -71,28 +67,17 @@ pub fn unbond( messages.extend( reward_assets .into_iter() - .map(|ra| { - Ok(ra.into_msg( - None, - &deps.querier, - env.contract.address.clone(), - staker_addr.clone(), - )?) - }) + .map(|ra| Ok(ra.into_msg(None, &deps.querier, staker_addr.clone())?)) .collect::>>()?, ); - Ok(Response { - messages, - attributes: vec![ - attr("action", "unbond"), - attr("staker_addr", staker_addr.as_str()), - attr("asset_info", asset_info), - attr("amount", amount.to_string()), - attr("staking_token", staking_token_addr.as_str()), - ], - data: None, - }) + Ok(Response::new().add_messages(messages).add_attributes([ + attr("action", "unbond"), + attr("staker_addr", staker_addr.as_str()), + attr("asset_info", &asset_info.to_string()), + attr("amount", &amount.to_string()), + attr("staking_token", staking_token_addr.as_str()), + ])) } pub fn update_list_stakers( @@ -109,15 +94,13 @@ pub fn update_list_stakers( } let asset_info_raw = asset_info.to_raw(deps.api)?; for staker in stakers { - stakers_store(deps.storage, asset_info_raw.as_bytes()) - .save(deps.api.addr_canonicalize(&staker)?.as_slice(), &true)?; + stakers_store(deps.storage, asset_info_raw.as_bytes()).save( + deps.api.addr_canonicalize(staker.as_str())?.as_slice(), + &true, + )?; } - Ok(Response { - messages: vec![], - attributes: vec![attr("action", "update_list_stakers")], - data: None, - }) + Ok(Response::new().add_attribute("action", "update_list_stakers")) } pub fn auto_stake( @@ -159,10 +142,16 @@ pub fn auto_stake( let oraiswap_pair: PairInfo = query_pair_info(&deps.querier, factory_addr, &asset_infos)?; // assert the token and lp token match with pool info - let pool_info: PoolInfo = - read_pool_info(deps.storage, &deps.api.addr_canonicalize(&token_addr)?)?; + let pool_info: PoolInfo = read_pool_info( + deps.storage, + &deps.api.addr_canonicalize(token_addr.as_str())?, + )?; - if pool_info.staking_token != deps.api.addr_canonicalize(&oraiswap_pair.liquidity_token)? { + if pool_info.staking_token + != deps + .api + .addr_canonicalize(oraiswap_pair.liquidity_token.as_str())? + { return Err(StdError::generic_err("Invalid staking token")); } @@ -182,34 +171,32 @@ pub fn auto_stake( // 2. Increase allowance of token for pair contract // 3. Provide liquidity // 4. Execute staking hook, will stake in the name of the sender - Ok(Response { - messages: vec![ + Ok(Response::new() + .add_messages(vec![ WasmMsg::Execute { - contract_addr: token_addr.clone(), + contract_addr: token_addr.to_string(), msg: to_binary(&Cw20ExecuteMsg::TransferFrom { - owner: info.sender.clone(), - recipient: env.contract.address.clone(), + owner: info.sender.to_string(), + recipient: env.contract.address.to_string(), amount: token_amount, })?, - send: vec![], - } - .into(), + funds: vec![], + }, WasmMsg::Execute { - contract_addr: token_addr.clone(), + contract_addr: token_addr.to_string(), msg: to_binary(&Cw20ExecuteMsg::IncreaseAllowance { - spender: oraiswap_pair.contract_addr.clone(), + spender: oraiswap_pair.contract_addr.to_string(), amount: token_amount, expires: None, })?, - send: vec![], - } - .into(), + funds: vec![], + }, WasmMsg::Execute { - contract_addr: oraiswap_pair.contract_addr.clone(), + contract_addr: oraiswap_pair.contract_addr.to_string(), msg: to_binary(&PairExecuteMsg::ProvideLiquidity { assets: [ Asset { - amount: Asset::checked_sub(native_asset.amount, tax_amount)?, + amount: native_asset.amount.checked_sub(tax_amount)?, info: native_asset.info.clone(), }, Asset { @@ -222,14 +209,13 @@ pub fn auto_stake( slippage_tolerance, receiver: None, })?, - send: vec![Coin { + funds: vec![Coin { denom: native_asset.info.to_string(), - amount: Asset::checked_sub(native_asset.amount, tax_amount)?, + amount: native_asset.amount.checked_sub(tax_amount)?, }], - } - .into(), + }, WasmMsg::Execute { - contract_addr: env.contract.address, + contract_addr: env.contract.address.to_string(), msg: to_binary(&ExecuteMsg::AutoStakeHook { asset_info: AssetInfo::Token { contract_addr: token_addr.clone(), @@ -238,17 +224,14 @@ pub fn auto_stake( staker_addr: info.sender, prev_staking_token_amount, })?, - send: vec![], - } - .into(), - ], - attributes: vec![ - attr("action", "auto_stake"), - attr("asset_token", token_addr.to_string()), - attr("tax_amount", tax_amount.to_string()), - ], - data: None, - }) + funds: vec![], + }, + ]) + .add_attributes([ + ("action", "auto_stake"), + ("asset_token", &token_addr.to_string()), + ("tax_amount", &tax_amount.to_string()), + ])) } pub fn auto_stake_hook( @@ -268,8 +251,7 @@ pub fn auto_stake_hook( // stake all lp tokens received, compare with staking token amount before liquidity provision was executed let current_staking_token_amount = query_token_balance(&deps.querier, staking_token, env.contract.address)?; - let amount_to_stake = - Asset::checked_sub(current_staking_token_amount, prev_staking_token_amount)?; + let amount_to_stake = current_staking_token_amount.checked_sub(prev_staking_token_amount)?; bond(deps, staker_addr, asset_info, amount_to_stake) } @@ -359,11 +341,11 @@ fn _decrease_bond_amount( // Decrease total bond amount if !should_migrate { // if it should migrate, we dont need to decrease from the current total bond amount - pool_info.total_bond_amount = Asset::checked_sub(pool_info.total_bond_amount, amount)?; + pool_info.total_bond_amount = pool_info.total_bond_amount.checked_sub(amount)?; } // Update rewards info - reward_info.bond_amount = Asset::checked_sub(reward_info.bond_amount, amount)?; + reward_info.bond_amount = reward_info.bond_amount.checked_sub(amount)?; if reward_info.bond_amount.is_zero() && should_migrate { store_is_migrated(storage, asset_key, staker_addr)?; diff --git a/contracts/oraiswap_staking/src/testing/contract_test.rs b/contracts/oraiswap_staking/src/testing/contract_test.rs index 6c90b1ab..290938c9 100644 --- a/contracts/oraiswap_staking/src/testing/contract_test.rs +++ b/contracts/oraiswap_staking/src/testing/contract_test.rs @@ -1,5 +1,7 @@ -use crate::contract::{handle, init, query}; -use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info}; +use crate::contract::{execute, instantiate, query}; +use cosmwasm_std::testing::{ + mock_dependencies, mock_dependencies_with_balance, mock_env, mock_info, +}; use cosmwasm_std::{attr, coin, from_binary, to_binary, Addr, Decimal, Order, StdError, Uint128}; use cw20::Cw20ReceiveMsg; use oraiswap::asset::{Asset, AssetInfo, ORAI_DENOM}; @@ -10,14 +12,14 @@ use oraiswap::staking::{ #[test] fn proper_initialization() { - let mut deps = mock_dependencies(&[]); + let mut deps = mock_dependencies(); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "reward".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("reward"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -31,10 +33,10 @@ fn proper_initialization() { let config: ConfigResponse = from_binary(&res).unwrap(); assert_eq!( ConfigResponse { - owner: "owner".into(), - rewarder: "reward".into(), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Addr::unchecked("owner"), + rewarder: Addr::unchecked("reward"), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: ORAI_DENOM.to_string(), }, config @@ -43,14 +45,14 @@ fn proper_initialization() { #[test] fn update_config() { - let mut deps = mock_dependencies(&[]); + let mut deps = mock_dependencies(); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "reward".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("reward"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -60,7 +62,7 @@ fn update_config() { // update owner let info = mock_info("owner", &[]); let msg = ExecuteMsg::UpdateConfig { - owner: Some("owner2".into()), + owner: Some(Addr::unchecked("owner2")), rewarder: None, }; @@ -72,10 +74,10 @@ fn update_config() { let config: ConfigResponse = from_binary(&res).unwrap(); assert_eq!( ConfigResponse { - owner: "owner2".into(), - rewarder: "reward".into(), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Addr::unchecked("owner2"), + rewarder: Addr::unchecked("reward"), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: ORAI_DENOM.to_string(), }, config @@ -97,14 +99,14 @@ fn update_config() { #[test] fn test_register() { - let mut deps = mock_dependencies(&[]); + let mut deps = mock_dependencies(); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "reward".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("reward"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -115,9 +117,9 @@ fn test_register() { let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; // failed with unauthorized error @@ -143,7 +145,7 @@ fn test_register() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -153,9 +155,9 @@ fn test_register() { pool_info, PoolInfoResponse { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), total_bond_amount: Uint128::zero(), reward_index: Decimal::zero(), pending_reward: Uint128::zero(), @@ -167,14 +169,14 @@ fn test_register() { #[test] fn test_query_staker_pagination() { - let mut deps = mock_dependencies(&[coin(10000000000u128, ORAI_DENOM)]); + let mut deps = mock_dependencies_with_balance(&[coin(10000000000u128, ORAI_DENOM)]); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "rewarder".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("reward"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -185,7 +187,7 @@ fn test_query_staker_pagination() { // will also add to the index the pending rewards from before the migration let msg = ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![Asset { info: AssetInfo::NativeToken { @@ -199,9 +201,9 @@ fn test_query_staker_pagination() { let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; let info = mock_info("owner", &[]); @@ -210,14 +212,14 @@ fn test_query_staker_pagination() { // bond 100 tokens for 100 stakers for i in 0..100 { let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { - sender: format!("addr{}", i).into(), - amount: Uint128(100u128), + sender: format!("addr{}", i), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -231,7 +233,7 @@ fn test_query_staker_pagination() { mock_env(), QueryMsg::RewardInfos { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, limit: Some(10), order: Some(Order::Ascending.into()), diff --git a/contracts/oraiswap_staking/src/testing/deprecate_test.rs b/contracts/oraiswap_staking/src/testing/deprecate_test.rs index 097663d5..92ec015d 100644 --- a/contracts/oraiswap_staking/src/testing/deprecate_test.rs +++ b/contracts/oraiswap_staking/src/testing/deprecate_test.rs @@ -1,28 +1,30 @@ -use crate::contract::{handle, init, query}; +use crate::contract::{execute, instantiate, query}; use crate::state::{read_pool_info, store_pool_info}; -use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info}; -use cosmwasm_std::{coin, from_binary, to_binary, Api, Decimal, StdError, Uint128, WasmMsg}; +use cosmwasm_std::testing::{mock_dependencies_with_balance, mock_env, mock_info}; +use cosmwasm_std::{ + coin, from_binary, to_binary, Addr, Api, Decimal, StdError, SubMsg, Uint128, WasmMsg, +}; use cw20::{Cw20ExecuteMsg, Cw20ReceiveMsg}; use oraiswap::asset::{Asset, AssetInfo, ORAI_DENOM}; -use oraiswap::mock_app::ATOM_DENOM; use oraiswap::staking::{ Cw20HookMsg, ExecuteMsg, InstantiateMsg, PoolInfoResponse, QueryMsg, RewardInfoResponse, RewardInfoResponseItem, }; +use oraiswap::testing::ATOM_DENOM; #[test] fn test_deprecate() { - let mut deps = mock_dependencies(&[ + let mut deps = mock_dependencies_with_balance(&[ coin(10000000000u128, ORAI_DENOM), coin(20000000000u128, ATOM_DENOM), ]); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "rewarder".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("rewarder"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -31,15 +33,15 @@ fn test_deprecate() { let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; let info = mock_info("owner", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); - let asset_key = deps.api.addr_canonicalize(&"asset".into()).unwrap(); + let asset_key = deps.api.addr_canonicalize("asset").unwrap(); let pool_info = read_pool_info(&deps.storage, &asset_key).unwrap(); store_pool_info(&mut deps.storage, &asset_key, &pool_info).unwrap(); @@ -47,7 +49,7 @@ fn test_deprecate() { // will also add to the index the pending rewards from before the migration let msg = ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -69,14 +71,14 @@ fn test_deprecate() { // bond 100 tokens let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { - sender: "addr".into(), - amount: Uint128(100u128), + sender: "addr".to_string(), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -86,9 +88,9 @@ fn test_deprecate() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; let info = mock_info("rewarder", &[]); @@ -101,7 +103,7 @@ fn test_deprecate() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -112,7 +114,7 @@ fn test_deprecate() { assert_eq!( res_cmp, PoolInfoResponse { - total_bond_amount: Uint128(100u128), + total_bond_amount: Uint128::from(100u128), reward_index: Decimal::from_ratio(100u128, 100u128), migration_index_snapshot: None, migration_deprecated_staking_token: None, @@ -125,9 +127,9 @@ fn test_deprecate() { QueryMsg::RewardInfo { asset_info: None, // asset_info: Some(AssetInfo::Token { - // contract_addr: "asset".into(), + // contract_addr: Addr::unchecked("asset"), // }), - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), }, ) .unwrap(); @@ -135,25 +137,25 @@ fn test_deprecate() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - bond_amount: Uint128(100u128), - pending_reward: Uint128(100u128), + bond_amount: Uint128::from(100u128), + pending_reward: Uint128::from(100u128), pending_withdraw: vec![], should_migrate: None, }], } ); - // handle deprecate + // execute deprecate let msg = ExecuteMsg::DeprecateStakingToken { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - new_staking_token: "new_staking".into(), + new_staking_token: Addr::unchecked("new_staking"), }; let info = mock_info("owner", &[]); execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -162,9 +164,9 @@ fn test_deprecate() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; let info = mock_info("rewarder", &[]); @@ -177,7 +179,7 @@ fn test_deprecate() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -188,12 +190,12 @@ fn test_deprecate() { assert_eq!( res_cmp, PoolInfoResponse { - staking_token: "new_staking".into(), + staking_token: Addr::unchecked("new_staking"), total_bond_amount: Uint128::zero(), // reset reward_index: Decimal::from_ratio(100u128, 100u128), // stays the same migration_index_snapshot: Some(Decimal::from_ratio(100u128, 100u128)), - migration_deprecated_staking_token: Some("staking".into()), - pending_reward: Uint128(100u128), // new reward waiting here + migration_deprecated_staking_token: Some(Addr::unchecked("staking")), + pending_reward: Uint128::from(100u128), // new reward waiting here ..res } ); @@ -202,7 +204,7 @@ fn test_deprecate() { mock_env(), QueryMsg::RewardInfo { asset_info: None, - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), }, ) .unwrap(); @@ -210,13 +212,13 @@ fn test_deprecate() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - bond_amount: Uint128(100u128), - pending_reward: Uint128(100u128), // did not change + bond_amount: Uint128::from(100u128), + pending_reward: Uint128::from(100u128), // did not change pending_withdraw: vec![], should_migrate: Some(true), // non-short pos should migrate }], @@ -225,14 +227,14 @@ fn test_deprecate() { // try to bond new or old staking token, should fail both let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { - sender: "addr".into(), - amount: Uint128(100u128), + sender: "addr".to_string(), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let err = execute(deps.as_mut(), mock_env(), info, msg.clone()).unwrap_err(); @@ -250,32 +252,31 @@ fn test_deprecate() { // unbond all the old tokens let msg = ExecuteMsg::Unbond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }; let info = mock_info("addr", &[]); let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); // make sure that we are receiving deprecated lp tokens tokens assert_eq!( res.messages, - vec![WasmMsg::Execute { + vec![SubMsg::new(WasmMsg::Execute { contract_addr: "staking".into(), msg: to_binary(&Cw20ExecuteMsg::Transfer { - recipient: "addr".into(), - amount: Uint128(100u128), + recipient: "addr".to_string(), + amount: Uint128::from(100u128), }) .unwrap(), - send: vec![], - } - .into()] + funds: vec![], + })] ); let data = query( deps.as_ref(), mock_env(), QueryMsg::RewardInfo { asset_info: None, - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), }, ) .unwrap(); @@ -283,13 +284,13 @@ fn test_deprecate() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, bond_amount: Uint128::zero(), - pending_reward: Uint128(100u128), // still the same + pending_reward: Uint128::from(100u128), // still the same pending_withdraw: vec![], should_migrate: None, // now its back to empty },], @@ -298,14 +299,14 @@ fn test_deprecate() { // now can bond the new staking token let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { - sender: "addr".into(), - amount: Uint128(100u128), + sender: "addr".to_string(), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("new_staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -315,9 +316,9 @@ fn test_deprecate() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; let info = mock_info("rewarder", &[]); @@ -330,7 +331,7 @@ fn test_deprecate() { mock_env(), QueryMsg::RewardInfo { asset_info: None, - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), }, ) .unwrap(); @@ -338,13 +339,13 @@ fn test_deprecate() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - bond_amount: Uint128(100u128), - pending_reward: Uint128(300u128), // 100 * 3 + bond_amount: Uint128::from(100u128), + pending_reward: Uint128::from(300u128), // 100 * 3 pending_withdraw: vec![], should_migrate: None, },], @@ -354,13 +355,13 @@ fn test_deprecate() { // completely new users can bond let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { sender: "newaddr".into(), - amount: Uint128(100u128), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("new_staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -370,7 +371,7 @@ fn test_deprecate() { mock_env(), QueryMsg::RewardInfo { asset_info: None, - staker_addr: "newaddr".into(), + staker_addr: Addr::unchecked("newaddr"), }, ) .unwrap(); @@ -378,12 +379,12 @@ fn test_deprecate() { assert_eq!( res, RewardInfoResponse { - staker_addr: "newaddr".into(), + staker_addr: Addr::unchecked("newaddr"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - bond_amount: Uint128(100u128), + bond_amount: Uint128::from(100u128), pending_reward: Uint128::zero(), pending_withdraw: vec![], should_migrate: None, diff --git a/contracts/oraiswap_staking/src/testing/migrate_test.rs b/contracts/oraiswap_staking/src/testing/migrate_test.rs index a0ed7adc..8c408517 100644 --- a/contracts/oraiswap_staking/src/testing/migrate_test.rs +++ b/contracts/oraiswap_staking/src/testing/migrate_test.rs @@ -19,13 +19,12 @@ pub fn rewards_store<'a>( #[test] fn test_migration() { - let mut deps = mock_dependencies(&[]); - deps.api.canonical_length = 54; + let mut deps = mock_dependencies(); let mut legacy_store = pool_infos_old_store(&mut deps.storage); - let asset_1 = deps.api.addr_canonicalize(&"asset1".into()).unwrap(); + let asset_1 = deps.api.addr_canonicalize("asset1").unwrap(); let pool_info_1 = LegacyPoolInfo { - staking_token: deps.api.addr_canonicalize(&"staking1".into()).unwrap(), + staking_token: deps.api.addr_canonicalize("staking1").unwrap(), total_bond_amount: Uint128::from(1u128), total_short_amount: Uint128::from(1u128), reward_index: Decimal::percent(1), @@ -37,9 +36,9 @@ fn test_migration() { premium_updated_time: 1, migration_params: None, }; - let asset_2 = deps.api.addr_canonicalize(&"asset2".into()).unwrap(); + let asset_2 = deps.api.addr_canonicalize("asset2").unwrap(); let pool_info_2 = LegacyPoolInfo { - staking_token: deps.api.addr_canonicalize(&"staking2".into()).unwrap(), + staking_token: deps.api.addr_canonicalize("staking2").unwrap(), total_bond_amount: Uint128::from(2u128), total_short_amount: Uint128::from(2u128), reward_index: Decimal::percent(2), @@ -58,7 +57,7 @@ fn test_migration() { // update reward store let staker_addr = deps .api - .addr_canonicalize(&"orai1g4h64yjt0fvzv5v2j8tyfnpe5kmnetejvfgs7g".into()) + .addr_canonicalize("orai1g4h64yjt0fvzv5v2j8tyfnpe5kmnetejvfgs7g") .unwrap(); let asset_key = "foobar".as_bytes(); // store legacy reward info diff --git a/contracts/oraiswap_staking/src/testing/reward_test.rs b/contracts/oraiswap_staking/src/testing/reward_test.rs index 1c05b9d0..fdadf81c 100644 --- a/contracts/oraiswap_staking/src/testing/reward_test.rs +++ b/contracts/oraiswap_staking/src/testing/reward_test.rs @@ -1,28 +1,29 @@ -use crate::contract::{handle, init, query}; +use crate::contract::{execute, instantiate, query}; use crate::state::{read_pool_info, rewards_read, store_pool_info, PoolInfo, RewardInfo}; -use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info}; -use cosmwasm_std::{coin, from_binary, to_binary, Api, Decimal, Uint128}; +use cosmwasm_std::testing::{mock_dependencies_with_balance, mock_env, mock_info}; +use cosmwasm_std::{coin, from_binary, to_binary, Addr, Api, Decimal, Uint128}; use cw20::Cw20ReceiveMsg; use oraiswap::asset::{Asset, AssetInfo, ORAI_DENOM}; -use oraiswap::mock_app::{MockApp, ATOM_DENOM}; +use oraiswap::create_entry_points_testing; use oraiswap::staking::{ Cw20HookMsg, ExecuteMsg, InstantiateMsg, PoolInfoResponse, QueryMsg, RewardInfoResponse, RewardInfoResponseItem, }; +use oraiswap::testing::{MockApp, ATOM_DENOM}; #[test] fn test_deposit_reward() { - let mut deps = mock_dependencies(&[ + let mut deps = mock_dependencies_with_balance(&[ coin(10000000000u128, ORAI_DENOM), coin(20000000000u128, ATOM_DENOM), ]); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "rewarder".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("rewarder"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -32,7 +33,7 @@ fn test_deposit_reward() { // will also add to the index the pending rewards from before the migration let msg = ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -54,28 +55,28 @@ fn test_deposit_reward() { let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; let info = mock_info("owner", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); - let token_raw = deps.api.addr_canonicalize(&"asset".into()).unwrap(); + let token_raw = deps.api.addr_canonicalize("asset").unwrap(); let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap(); store_pool_info(&mut deps.storage, &token_raw, &pool_info).unwrap(); // bond 100 tokens let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { sender: "addr".into(), - amount: Uint128(100u128), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -84,9 +85,9 @@ fn test_deposit_reward() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; let info = mock_info("rewarder", &[]); @@ -99,7 +100,7 @@ fn test_deposit_reward() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -110,13 +111,13 @@ fn test_deposit_reward() { assert_eq!( res_cmp, PoolInfoResponse { - total_bond_amount: Uint128(100u128), + total_bond_amount: Uint128::from(100u128), reward_index: Decimal::from_ratio(100u128, 100u128), ..res } ); - let asset_key = deps.api.addr_canonicalize(&"asset".into()).unwrap(); + let asset_key = deps.api.addr_canonicalize("asset").unwrap(); let pool_info: PoolInfo = read_pool_info(&deps.storage, &asset_key).unwrap(); store_pool_info( &mut deps.storage, @@ -136,7 +137,7 @@ fn test_deposit_reward() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -147,7 +148,7 @@ fn test_deposit_reward() { assert_eq!( res_cmp, PoolInfoResponse { - total_bond_amount: Uint128(100u128), + total_bond_amount: Uint128::from(100u128), reward_index: Decimal::from_ratio(100u128, 100u128), ..res } @@ -156,17 +157,17 @@ fn test_deposit_reward() { #[test] fn test_deposit_reward_when_no_bonding() { - let mut deps = mock_dependencies(&[ + let mut deps = mock_dependencies_with_balance(&[ coin(10000000000u128, ORAI_DENOM), coin(20000000000u128, ATOM_DENOM), ]); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "rewarder".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("rewarder"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -176,7 +177,7 @@ fn test_deposit_reward_when_no_bonding() { // will also add to the index the pending rewards from before the migration let msg = ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -198,15 +199,15 @@ fn test_deposit_reward_when_no_bonding() { let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; let info = mock_info("owner", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); - let token_raw = deps.api.addr_canonicalize(&"asset".into()).unwrap(); + let token_raw = deps.api.addr_canonicalize("asset").unwrap(); let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap(); store_pool_info(&mut deps.storage, &token_raw, &pool_info).unwrap(); @@ -214,9 +215,9 @@ fn test_deposit_reward_when_no_bonding() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; let info = mock_info("rewarder", &[]); @@ -229,7 +230,7 @@ fn test_deposit_reward_when_no_bonding() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -241,12 +242,12 @@ fn test_deposit_reward_when_no_bonding() { res_cmp, PoolInfoResponse { reward_index: Decimal::zero(), - pending_reward: Uint128(100u128), + pending_reward: Uint128::from(100u128), ..res } ); - let asset_key = deps.api.addr_canonicalize(&"asset".into()).unwrap(); + let asset_key = deps.api.addr_canonicalize("asset").unwrap(); let pool_info: PoolInfo = read_pool_info(&deps.storage, &asset_key).unwrap(); store_pool_info( &mut deps.storage, @@ -266,7 +267,7 @@ fn test_deposit_reward_when_no_bonding() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -278,7 +279,7 @@ fn test_deposit_reward_when_no_bonding() { res_cmp, PoolInfoResponse { reward_index: Decimal::zero(), - pending_reward: Uint128(100u128), + pending_reward: Uint128::from(100u128), ..res } ); @@ -286,17 +287,17 @@ fn test_deposit_reward_when_no_bonding() { #[test] fn test_before_share_changes() { - let mut deps = mock_dependencies(&[ + let mut deps = mock_dependencies_with_balance(&[ coin(10000000000u128, ORAI_DENOM), coin(20000000000u128, ATOM_DENOM), ]); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "rewarder".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("rewarder"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -306,7 +307,7 @@ fn test_before_share_changes() { // will also add to the index the pending rewards from before the migration let msg = ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -328,28 +329,28 @@ fn test_before_share_changes() { let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; let info = mock_info("owner", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); - let token_raw = deps.api.addr_canonicalize(&"asset".into()).unwrap(); + let token_raw = deps.api.addr_canonicalize("asset").unwrap(); let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap(); store_pool_info(&mut deps.storage, &token_raw, &pool_info).unwrap(); // bond 100 tokens let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { sender: "addr".into(), - amount: Uint128(100u128), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -357,23 +358,23 @@ fn test_before_share_changes() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; let info = mock_info("rewarder", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); - let asset_key = deps.api.addr_canonicalize(&"asset".into()).unwrap(); - let addr_raw = deps.api.addr_canonicalize(&"addr".into()).unwrap(); + let asset_key = deps.api.addr_canonicalize("asset").unwrap(); + let addr_raw = deps.api.addr_canonicalize("addr").unwrap(); let reward_bucket = rewards_read(&deps.storage, &addr_raw); let reward_info: RewardInfo = reward_bucket.load(asset_key.as_slice()).unwrap(); assert_eq!( RewardInfo { pending_reward: Uint128::zero(), - bond_amount: Uint128(100u128), + bond_amount: Uint128::from(100u128), index: Decimal::zero(), native_token: false, pending_withdraw: vec![], @@ -384,13 +385,13 @@ fn test_before_share_changes() { // bond 100 more tokens let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { sender: "addr".into(), - amount: Uint128(100u128), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -399,8 +400,8 @@ fn test_before_share_changes() { let reward_info: RewardInfo = reward_bucket.load(asset_key.as_slice()).unwrap(); assert_eq!( RewardInfo { - pending_reward: Uint128(100u128), - bond_amount: Uint128(200u128), + pending_reward: Uint128::from(100u128), + bond_amount: Uint128::from(200u128), index: Decimal::from_ratio(100u128, 100u128), native_token: false, pending_withdraw: vec![], @@ -412,9 +413,9 @@ fn test_before_share_changes() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; let info = mock_info("rewarder", &[]); @@ -423,9 +424,9 @@ fn test_before_share_changes() { // unbond let msg = ExecuteMsg::Unbond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }; let info = mock_info("addr", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -434,8 +435,8 @@ fn test_before_share_changes() { let reward_info: RewardInfo = reward_bucket.load(asset_key.as_slice()).unwrap(); assert_eq!( RewardInfo { - pending_reward: Uint128(200u128), - bond_amount: Uint128(100u128), + pending_reward: Uint128::from(200u128), + bond_amount: Uint128::from(100u128), index: Decimal::from_ratio(150u128, 100u128), native_token: false, pending_withdraw: vec![], @@ -446,25 +447,27 @@ fn test_before_share_changes() { #[test] fn test_withdraw() { - let mut app = MockApp::new(); - - app.set_oracle_contract(oraiswap_oracle::testutils::contract()); - - app.set_token_contract(oraiswap_token::testutils::contract()); - - app.set_factory_and_pair_contract( - oraiswap_factory::testutils::contract(), - oraiswap_pair::testutils::contract(), - ); - - app.set_balance( - "addr".into(), + let mut app = MockApp::new(&[( + &"addr".to_string(), &[ coin(10000000000u128, ORAI_DENOM), coin(20000000000u128, ATOM_DENOM), ], - ); + )]); + + app.set_oracle_contract(Box::new(create_entry_points_testing!(oraiswap_oracle))); + app.set_token_contract(Box::new(create_entry_points_testing!(oraiswap_token))); + + app.set_factory_and_pair_contract( + Box::new( + create_entry_points_testing!(oraiswap_factory) + .with_reply(oraiswap_factory::contract::reply), + ), + Box::new( + create_entry_points_testing!(oraiswap_pair).with_reply(oraiswap_pair::contract::reply), + ), + ); let asset_addr = app.create_token("asset"); let reward_addr = app.create_token("reward"); @@ -481,28 +484,35 @@ fn test_withdraw() { ]); let msg = InstantiateMsg { - owner: Some("owner".into()), + owner: Some(Addr::unchecked("owner")), rewarder: reward_addr.clone(), - minter: Some("mint".into()), + minter: Some(Addr::unchecked("mint")), oracle_addr: app.oracle_addr.clone(), factory_addr: app.factory_addr.clone(), base_denom: None, }; - let code_id = app.upload(crate::testutils::contract()); + let code_id = app.upload(Box::new(create_entry_points_testing!(crate))); let staking_addr = app - .instantiate(code_id, "addr".into(), &msg, &[], "staking") + .instantiate(code_id, Addr::unchecked("addr"), &msg, &[], "staking") .unwrap(); // funding some balances to the staking contract from rewarder - app.set_balance( - staking_addr.clone(), + app.set_balances_from( + Addr::unchecked("addr"), &[ - coin(10000000000u128, ORAI_DENOM), - coin(20000000000u128, ATOM_DENOM), + ( + &ORAI_DENOM.to_string(), + &[(&staking_addr.to_string(), &Uint128::from(10000000000u128))], + ), + ( + &ATOM_DENOM.to_string(), + &[(&staking_addr.to_string(), &Uint128::from(20000000000u128))], + ), ], ); + app.set_token_balances(&[ ( &"reward".to_string(), @@ -542,7 +552,7 @@ fn test_withdraw() { }; let _res = app - .execute("owner".into(), staking_addr.clone(), &msg, &[]) + .execute(Addr::unchecked("owner"), staking_addr.clone(), &msg, &[]) .unwrap(); let lp_addr = app.create_token("lptoken"); @@ -555,19 +565,19 @@ fn test_withdraw() { }; let _res = app - .execute("owner".into(), staking_addr.clone(), &msg, &[]) + .execute(Addr::unchecked("owner"), staking_addr.clone(), &msg, &[]) .unwrap(); // bond 100 tokens let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { sender: "addr".into(), - amount: Uint128(100u128), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { contract_addr: asset_addr.clone(), }, }) - .ok(), + .unwrap(), }); let _res = app @@ -579,7 +589,7 @@ fn test_withdraw() { info: AssetInfo::Token { contract_addr: asset_addr.clone(), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; @@ -589,10 +599,10 @@ fn test_withdraw() { // set allowance app.execute( - "addr".into(), + Addr::unchecked("addr"), asset_addr.clone(), - &oraiswap_token::msg::ExecuteMsg::IncreaseAllowance { - spender: staking_addr.clone(), + &cw20::Cw20ExecuteMsg::IncreaseAllowance { + spender: staking_addr.to_string(), amount: Uint128::from(100u128), expires: None, }, @@ -607,7 +617,7 @@ fn test_withdraw() { }; let res = app - .execute("addr".into(), staking_addr.clone(), &msg, &[]) + .execute(Addr::unchecked("addr"), staking_addr.clone(), &msg, &[]) .unwrap(); println!("{:?}", res); @@ -615,17 +625,17 @@ fn test_withdraw() { #[test] fn test_update_rewards_per_sec() { - let mut deps = mock_dependencies(&[ + let mut deps = mock_dependencies_with_balance(&[ coin(10000000000u128, ORAI_DENOM), coin(20000000000u128, ATOM_DENOM), ]); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "rewarder".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("rewarder"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -635,7 +645,7 @@ fn test_update_rewards_per_sec() { // will also add to the index the pending rewards from before the migration let msg = ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -657,28 +667,28 @@ fn test_update_rewards_per_sec() { let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; let info = mock_info("owner", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); - let token_raw = deps.api.addr_canonicalize(&"asset".into()).unwrap(); + let token_raw = deps.api.addr_canonicalize("asset").unwrap(); let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap(); store_pool_info(&mut deps.storage, &token_raw, &pool_info).unwrap(); // bond 100 tokens let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { sender: "addr".into(), - amount: Uint128(300u128), + amount: Uint128::from(300u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -687,9 +697,9 @@ fn test_update_rewards_per_sec() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(300u128), + amount: Uint128::from(300u128), }], }; let info = mock_info("rewarder", &[]); @@ -702,7 +712,7 @@ fn test_update_rewards_per_sec() { mock_info("owner", &[]), ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -726,9 +736,9 @@ fn test_update_rewards_per_sec() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; let info = mock_info("rewarder", &[]); @@ -740,7 +750,7 @@ fn test_update_rewards_per_sec() { mock_env(), QueryMsg::RewardInfo { asset_info: None, - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), }, ) .unwrap(); @@ -748,25 +758,25 @@ fn test_update_rewards_per_sec() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - bond_amount: Uint128(300u128), - pending_reward: Uint128(99u128), + bond_amount: Uint128::from(300u128), + pending_reward: Uint128::from(99u128), pending_withdraw: vec![ Asset { info: AssetInfo::NativeToken { denom: ORAI_DENOM.to_string() }, - amount: Uint128(99) + amount: Uint128::from(99u128) }, Asset { info: AssetInfo::NativeToken { denom: ATOM_DENOM.to_string() }, - amount: Uint128(199) + amount: Uint128::from(199u128) } ], should_migrate: None, @@ -777,17 +787,17 @@ fn test_update_rewards_per_sec() { #[test] fn test_update_rewards_per_sec_with_multiple_bond() { - let mut deps = mock_dependencies(&[ + let mut deps = mock_dependencies_with_balance(&[ coin(10000000000u128, ORAI_DENOM), coin(20000000000u128, ATOM_DENOM), ]); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "rewarder".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("rewarder"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -797,7 +807,7 @@ fn test_update_rewards_per_sec_with_multiple_bond() { // will also add to the index the pending rewards from before the migration let msg = ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -819,28 +829,28 @@ fn test_update_rewards_per_sec_with_multiple_bond() { let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; let info = mock_info("owner", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); - let token_raw = deps.api.addr_canonicalize(&"asset".into()).unwrap(); + let token_raw = deps.api.addr_canonicalize("asset").unwrap(); let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap(); store_pool_info(&mut deps.storage, &token_raw, &pool_info).unwrap(); // bond 100 tokens let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { sender: "addr".into(), - amount: Uint128(300u128), + amount: Uint128::from(300u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -849,9 +859,9 @@ fn test_update_rewards_per_sec_with_multiple_bond() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(300u128), + amount: Uint128::from(300u128), }], }; let info = mock_info("rewarder", &[]); @@ -864,7 +874,7 @@ fn test_update_rewards_per_sec_with_multiple_bond() { mock_info("owner", &[]), ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -887,13 +897,13 @@ fn test_update_rewards_per_sec_with_multiple_bond() { // bond 100 tokens let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { sender: "addr1".into(), - amount: Uint128(300u128), + amount: Uint128::from(300u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -903,7 +913,7 @@ fn test_update_rewards_per_sec_with_multiple_bond() { mock_env(), QueryMsg::RewardInfo { asset_info: None, - staker_addr: "addr1".into(), + staker_addr: Addr::unchecked("addr1"), }, ) .unwrap(); @@ -911,12 +921,12 @@ fn test_update_rewards_per_sec_with_multiple_bond() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr1".into(), + staker_addr: Addr::unchecked("addr1"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - bond_amount: Uint128(300u128), + bond_amount: Uint128::from(300u128), pending_reward: Uint128::zero(), pending_withdraw: vec![], should_migrate: None, @@ -928,9 +938,9 @@ fn test_update_rewards_per_sec_with_multiple_bond() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], }; let info = mock_info("rewarder", &[]); @@ -942,7 +952,7 @@ fn test_update_rewards_per_sec_with_multiple_bond() { mock_env(), QueryMsg::RewardInfo { asset_info: None, - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), }, ) .unwrap(); @@ -950,25 +960,25 @@ fn test_update_rewards_per_sec_with_multiple_bond() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - bond_amount: Uint128(300u128), - pending_reward: Uint128(49u128), + bond_amount: Uint128::from(300u128), + pending_reward: Uint128::from(49u128), pending_withdraw: vec![ Asset { info: AssetInfo::NativeToken { denom: ORAI_DENOM.to_string() }, - amount: Uint128(99) + amount: Uint128::from(99u128) }, Asset { info: AssetInfo::NativeToken { denom: ATOM_DENOM.to_string() }, - amount: Uint128(199) + amount: Uint128::from(199u128) } ], should_migrate: None, @@ -982,7 +992,7 @@ fn test_update_rewards_per_sec_with_multiple_bond() { mock_env(), QueryMsg::RewardInfo { asset_info: None, - staker_addr: "addr1".into(), + staker_addr: Addr::unchecked("addr1"), }, ) .unwrap(); @@ -990,13 +1000,13 @@ fn test_update_rewards_per_sec_with_multiple_bond() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr1".into(), + staker_addr: Addr::unchecked("addr1"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - bond_amount: Uint128(300u128), - pending_reward: Uint128(49u128), + bond_amount: Uint128::from(300u128), + pending_reward: Uint128::from(49u128), pending_withdraw: vec![], should_migrate: None, },], diff --git a/contracts/oraiswap_staking/src/testing/staking_test.rs b/contracts/oraiswap_staking/src/testing/staking_test.rs index 9dee66c1..3b32d7f0 100644 --- a/contracts/oraiswap_staking/src/testing/staking_test.rs +++ b/contracts/oraiswap_staking/src/testing/staking_test.rs @@ -1,27 +1,31 @@ -use crate::contract::{handle, init, query}; -use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info}; +use crate::contract::{execute, instantiate, query}; +use cosmwasm_std::testing::{ + mock_dependencies, mock_dependencies_with_balance, mock_env, mock_info, +}; use cosmwasm_std::{ - attr, coin, from_binary, to_binary, BankMsg, Coin, CosmosMsg, Decimal, StdError, Uint128, - WasmMsg, + attr, coin, from_binary, to_binary, Addr, BankMsg, Coin, CosmosMsg, Decimal, StdError, SubMsg, + Uint128, WasmMsg, }; use cw20::{Cw20ExecuteMsg, Cw20ReceiveMsg}; -use oraiswap::asset::{Asset, AssetInfo, PairInfo, ORAI_DENOM}; -use oraiswap::mock_app::{MockApp, ATOM_DENOM}; +use oraiswap::asset::{Asset, AssetInfo, ORAI_DENOM}; +use oraiswap::create_entry_points_testing; +use oraiswap::pair::PairResponse; use oraiswap::staking::{ Cw20HookMsg, ExecuteMsg, InstantiateMsg, PoolInfoResponse, QueryMsg, RewardInfoResponse, RewardInfoResponseItem, }; +use oraiswap::testing::{MockApp, ATOM_DENOM}; #[test] fn test_bond_tokens() { - let mut deps = mock_dependencies(&[]); + let mut deps = mock_dependencies(); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "reward".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("rewarder"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -30,23 +34,23 @@ fn test_bond_tokens() { let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; let info = mock_info("owner", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { - sender: "addr".into(), - amount: Uint128(100u128), + sender: "addr".to_string(), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); @@ -56,9 +60,9 @@ fn test_bond_tokens() { mock_env(), QueryMsg::RewardInfo { asset_info: Some(AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }), - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), }, ) .unwrap(); @@ -66,14 +70,14 @@ fn test_bond_tokens() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), reward_infos: vec![RewardInfoResponseItem { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, pending_reward: Uint128::zero(), pending_withdraw: vec![], - bond_amount: Uint128(100u128), + bond_amount: Uint128::from(100u128), should_migrate: None, }], } @@ -84,7 +88,7 @@ fn test_bond_tokens() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -95,10 +99,10 @@ fn test_bond_tokens() { pool_info, PoolInfoResponse { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - staking_token: "staking".into(), - total_bond_amount: Uint128(100u128), + staking_token: Addr::unchecked("staking"), + total_bond_amount: Uint128::from(100u128), reward_index: Decimal::zero(), pending_reward: Uint128::zero(), migration_deprecated_staking_token: None, @@ -108,14 +112,14 @@ fn test_bond_tokens() { // bond 100 more tokens from other account let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { - sender: "addr2".into(), - amount: Uint128(100u128), + sender: "addr2".to_string(), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -125,7 +129,7 @@ fn test_bond_tokens() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -135,10 +139,10 @@ fn test_bond_tokens() { pool_info, PoolInfoResponse { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - staking_token: "staking".into(), - total_bond_amount: Uint128(200u128), + staking_token: Addr::unchecked("staking"), + total_bond_amount: Uint128::from(200u128), reward_index: Decimal::zero(), pending_reward: Uint128::zero(), migration_deprecated_staking_token: None, @@ -148,14 +152,14 @@ fn test_bond_tokens() { // failed with unauthorized let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { - sender: "addr".into(), - amount: Uint128(100u128), + sender: "addr".to_string(), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking2", &[]); @@ -168,17 +172,17 @@ fn test_bond_tokens() { #[test] fn test_unbond() { - let mut deps = mock_dependencies(&[ + let mut deps = mock_dependencies_with_balance(&[ coin(10000000000u128, ORAI_DENOM), coin(20000000000u128, ATOM_DENOM), ]); let msg = InstantiateMsg { - owner: Some("owner".into()), - rewarder: "rewarder".into(), - minter: Some("mint".into()), - oracle_addr: "oracle".into(), - factory_addr: "factory".into(), + owner: Some(Addr::unchecked("owner")), + rewarder: Addr::unchecked("rewarder"), + minter: Some(Addr::unchecked("mint")), + oracle_addr: Addr::unchecked("oracle"), + factory_addr: Addr::unchecked("factory"), base_denom: None, }; @@ -188,7 +192,7 @@ fn test_unbond() { // will also add to the index the pending rewards from before the migration let msg = ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -211,9 +215,9 @@ fn test_unbond() { // register asset let msg = ExecuteMsg::RegisterAsset { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), }; let info = mock_info("owner", &[]); @@ -221,14 +225,14 @@ fn test_unbond() { // bond 100 tokens let msg = ExecuteMsg::Receive(Cw20ReceiveMsg { - sender: "addr".into(), - amount: Uint128(100u128), + sender: "addr".to_string(), + amount: Uint128::from(100u128), msg: to_binary(&Cw20HookMsg::Bond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }) - .ok(), + .unwrap(), }); let info = mock_info("staking", &[]); let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap(); @@ -236,9 +240,9 @@ fn test_unbond() { let msg = ExecuteMsg::DepositReward { rewards: vec![Asset { info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(300u128), + amount: Uint128::from(300u128), }], }; let info = mock_info("rewarder", &[]); @@ -247,7 +251,7 @@ fn test_unbond() { // will also add to the index the pending rewards from before the migration let msg = ExecuteMsg::UpdateRewardsPerSec { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, assets: vec![ Asset { @@ -270,9 +274,9 @@ fn test_unbond() { // unbond 150 tokens; failed let msg = ExecuteMsg::Unbond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(150u128), + amount: Uint128::from(150u128), }; let info = mock_info("addr", &[]); @@ -287,9 +291,9 @@ fn test_unbond() { // normal unbond let msg = ExecuteMsg::Unbond { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }; let info = mock_info("addr", &[]); @@ -297,28 +301,23 @@ fn test_unbond() { assert_eq!( res.messages, vec![ - WasmMsg::Execute { - contract_addr: "staking".into(), + SubMsg::new(WasmMsg::Execute { + contract_addr: "staking".to_string(), msg: to_binary(&Cw20ExecuteMsg::Transfer { - recipient: "addr".into(), - amount: Uint128(100u128), + recipient: "addr".to_string(), + amount: Uint128::from(100u128), }) .unwrap(), - send: vec![], - } - .into(), - CosmosMsg::Bank(BankMsg::Send { - from_address: "cosmos2contract".into(), - to_address: "addr".into(), + funds: vec![], + }), + SubMsg::new(CosmosMsg::Bank(BankMsg::Send { + to_address: "addr".to_string(), amount: vec![coin(99u128, ORAI_DENOM)], - }) - .into(), - CosmosMsg::Bank(BankMsg::Send { - from_address: "cosmos2contract".into(), - to_address: "addr".into(), + })), + SubMsg::new(CosmosMsg::Bank(BankMsg::Send { + to_address: "addr".to_string(), amount: vec![coin(199u128, ATOM_DENOM)], - }) - .into() + })) ] ); @@ -327,7 +326,7 @@ fn test_unbond() { mock_env(), QueryMsg::PoolInfo { asset_info: AssetInfo::Token { - contract_addr: "asset".into(), + contract_addr: Addr::unchecked("asset"), }, }, ) @@ -337,9 +336,9 @@ fn test_unbond() { pool_info, PoolInfoResponse { asset_info: AssetInfo::Token { - contract_addr: "asset".into() + contract_addr: Addr::unchecked("asset") }, - staking_token: "staking".into(), + staking_token: Addr::unchecked("staking"), total_bond_amount: Uint128::zero(), reward_index: Decimal::from_ratio(300u128, 100u128), pending_reward: Uint128::zero(), @@ -353,7 +352,7 @@ fn test_unbond() { mock_env(), QueryMsg::RewardInfo { asset_info: None, - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), }, ) .unwrap(); @@ -361,7 +360,7 @@ fn test_unbond() { assert_eq!( res, RewardInfoResponse { - staker_addr: "addr".into(), + staker_addr: Addr::unchecked("addr"), reward_infos: vec![], } ); @@ -369,19 +368,22 @@ fn test_unbond() { #[test] fn test_auto_stake() { - let mut app = MockApp::new(); + let mut app = MockApp::new(&[(&"addr".to_string(), &[coin(10000000000u128, ORAI_DENOM)])]); - app.set_oracle_contract(oraiswap_oracle::testutils::contract()); + app.set_oracle_contract(Box::new(create_entry_points_testing!(oraiswap_oracle))); - app.set_token_contract(oraiswap_token::testutils::contract()); + app.set_token_contract(Box::new(create_entry_points_testing!(oraiswap_token))); app.set_factory_and_pair_contract( - oraiswap_factory::testutils::contract(), - oraiswap_pair::testutils::contract(), + Box::new( + create_entry_points_testing!(oraiswap_factory) + .with_reply(oraiswap_factory::contract::reply), + ), + Box::new( + create_entry_points_testing!(oraiswap_pair).with_reply(oraiswap_pair::contract::reply), + ), ); - app.set_balance("addr".into(), &[coin(10000000000u128, ORAI_DENOM)]); - let asset_addr = app.create_token("asset"); let reward_addr = app.create_token("reward"); // update other contract token balance @@ -408,16 +410,16 @@ fn test_auto_stake() { // create pair let pair_addr = app.create_pair(asset_infos.clone()).unwrap(); - let pair_info: PairInfo = app + let PairResponse { info: pair_info } = app .query(pair_addr.clone(), &oraiswap::pair::QueryMsg::Pair {}) .unwrap(); // set allowance app.execute( - "addr".into(), + Addr::unchecked("addr"), asset_addr.clone(), - &oraiswap_token::msg::ExecuteMsg::IncreaseAllowance { - spender: pair_addr.clone(), + &cw20::Cw20ExecuteMsg::IncreaseAllowance { + spender: pair_addr.to_string(), amount: Uint128::from(100u128), expires: None, }, @@ -448,7 +450,7 @@ fn test_auto_stake() { let _res = app .execute( - "addr".into(), + Addr::unchecked("addr"), pair_addr.clone(), &msg, &[Coin { @@ -458,27 +460,27 @@ fn test_auto_stake() { ) .unwrap(); - let code_id = app.upload(crate::testutils::contract()); + let code_id = app.upload(Box::new(create_entry_points_testing!(crate))); let msg = InstantiateMsg { - owner: Some("owner".into()), + owner: Some(Addr::unchecked("owner")), rewarder: reward_addr.clone(), - minter: Some("mint".into()), + minter: Some(Addr::unchecked("mint")), oracle_addr: app.oracle_addr.clone(), factory_addr: app.factory_addr.clone(), base_denom: None, }; let staking_addr = app - .instantiate(code_id, "addr".into(), &msg, &[], "staking") + .instantiate(code_id, Addr::unchecked("addr"), &msg, &[], "staking") .unwrap(); // set allowance app.execute( - "addr".into(), + Addr::unchecked("addr"), asset_addr.clone(), - &oraiswap_token::msg::ExecuteMsg::IncreaseAllowance { - spender: staking_addr.clone(), + &cw20::Cw20ExecuteMsg::IncreaseAllowance { + spender: staking_addr.to_string(), amount: Uint128::from(100u128), expires: None, }, @@ -494,7 +496,7 @@ fn test_auto_stake() { }; let _res = app - .execute("owner".into(), staking_addr.clone(), &msg, &[]) + .execute(Addr::unchecked("owner"), staking_addr.clone(), &msg, &[]) .unwrap(); // no token asset @@ -504,13 +506,13 @@ fn test_auto_stake() { info: AssetInfo::NativeToken { denom: ORAI_DENOM.to_string(), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }, Asset { info: AssetInfo::NativeToken { denom: ORAI_DENOM.to_string(), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }, ], slippage_tolerance: None, @@ -518,19 +520,16 @@ fn test_auto_stake() { let res = app .execute( - "addr".into(), + Addr::unchecked("addr"), staking_addr.clone(), &msg, &[Coin { denom: ORAI_DENOM.to_string(), - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], ) .unwrap_err(); - assert_eq!( - res, - StdError::generic_err("Missing token asset").to_string() - ); + assert_eq!(res.contains("error executing WasmMsg"), true); // no native asset let msg = ExecuteMsg::AutoStake { @@ -552,12 +551,9 @@ fn test_auto_stake() { }; let res = app - .execute("addr".into(), staking_addr.clone(), &msg, &[]) + .execute(Addr::unchecked("addr"), staking_addr.clone(), &msg, &[]) .unwrap_err(); - assert_eq!( - res, - StdError::generic_err("Missing native asset").to_string() - ); + assert_eq!(res.contains("error executing WasmMsg"), true); let msg = ExecuteMsg::AutoStake { assets: [ @@ -565,13 +561,13 @@ fn test_auto_stake() { info: AssetInfo::NativeToken { denom: ORAI_DENOM.to_string(), }, - amount: Uint128(100u128), + amount: Uint128::from(100u128), }, Asset { info: AssetInfo::Token { contract_addr: asset_addr.clone(), }, - amount: Uint128(1u128), + amount: Uint128::from(1u128), }, ], slippage_tolerance: None, @@ -579,24 +575,18 @@ fn test_auto_stake() { // attempt with no coins let res = app - .execute("addr".into(), staking_addr.clone(), &msg, &[]) + .execute(Addr::unchecked("addr"), staking_addr.clone(), &msg, &[]) .unwrap_err(); - assert_eq!( - res, - StdError::generic_err( - "Native token balance mismatch between the argument and the transferred" - ) - .to_string() - ); + assert_eq!(res.contains("error executing WasmMsg"), true); let _res = app .execute( - "addr".into(), + Addr::unchecked("addr"), staking_addr.clone(), &msg, &[Coin { denom: ORAI_DENOM.to_string(), - amount: Uint128(100u128), + amount: Uint128::from(100u128), }], ) .unwrap(); @@ -604,17 +594,17 @@ fn test_auto_stake() { // wrong asset let msg = ExecuteMsg::AutoStakeHook { asset_info: AssetInfo::Token { - contract_addr: "asset1".into(), + contract_addr: Addr::unchecked("asset1"), }, staking_token: pair_info.liquidity_token.clone(), - staker_addr: "addr".into(), - prev_staking_token_amount: Uint128(0), + staker_addr: Addr::unchecked("addr"), + prev_staking_token_amount: Uint128::zero(), }; let res = app .execute(staking_addr.clone(), staking_addr.clone(), &msg, &[]) .unwrap_err(); // pool not found error - assert_eq!(res.contains("PoolInfo not found"), true); + assert_eq!(res.contains("error executing WasmMsg"), true); // valid msg let msg = ExecuteMsg::AutoStakeHook { @@ -622,15 +612,15 @@ fn test_auto_stake() { contract_addr: asset_addr.clone(), }, staking_token: pair_info.liquidity_token.clone(), - staker_addr: "addr".into(), - prev_staking_token_amount: Uint128(0), + staker_addr: Addr::unchecked("addr"), + prev_staking_token_amount: Uint128::zero(), }; // unauthorized attempt let res = app - .execute("addr".into(), staking_addr.clone(), &msg, &[]) + .execute(Addr::unchecked("addr"), staking_addr.clone(), &msg, &[]) .unwrap_err(); - assert_eq!(res, StdError::generic_err("unauthorized").to_string()); + assert_eq!(res.contains("error executing WasmMsg"), true); // successfull attempt @@ -638,7 +628,8 @@ fn test_auto_stake() { .execute(staking_addr.clone(), staking_addr.clone(), &msg, &[]) .unwrap(); assert_eq!( - res.attributes, + // first attribute is _contract_addr + res.events[1].attributes[1..], vec![ attr("action", "bond"), attr("staker_addr", "addr"), @@ -665,7 +656,7 @@ fn test_auto_stake() { contract_addr: asset_addr.clone() }, staking_token: pair_info.liquidity_token.clone(), - total_bond_amount: Uint128(1u128), + total_bond_amount: Uint128::from(2u128), reward_index: Decimal::zero(), pending_reward: Uint128::zero(), migration_deprecated_staking_token: None, diff --git a/contracts/oraiswap_token/README.md b/contracts/oraiswap_token/README.md index 3c276af0..5d166e07 100644 --- a/contracts/oraiswap_token/README.md +++ b/contracts/oraiswap_token/README.md @@ -27,8 +27,8 @@ You can also import much of the logic of this contract to build another ERC20-contract, such as a bonding curve, overiding or extending what you need. -Basically, you just need to write your handle function and import -`cw20_base::contract::handle_transfer`, etc and dispatch to them. +Basically, you just need to write your execute function and import +`cw20_base::contract::execute_transfer`, etc and dispatch to them. This allows you to use custom `ExecuteMsg` and `QueryMsg` with your additional calls, but then use the underlying implementation for the standard cw20 messages you want to support. The same with `QueryMsg`. You _could_ reuse `init` diff --git a/packages/oraiswap/src/math.rs b/packages/oraiswap/src/math.rs index a048d2b3..3c8d4815 100644 --- a/packages/oraiswap/src/math.rs +++ b/packages/oraiswap/src/math.rs @@ -579,7 +579,7 @@ mod test { Decimal256::percent(4) ); - // Can handle 18 fractional digits + // Can execute 18 fractional digits assert_eq!( Decimal256::from_str("7.123456789012345678").unwrap(), Decimal256(7123456789012345678u64.into()) diff --git a/packages/oraiswap/src/testing.rs b/packages/oraiswap/src/testing.rs index 16141764..53518a76 100644 --- a/packages/oraiswap/src/testing.rs +++ b/packages/oraiswap/src/testing.rs @@ -1,12 +1,12 @@ use cosmwasm_std::{ - Addr, AllBalanceResponse, BalanceResponse, BankQuery, Coin, Decimal, Empty, QuerierWrapper, - QueryRequest, StdResult, Uint128, + coin, Addr, AllBalanceResponse, BalanceResponse, BankQuery, Coin, Decimal, Empty, + QuerierWrapper, QueryRequest, StdResult, Uint128, }; use serde::de::DeserializeOwned; use serde::Serialize; use std::collections::HashMap; -use crate::asset::{AssetInfo, PairInfo}; +use crate::asset::{AssetInfo, PairInfo, ORAI_DENOM}; use crate::pair::DEFAULT_COMMISSION_RATE; use cw_multi_test::{next_block, App, AppResponse, Contract, Executor}; @@ -36,6 +36,19 @@ pub struct MockApp { impl MockApp { pub fn new(init_balances: &[(&String, &[Coin])]) -> Self { let app = App::new(|router, _, storage| { + // init for App Owner a lot of balances + router + .bank + .init_balance( + storage, + &Addr::unchecked(APP_OWNER), + vec![ + coin(1000000000000000000u128, ORAI_DENOM), + coin(1000000000000000000u128, ATOM_DENOM), + ], + ) + .unwrap(); + for (owner, init_funds) in init_balances.iter() { router .bank @@ -301,6 +314,28 @@ impl MockApp { addr } + pub fn set_balances_from( + &mut self, + sender: Addr, + balances: &[(&String, &[(&String, &Uint128)])], + ) { + for (denom, balances) in balances.iter() { + // send for each recipient + for (recipient, &amount) in balances.iter() { + self.app + .send_tokens( + sender.clone(), + Addr::unchecked(recipient.as_str()), + &[Coin { + denom: denom.to_string(), + amount, + }], + ) + .unwrap(); + } + } + } + pub fn set_token_balances_from( &mut self, sender: Addr, @@ -330,6 +365,10 @@ impl MockApp { } } + pub fn set_balances(&mut self, balances: &[(&String, &[(&String, &Uint128)])]) { + self.set_balances_from(Addr::unchecked(APP_OWNER), balances) + } + // configure the mint whitelist mock querier pub fn set_token_balances(&mut self, balances: &[(&String, &[(&String, &Uint128)])]) { self.set_token_balances_from(Addr::unchecked(APP_OWNER), balances)