From d584a98982f8914c7c1c6037520007c60f55bbaa Mon Sep 17 00:00:00 2001 From: orkunkl Date: Tue, 29 Jun 2021 10:37:37 +0300 Subject: [PATCH] cw20-staking: Upgrade to cw 0.15 --- Cargo.lock | 4 +- contracts/cw20-staking/Cargo.toml | 6 +- .../schema/allowance_response.json | 2 +- .../cw20-staking/schema/claims_response.json | 2 +- .../cw20-staking/schema/execute_msg.json | 2 +- contracts/cw20-staking/src/contract.rs | 131 +++++++++--------- 6 files changed, 71 insertions(+), 76 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 584882c79..506718c20 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -436,8 +436,8 @@ dependencies = [ name = "cw20-staking" version = "0.6.2" dependencies = [ - "cosmwasm-schema 0.14.1", - "cosmwasm-std 0.14.1", + "cosmwasm-schema 0.15.0", + "cosmwasm-std 0.15.0", "cw-controllers", "cw-storage-plus", "cw0", diff --git a/contracts/cw20-staking/Cargo.toml b/contracts/cw20-staking/Cargo.toml index c8b5064a0..9c3088d67 100644 --- a/contracts/cw20-staking/Cargo.toml +++ b/contracts/cw20-staking/Cargo.toml @@ -25,11 +25,11 @@ cw2 = { path = "../../packages/cw2", version = "0.6.2" } cw20 = { path = "../../packages/cw20", version = "0.6.2" } cw-controllers = { path = "../../packages/controllers", version = "0.6.2" } cw20-base = { path = "../../contracts/cw20-base", version = "0.6.2", features = ["library"] } -cosmwasm-std = { version = "0.14.0", features = ["staking"] } +cosmwasm-std = { version = "0.15.0", features = ["staking"] } cw-storage-plus = { path = "../../packages/storage-plus", version = "0.6.2", features = ["iterator"] } schemars = "0.8.1" serde = { version = "1.0.103", default-features = false, features = ["derive"] } -thiserror = { version = "1.0.20" } +thiserror = { version = "1.0.23" } [dev-dependencies] -cosmwasm-schema = { version = "0.14.0" } +cosmwasm-schema = { version = "0.15.0" } diff --git a/contracts/cw20-staking/schema/allowance_response.json b/contracts/cw20-staking/schema/allowance_response.json index a05443377..71b49adf1 100644 --- a/contracts/cw20-staking/schema/allowance_response.json +++ b/contracts/cw20-staking/schema/allowance_response.json @@ -62,7 +62,7 @@ ] }, "Timestamp": { - "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.", + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", "allOf": [ { "$ref": "#/definitions/Uint64" diff --git a/contracts/cw20-staking/schema/claims_response.json b/contracts/cw20-staking/schema/claims_response.json index 6f0bb0f4c..d42c52e35 100644 --- a/contracts/cw20-staking/schema/claims_response.json +++ b/contracts/cw20-staking/schema/claims_response.json @@ -76,7 +76,7 @@ ] }, "Timestamp": { - "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.", + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", "allOf": [ { "$ref": "#/definitions/Uint64" diff --git a/contracts/cw20-staking/schema/execute_msg.json b/contracts/cw20-staking/schema/execute_msg.json index 8ec4253aa..63ec318ca 100644 --- a/contracts/cw20-staking/schema/execute_msg.json +++ b/contracts/cw20-staking/schema/execute_msg.json @@ -360,7 +360,7 @@ ] }, "Timestamp": { - "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.", + "description": "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```", "allOf": [ { "$ref": "#/definitions/Uint64" diff --git a/contracts/cw20-staking/src/contract.rs b/contracts/cw20-staking/src/contract.rs index 834c1bc91..11241b6e1 100644 --- a/contracts/cw20-staking/src/contract.rs +++ b/contracts/cw20-staking/src/contract.rs @@ -2,7 +2,8 @@ use cosmwasm_std::entry_point; use cosmwasm_std::{ attr, coin, to_binary, Addr, BankMsg, Binary, Decimal, Deps, DepsMut, DistributionMsg, Env, - MessageInfo, QuerierWrapper, Response, StakingMsg, StdError, StdResult, Uint128, WasmMsg, + MessageInfo, QuerierWrapper, Response, StakingMsg, StdError, StdResult, SubMsg, Uint128, + WasmMsg, }; use cw2::set_contract_version; @@ -47,7 +48,7 @@ pub fn instantiate( name: msg.name, symbol: msg.symbol, decimals: msg.decimals, - total_supply: Uint128(0), + total_supply: Uint128::zero(), // set self as minter, so we can properly execute mint and burn mint: Some(MinterData { minter: env.contract.address, @@ -138,10 +139,10 @@ pub fn execute( fn get_bonded(querier: &QuerierWrapper, contract: &Addr) -> Result { let bonds = querier.query_all_delegations(contract)?; if bonds.is_empty() { - return Ok(Uint128(0)); + return Ok(Uint128::zero()); } let denom = bonds[0].amount.denom.as_str(); - bonds.iter().fold(Ok(Uint128(0)), |racc, d| { + bonds.iter().fold(Ok(Uint128::zero()), |racc, d| { let acc = racc?; if d.amount.denom.as_str() != denom { Err(ContractError::DifferentBondDenom { @@ -204,18 +205,17 @@ pub fn bond(deps: DepsMut, env: Env, info: MessageInfo) -> Result Uint128(0) { + if tax > Uint128::zero() { let sub_info = MessageInfo { sender: env.contract.address.clone(), funds: vec![], @@ -284,18 +284,17 @@ pub fn unbond( // unbond them let res = Response { - submessages: vec![], - messages: vec![StakingMsg::Undelegate { + messages: vec![SubMsg::new(StakingMsg::Undelegate { validator: invest.validator, amount: coin(unbond.u128(), &invest.bond_denom), - } - .into()], + })], attributes: vec![ attr("action", "unbond"), attr("to", info.sender), attr("unbonded", unbond), attr("burnt", amount), ], + events: vec![], data: None, }; Ok(res) @@ -315,7 +314,7 @@ pub fn claim(deps: DepsMut, env: Env, info: MessageInfo) -> Result Result Result { assert_eq!(validator.as_str(), DEFAULT_VALIDATOR); assert_eq!(amount, &coin(1000, "ustake")); @@ -651,17 +646,17 @@ mod tests { } // bob got 1000 DRV for 1000 stake at a 1.0 ratio - assert_eq!(get_balance(deps.as_ref(), &bob), Uint128(1000)); + assert_eq!(get_balance(deps.as_ref(), &bob), Uint128::new(1000)); // investment info correct (updated supply) let invest = query_investment(deps.as_ref()).unwrap(); - assert_eq!(invest.token_supply, Uint128(1000)); + assert_eq!(invest.token_supply, Uint128::new(1000)); assert_eq!(invest.staked_tokens, coin(1000, "ustake")); assert_eq!(invest.nominal_value, Decimal::one()); // token info also properly updated let token = query_token_info(deps.as_ref()).unwrap(); - assert_eq!(token.total_supply, Uint128(1000)); + assert_eq!(token.total_supply, Uint128::new(1000)); } #[test] @@ -699,7 +694,7 @@ mod tests { // we should now see 1000 issues and 1500 bonded (and a price of 1.5) let invest = query_investment(deps.as_ref()).unwrap(); - assert_eq!(invest.token_supply, Uint128(1000)); + assert_eq!(invest.token_supply, Uint128::new(1000)); assert_eq!(invest.staked_tokens, coin(1500, "ustake")); let ratio = Decimal::from_str("1.5").unwrap(); assert_eq!(invest.nominal_value, ratio); @@ -715,10 +710,10 @@ mod tests { set_delegation(&mut deps.querier, 3000, "ustake"); // alice should have gotten 2000 DRV for the 3000 stake, keeping the ratio at 1.5 - assert_eq!(get_balance(deps.as_ref(), &alice), Uint128(2000)); + assert_eq!(get_balance(deps.as_ref(), &alice), Uint128::new(2000)); let invest = query_investment(deps.as_ref()).unwrap(); - assert_eq!(invest.token_supply, Uint128(3000)); + assert_eq!(invest.token_supply, Uint128::new(3000)); assert_eq!(invest.staked_tokens, coin(4500, "ustake")); assert_eq!(invest.nominal_value, ratio); } @@ -788,7 +783,7 @@ mod tests { // creator now tries to unbond these tokens - this must fail let unbond_msg = ExecuteMsg::Unbond { - amount: Uint128(600), + amount: Uint128::new(600), }; let info = mock_info(&creator, &[]); let err = execute(deps.as_mut(), mock_env(), info, unbond_msg).unwrap_err(); @@ -805,17 +800,17 @@ mod tests { // 60 are taken and send to the owner // 540 are unbonded in exchange for 540 * 1.5 = 810 native tokens let unbond_msg = ExecuteMsg::Unbond { - amount: Uint128(600), + amount: Uint128::new(600), }; - let owner_cut = Uint128(60); - let bobs_claim = Uint128(810); - let bobs_balance = Uint128(400); + let owner_cut = Uint128::new(60); + let bobs_claim = Uint128::new(810); + let bobs_balance = Uint128::new(400); let env = mock_env(); let info = mock_info(&bob, &[]); let res = execute(deps.as_mut(), env.clone(), info, unbond_msg).unwrap(); assert_eq!(1, res.messages.len()); let delegate = &res.messages[0]; - match delegate { + match &delegate.msg { CosmosMsg::Staking(StakingMsg::Undelegate { validator, amount }) => { assert_eq!(validator.as_str(), DEFAULT_VALIDATOR); assert_eq!(amount, &coin(bobs_claim.u128(), "ustake")); @@ -864,7 +859,7 @@ mod tests { // unbond part of them let unbond_msg = ExecuteMsg::Unbond { - amount: Uint128(600), + amount: Uint128::new(600), }; let env = mock_env(); let info = mock_info(&bob, &[]); @@ -872,7 +867,7 @@ mod tests { set_delegation(&mut deps.querier, 460, "ustake"); // ensure claims are proper - let bobs_claim = Uint128(540); + let bobs_claim = Uint128::new(540); let original_claims = vec![Claim { amount: bobs_claim, release_at: (DAY * 3).after(&env.block), @@ -900,7 +895,7 @@ mod tests { let res = execute(deps.as_mut(), claim_ready, info, ExecuteMsg::Claim {}).unwrap(); assert_eq!(1, res.messages.len()); let payout = &res.messages[0]; - match payout { + match &payout.msg { CosmosMsg::Bank(BankMsg::Send { to_address, amount }) => { assert_eq!(amount, &coins(540, "ustake")); assert_eq!(to_address, &bob); @@ -933,62 +928,62 @@ mod tests { execute(deps.as_mut(), mock_env(), info, ExecuteMsg::Bond {}).unwrap(); // bob got 1000 DRV for 1000 stake at a 1.0 ratio - assert_eq!(get_balance(deps.as_ref(), &bob), Uint128(1000)); + assert_eq!(get_balance(deps.as_ref(), &bob), Uint128::new(1000)); // send coins to carl let bob_info = mock_info(&bob, &[]); let transfer = ExecuteMsg::Transfer { recipient: carl.clone(), - amount: Uint128(200), + amount: Uint128::new(200), }; execute(deps.as_mut(), mock_env(), bob_info.clone(), transfer).unwrap(); - assert_eq!(get_balance(deps.as_ref(), &bob), Uint128(800)); - assert_eq!(get_balance(deps.as_ref(), &carl), Uint128(200)); + assert_eq!(get_balance(deps.as_ref(), &bob), Uint128::new(800)); + assert_eq!(get_balance(deps.as_ref(), &carl), Uint128::new(200)); // allow alice let allow = ExecuteMsg::IncreaseAllowance { spender: alice.clone(), - amount: Uint128(350), + amount: Uint128::new(350), expires: None, }; execute(deps.as_mut(), mock_env(), bob_info.clone(), allow).unwrap(); - assert_eq!(get_balance(deps.as_ref(), &bob), Uint128(800)); - assert_eq!(get_balance(deps.as_ref(), &alice), Uint128(0)); + assert_eq!(get_balance(deps.as_ref(), &bob), Uint128::new(800)); + assert_eq!(get_balance(deps.as_ref(), &alice), Uint128::zero()); assert_eq!( query_allowance(deps.as_ref(), bob.clone(), alice.clone()) .unwrap() .allowance, - Uint128(350) + Uint128::new(350) ); // alice takes some for herself let self_pay = ExecuteMsg::TransferFrom { owner: bob.clone(), recipient: alice.clone(), - amount: Uint128(250), + amount: Uint128::new(250), }; let alice_info = mock_info(&alice, &[]); execute(deps.as_mut(), mock_env(), alice_info, self_pay).unwrap(); - assert_eq!(get_balance(deps.as_ref(), &bob), Uint128(550)); - assert_eq!(get_balance(deps.as_ref(), &alice), Uint128(250)); + assert_eq!(get_balance(deps.as_ref(), &bob), Uint128::new(550)); + assert_eq!(get_balance(deps.as_ref(), &alice), Uint128::new(250)); assert_eq!( query_allowance(deps.as_ref(), bob.clone(), alice) .unwrap() .allowance, - Uint128(100) + Uint128::new(100) ); // burn some, but not too much let burn_too_much = ExecuteMsg::Burn { - amount: Uint128(1000), + amount: Uint128::new(1000), }; let failed = execute(deps.as_mut(), mock_env(), bob_info.clone(), burn_too_much); assert!(failed.is_err()); - assert_eq!(get_balance(deps.as_ref(), &bob), Uint128(550)); + assert_eq!(get_balance(deps.as_ref(), &bob), Uint128::new(550)); let burn = ExecuteMsg::Burn { - amount: Uint128(130), + amount: Uint128::new(130), }; execute(deps.as_mut(), mock_env(), bob_info, burn).unwrap(); - assert_eq!(get_balance(deps.as_ref(), &bob), Uint128(420)); + assert_eq!(get_balance(deps.as_ref(), &bob), Uint128::new(420)); } }