From df0b0367a4979f51f4d968558c5808908d625f2b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jon=20H=C3=A4ggblad?= Date: Tue, 11 Apr 2023 10:39:03 +0200 Subject: [PATCH] Rename service provider owner to announcer (#3290) --- .../service-provider-directory/src/events.rs | 2 +- .../service-provider-directory/src/msg.rs | 4 +- .../service-provider-directory/src/types.rs | 2 +- .../src/constants.rs | 4 +- .../src/contract.rs | 20 +- .../src/contract/execute.rs | 24 +-- .../src/contract/query.rs | 4 +- .../service-provider-directory/src/error.rs | 6 +- .../src/integration_tests.rs | 172 ++++++++++-------- .../src/state/services.rs | 32 ++-- .../src/test_helpers/fixture.rs | 12 +- .../src/test_helpers/helpers.rs | 6 +- .../src/test_helpers/test_setup.rs | 26 ++- 13 files changed, 175 insertions(+), 139 deletions(-) diff --git a/common/cosmwasm-smart-contracts/service-provider-directory/src/events.rs b/common/cosmwasm-smart-contracts/service-provider-directory/src/events.rs index 05cb644984..545f0b3267 100644 --- a/common/cosmwasm-smart-contracts/service-provider-directory/src/events.rs +++ b/common/cosmwasm-smart-contracts/service-provider-directory/src/events.rs @@ -41,7 +41,7 @@ pub fn new_announce_event(service_id: ServiceId, service: Service) -> Event { .add_attribute(SERVICE_ID, service_id.to_string()) .add_attribute(SERVICE_TYPE, service.service_type.to_string()) .add_attribute(NYM_ADDRESS, service.nym_address.to_string()) - .add_attribute(OWNER, service.owner.to_string()) + .add_attribute(OWNER, service.announcer.to_string()) } pub fn new_delete_id_event(service_id: ServiceId, service: Service) -> Event { diff --git a/common/cosmwasm-smart-contracts/service-provider-directory/src/msg.rs b/common/cosmwasm-smart-contracts/service-provider-directory/src/msg.rs index 7635575a16..0cfbb0f467 100644 --- a/common/cosmwasm-smart-contracts/service-provider-directory/src/msg.rs +++ b/common/cosmwasm-smart-contracts/service-provider-directory/src/msg.rs @@ -48,8 +48,8 @@ pub enum QueryMsg { ServiceId { service_id: ServiceId, }, - Owner { - owner: Addr, + Announcer { + announcer: Addr, }, NymAddress { nym_address: NymAddress, diff --git a/common/cosmwasm-smart-contracts/service-provider-directory/src/types.rs b/common/cosmwasm-smart-contracts/service-provider-directory/src/types.rs index 40c5bd31c1..0b576c6adf 100644 --- a/common/cosmwasm-smart-contracts/service-provider-directory/src/types.rs +++ b/common/cosmwasm-smart-contracts/service-provider-directory/src/types.rs @@ -13,7 +13,7 @@ pub struct Service { /// The service type. pub service_type: ServiceType, /// Service owner. - pub owner: Addr, + pub announcer: Addr, /// Block height at which the service was added. pub block_height: u64, /// The deposit used to announce the service. diff --git a/contracts/service-provider-directory/src/constants.rs b/contracts/service-provider-directory/src/constants.rs index 9828160083..ded70c2592 100644 --- a/contracts/service-provider-directory/src/constants.rs +++ b/contracts/service-provider-directory/src/constants.rs @@ -1,5 +1,5 @@ // We limit the these for simplicity and to avoid having to deal with paging. -pub const MAX_NUMBER_OF_PROVIDERS_PER_OWNER: u32 = 100; +pub const MAX_NUMBER_OF_PROVIDERS_PER_ANNOUNCER: u32 = 100; pub const MAX_NUMBER_OF_ALIASES_FOR_NYM_ADDRESS: u32 = 100; pub const SERVICE_DEFAULT_RETRIEVAL_LIMIT: u32 = 100; @@ -11,5 +11,5 @@ pub const ADMIN_KEY: &str = "admin"; pub const SERVICE_ID_COUNTER_KEY: &str = "sidc"; pub const SERVICES_PK_NAMESPACE: &str = "sernames"; -pub const SERVICES_OWNER_IDX_NAMESPACE: &str = "serown"; +pub const SERVICES_ANNOUNCER_IDX_NAMESPACE: &str = "serown"; pub const SERVICES_NYM_ADDRESS_IDX_NAMESPACE: &str = "sernyma"; diff --git a/contracts/service-provider-directory/src/contract.rs b/contracts/service-provider-directory/src/contract.rs index 39f8ee78f3..bd4be86a52 100644 --- a/contracts/service-provider-directory/src/contract.rs +++ b/contracts/service-provider-directory/src/contract.rs @@ -88,7 +88,7 @@ pub fn execute( pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> Result { let response = match msg { QueryMsg::ServiceId { service_id } => to_binary(&query::query_id(deps, service_id)?), - QueryMsg::Owner { owner } => to_binary(&query::query_owner(deps, owner)?), + QueryMsg::Announcer { announcer } => to_binary(&query::query_announcer(deps, announcer)?), QueryMsg::NymAddress { nym_address } => { to_binary(&query::query_nym_address(deps, nym_address)?) } @@ -153,13 +153,13 @@ mod tests { // Announce let msg: ExecuteMsg = service_fixture().into(); - let owner = service_fixture().owner.to_string(); + let announcer = service_fixture().announcer.to_string(); assert_eq!( execute( deps.as_mut(), mock_env(), - mock_info(&owner, &[nyms(99)]), + mock_info(&announcer, &[nyms(99)]), msg.clone() ) .unwrap_err(), @@ -173,7 +173,7 @@ mod tests { execute( deps.as_mut(), mock_env(), - mock_info(&owner, &[nyms(101)]), + mock_info(&announcer, &[nyms(101)]), msg ) .unwrap_err(), @@ -231,7 +231,7 @@ mod tests { // Announce let msg: ExecuteMsg = service_fixture().into(); let info_steve = mock_info("steve", &[nyms(100)]); - assert_eq!(info_steve.sender, service_fixture().owner); + assert_eq!(info_steve.sender, service_fixture().announcer); execute(deps.as_mut(), mock_env(), info_steve, msg).unwrap(); // The expected announced service @@ -254,20 +254,20 @@ mod tests { // Removing an non-existent service will fail let msg = ExecuteMsg::delete_id(expected_id + 1); - let info_owner = MessageInfo { - sender: service_fixture().owner, + let info_announcer = MessageInfo { + sender: service_fixture().announcer, funds: vec![], }; assert_eq!( - execute(deps.as_mut(), mock_env(), info_owner.clone(), msg).unwrap_err(), + execute(deps.as_mut(), mock_env(), info_announcer.clone(), msg).unwrap_err(), ContractError::NotFound { service_id: expected_id + 1 } ); - // Remove as correct owner succeeds + // Remove as correct announcer succeeds let msg = ExecuteMsg::delete_id(expected_id); - let res = execute(deps.as_mut(), mock_env(), info_owner, msg).unwrap(); + let res = execute(deps.as_mut(), mock_env(), info_announcer, msg).unwrap(); assert_eq!( get_attribute(&res, "delete_id", "service_id"), expected_id.to_string() diff --git a/contracts/service-provider-directory/src/contract/execute.rs b/contracts/service-provider-directory/src/contract/execute.rs index daa67681bf..427688f105 100644 --- a/contracts/service-provider-directory/src/contract/execute.rs +++ b/contracts/service-provider-directory/src/contract/execute.rs @@ -1,5 +1,5 @@ use crate::{ - constants::{MAX_NUMBER_OF_ALIASES_FOR_NYM_ADDRESS, MAX_NUMBER_OF_PROVIDERS_PER_OWNER}, + constants::{MAX_NUMBER_OF_ALIASES_FOR_NYM_ADDRESS, MAX_NUMBER_OF_PROVIDERS_PER_ANNOUNCER}, error::{ContractError, Result}, state, }; @@ -25,14 +25,14 @@ fn ensure_correct_deposit(will_deposit: Uint128, deposit_required: Uint128) -> R } } -fn ensure_max_services_per_owner(deps: Deps, owner: Addr) -> Result<()> { - let current_entries = query::query_owner(deps, owner.clone())?; - if current_entries.services.len() < MAX_NUMBER_OF_PROVIDERS_PER_OWNER as usize { +fn ensure_max_services_per_announcer(deps: Deps, announcer: Addr) -> Result<()> { + let current_entries = query::query_announcer(deps, announcer.clone())?; + if current_entries.services.len() < MAX_NUMBER_OF_PROVIDERS_PER_ANNOUNCER as usize { Ok(()) } else { Err(ContractError::ReachedMaxProvidersForAdmin { - max_providers: MAX_NUMBER_OF_PROVIDERS_PER_OWNER, - owner, + max_providers: MAX_NUMBER_OF_PROVIDERS_PER_ANNOUNCER, + announcer, }) } } @@ -58,7 +58,7 @@ fn ensure_service_exists(deps: Deps, service_id: ServiceId) -> Result<()> { } fn ensure_sender_authorized(info: MessageInfo, service: &Service) -> Result<()> { - if info.sender == service.owner { + if info.sender == service.announcer { Ok(()) } else { Err(ContractError::Unauthorized { @@ -69,7 +69,7 @@ fn ensure_sender_authorized(info: MessageInfo, service: &Service) -> Result<()> fn return_deposit(service_to_delete: &Service) -> BankMsg { BankMsg::Send { - to_address: service_to_delete.owner.to_string(), + to_address: service_to_delete.announcer.to_string(), amount: vec![service_to_delete.deposit.clone()], } } @@ -82,7 +82,7 @@ pub fn announce( nym_address: NymAddress, service_type: ServiceType, ) -> Result { - ensure_max_services_per_owner(deps.as_ref(), info.sender.clone())?; + ensure_max_services_per_announcer(deps.as_ref(), info.sender.clone())?; ensure_max_aliases_per_nym_address(deps.as_ref(), nym_address.clone())?; let deposit_required = state::deposit_required(deps.storage)?; @@ -94,7 +94,7 @@ pub fn announce( let new_service = Service { nym_address, service_type, - owner: info.sender, + announcer: info.sender, block_height: env.block.height, deposit: Coin::new(will_deposit.u128(), denom), }; @@ -118,7 +118,7 @@ pub fn delete_id(deps: DepsMut, info: MessageInfo, service_id: ServiceId) -> Res } /// Delete an existing service by nym address. If there are multiple entries for a given nym -/// address then all entries with the matching owner will be attempted to removed. +/// address then all entries with the matching announcer will be attempted to removed. pub(crate) fn delete_nym_address( deps: DepsMut, info: MessageInfo, @@ -128,7 +128,7 @@ pub(crate) fn delete_nym_address( let services_to_delete = query::query_nym_address(deps.as_ref(), nym_address)?.services; for service_to_delete in services_to_delete { - if info.sender == service_to_delete.service.owner { + if info.sender == service_to_delete.service.announcer { state::services::remove(deps.storage, service_to_delete.service_id)?; let return_deposit_msg = return_deposit(&service_to_delete.service); response = response diff --git a/contracts/service-provider-directory/src/contract/query.rs b/contracts/service-provider-directory/src/contract/query.rs index abac378398..246aa81aa7 100644 --- a/contracts/service-provider-directory/src/contract/query.rs +++ b/contracts/service-provider-directory/src/contract/query.rs @@ -18,8 +18,8 @@ pub fn query_id(deps: Deps, service_id: ServiceId) -> Result { }) } -pub fn query_owner(deps: Deps, owner: Addr) -> Result { - let services = state::services::load_owner(deps.storage, owner)?; +pub fn query_announcer(deps: Deps, announcer: Addr) -> Result { + let services = state::services::load_announcer(deps.storage, announcer)?; Ok(ServicesListResponse::new(services)) } diff --git a/contracts/service-provider-directory/src/error.rs b/contracts/service-provider-directory/src/error.rs index 6c2f599f9a..8aca3d95f0 100644 --- a/contracts/service-provider-directory/src/error.rs +++ b/contracts/service-provider-directory/src/error.rs @@ -14,7 +14,7 @@ pub enum ContractError { #[error("service not found: {service_id}")] NotFound { service_id: ServiceId }, - #[error("{sender} is not owner of service")] + #[error("{sender} is not announcer of service")] Unauthorized { sender: Addr }, #[error("deposit required to announce service")] @@ -32,8 +32,8 @@ pub enum ContractError { deposit_required: cosmwasm_std::Uint128, }, - #[error("reached the max number of providers ({max_providers}) for owner {owner}")] - ReachedMaxProvidersForAdmin { max_providers: u32, owner: Addr }, + #[error("reached the max number of providers ({max_providers}) for announcer {announcer}")] + ReachedMaxProvidersForAdmin { max_providers: u32, announcer: Addr }, #[error("reached the max number of aliases ({max_aliases}) for nym address {0}", nym_address.to_string())] ReachedMaxAliasesForNymAddress { diff --git a/contracts/service-provider-directory/src/integration_tests.rs b/contracts/service-provider-directory/src/integration_tests.rs index 91ef85fc02..22f41e8d1a 100644 --- a/contracts/service-provider-directory/src/integration_tests.rs +++ b/contracts/service-provider-directory/src/integration_tests.rs @@ -40,15 +40,15 @@ fn announce_and_query_service() { ); // Announce a first service - let owner = Addr::unchecked("owner"); + let announcer = Addr::unchecked("announcer"); let nym_address = NymAddress::new("nymAddress"); assert_eq!(setup.contract_balance(), nyms(0)); - assert_eq!(setup.balance(&owner), nyms(250)); - setup.announce_net_req(nym_address.clone(), owner.clone()); + assert_eq!(setup.balance(&announcer), nyms(250)); + setup.announce_net_req(nym_address.clone(), announcer.clone()); - // Deposit is deposited to contract and deducted from owner's balance + // Deposit is deposited to contract and deducted from announcers's balance assert_eq!(setup.contract_balance(), nyms(100)); - assert_eq!(setup.balance(&owner), nyms(150)); + assert_eq!(setup.balance(&announcer), nyms(150)); // We can query the full service list assert_eq!( @@ -59,7 +59,7 @@ fn announce_and_query_service() { service: Service { nym_address: nym_address.clone(), service_type: ServiceType::NetworkRequester, - owner: owner.clone(), + announcer: announcer.clone(), block_height: 12345, deposit: nyms(100), }, @@ -77,7 +77,7 @@ fn announce_and_query_service() { service: Service { nym_address: nym_address.clone(), service_type: ServiceType::NetworkRequester, - owner: owner.clone(), + announcer: announcer.clone(), block_height: 12345, deposit: nyms(100), }, @@ -85,17 +85,17 @@ fn announce_and_query_service() { ); // Announce a second service - let owner2 = Addr::unchecked("owner2"); + let announcer2 = Addr::unchecked("announcer2"); let nym_address2 = NymAddress::new("nymAddress2"); - setup.announce_net_req(nym_address2.clone(), owner2.clone()); + setup.announce_net_req(nym_address2.clone(), announcer2.clone()); assert_eq!(setup.contract_balance(), nyms(200)); assert_eq!( setup.query_all(), PagedServicesListResponse { services: vec![ - service_info(1, nym_address, owner), - service_info(2, nym_address2, owner2) + service_info(1, nym_address, announcer), + service_info(2, nym_address2, announcer2) ], per_page: SERVICE_DEFAULT_RETRIEVAL_LIMIT as usize, start_next_after: Some(2), @@ -106,28 +106,28 @@ fn announce_and_query_service() { #[test] fn delete_service() { let mut setup = TestSetup::new(); - setup.announce_net_req(NymAddress::new("nymAddress"), Addr::unchecked("owner")); + setup.announce_net_req(NymAddress::new("nymAddress"), Addr::unchecked("announcer")); assert_eq!(setup.contract_balance(), nyms(100)); - assert_eq!(setup.balance("owner"), nyms(150)); + assert_eq!(setup.balance("announcer"), nyms(150)); assert!(!setup.query_all().services.is_empty()); - setup.delete(1, Addr::unchecked("owner")); + setup.delete(1, Addr::unchecked("announcer")); - // Deleting the service returns the deposit to the owner + // Deleting the service returns the deposit to the announcer assert_eq!(setup.contract_balance(), nyms(0)); - assert_eq!(setup.balance("owner"), nyms(250)); + assert_eq!(setup.balance("announcer"), nyms(250)); assert!(setup.query_all().services.is_empty()); } #[test] -fn only_owner_can_delete_service() { +fn only_announcer_can_delete_service() { let mut setup = TestSetup::new(); assert_eq!(setup.contract_balance(), nyms(0)); - setup.announce_net_req(NymAddress::new("nymAddress"), Addr::unchecked("owner")); + setup.announce_net_req(NymAddress::new("nymAddress"), Addr::unchecked("announcer")); assert_eq!(setup.contract_balance(), nyms(100)); assert!(!setup.query_all().services.is_empty()); let delete_resp: ContractError = setup - .try_delete(1, Addr::unchecked("not_owner")) + .try_delete(1, Addr::unchecked("not_announcer")) .unwrap_err() .downcast() .unwrap(); @@ -136,7 +136,7 @@ fn only_owner_can_delete_service() { assert_eq!( delete_resp, ContractError::Unauthorized { - sender: Addr::unchecked("not_owner") + sender: Addr::unchecked("not_announcer") } ); } @@ -144,12 +144,12 @@ fn only_owner_can_delete_service() { #[test] fn cant_delete_service_that_does_not_exist() { let mut setup = TestSetup::new(); - setup.announce_net_req(NymAddress::new("nymAddress"), Addr::unchecked("owner")); + setup.announce_net_req(NymAddress::new("nymAddress"), Addr::unchecked("announcer")); assert_eq!(setup.contract_balance(), nyms(100)); assert!(!setup.query_all().services.is_empty()); let delete_resp: ContractError = setup - .try_delete(0, Addr::unchecked("owner")) + .try_delete(0, Addr::unchecked("announcer")) .unwrap_err() .downcast() .unwrap(); @@ -157,7 +157,7 @@ fn cant_delete_service_that_does_not_exist() { assert_eq!(delete_resp, ContractError::NotFound { service_id: 0 }); let delete_resp: ContractError = setup - .try_delete(2, Addr::unchecked("owner")) + .try_delete(2, Addr::unchecked("announcer")) .unwrap_err() .downcast() .unwrap(); @@ -165,7 +165,7 @@ fn cant_delete_service_that_does_not_exist() { assert_eq!(delete_resp, ContractError::NotFound { service_id: 2 }); assert!(!setup.query_all().services.is_empty()); - setup.delete(1, Addr::unchecked("owner")); + setup.delete(1, Addr::unchecked("announcer")); assert_eq!(setup.contract_balance(), nyms(0)); assert!(setup.query_all().services.is_empty()); } @@ -173,31 +173,31 @@ fn cant_delete_service_that_does_not_exist() { #[test] fn announce_multiple_services_and_deleting_by_name() { let mut setup = TestSetup::new(); - let owner1 = Addr::unchecked("wealthy_owner_1"); - let owner2 = Addr::unchecked("wealthy_owner_2"); + let announcer1 = Addr::unchecked("wealthy_announcer_1"); + let announcer2 = Addr::unchecked("wealthy_announcer_2"); let nym_address1 = NymAddress::new("nymAddress1"); let nym_address2 = NymAddress::new("nymAddress2"); - // We announce the same address three times, but with different owners + // We announce the same address three times, but with different annoucers assert_eq!(setup.contract_balance(), nyms(0)); - assert_eq!(setup.balance(&owner1), nyms(1000)); - setup.announce_net_req(nym_address1.clone(), owner1.clone()); - setup.announce_net_req(nym_address1.clone(), owner1.clone()); - setup.announce_net_req(nym_address2.clone(), owner1.clone()); - setup.announce_net_req(nym_address1.clone(), owner2.clone()); - setup.announce_net_req(nym_address2.clone(), owner2.clone()); + assert_eq!(setup.balance(&announcer1), nyms(1000)); + setup.announce_net_req(nym_address1.clone(), announcer1.clone()); + setup.announce_net_req(nym_address1.clone(), announcer1.clone()); + setup.announce_net_req(nym_address2.clone(), announcer1.clone()); + setup.announce_net_req(nym_address1.clone(), announcer2.clone()); + setup.announce_net_req(nym_address2.clone(), announcer2.clone()); assert_eq!(setup.contract_balance(), nyms(500)); - assert_eq!(setup.balance(&owner1), nyms(700)); + assert_eq!(setup.balance(&announcer1), nyms(700)); assert_eq!( setup.query_all(), PagedServicesListResponse { services: vec![ - service_info(1, nym_address1.clone(), owner1.clone()), - service_info(2, nym_address1.clone(), owner1.clone()), - service_info(3, nym_address2.clone(), owner1.clone()), - service_info(4, nym_address1.clone(), owner2.clone()), - service_info(5, nym_address2.clone(), owner2.clone()), + service_info(1, nym_address1.clone(), announcer1.clone()), + service_info(2, nym_address1.clone(), announcer1.clone()), + service_info(3, nym_address2.clone(), announcer1.clone()), + service_info(4, nym_address1.clone(), announcer2.clone()), + service_info(5, nym_address2.clone(), announcer2.clone()), ], per_page: SERVICE_DEFAULT_RETRIEVAL_LIMIT as usize, start_next_after: Some(5), @@ -206,17 +206,17 @@ fn announce_multiple_services_and_deleting_by_name() { // Even though multiple of them point to the same nym address, we only delete the ones we actually // own. - setup.delete_nym_address(nym_address1.clone(), owner1.clone()); + setup.delete_nym_address(nym_address1.clone(), announcer1.clone()); assert_eq!(setup.contract_balance(), nyms(300)); - assert_eq!(setup.balance(&owner1), nyms(900)); + assert_eq!(setup.balance(&announcer1), nyms(900)); assert_eq!( setup.query_all(), PagedServicesListResponse { services: vec![ - service_info(3, nym_address2.clone(), owner1), - service_info(4, nym_address1, owner2.clone()), - service_info(5, nym_address2, owner2), + service_info(3, nym_address2.clone(), announcer1), + service_info(4, nym_address1, announcer2.clone()), + service_info(5, nym_address2, announcer2), ], per_page: SERVICE_DEFAULT_RETRIEVAL_LIMIT as usize, start_next_after: Some(5), @@ -229,27 +229,27 @@ fn announce_multiple_services_and_deleting_by_name() { #[test] fn paging_works() { let mut setup = TestSetup::new(); - let owner1 = Addr::unchecked("wealthy_owner_1"); - let owner2 = Addr::unchecked("wealthy_owner_2"); + let announcer1 = Addr::unchecked("wealthy_announcer_1"); + let announcer2 = Addr::unchecked("wealthy_announcer_2"); let nym_address1 = NymAddress::new("nymAddress1"); let nym_address2 = NymAddress::new("nymAddress2"); - // We announce the same address three times, but with different owners - setup.announce_net_req(nym_address1.clone(), owner1.clone()); - setup.announce_net_req(nym_address1.clone(), owner1.clone()); - setup.announce_net_req(nym_address2.clone(), owner1.clone()); - setup.announce_net_req(nym_address1.clone(), owner2.clone()); - setup.announce_net_req(nym_address2.clone(), owner2.clone()); + // We announce the same address three times, but with different announcers + setup.announce_net_req(nym_address1.clone(), announcer1.clone()); + setup.announce_net_req(nym_address1.clone(), announcer1.clone()); + setup.announce_net_req(nym_address2.clone(), announcer1.clone()); + setup.announce_net_req(nym_address1.clone(), announcer2.clone()); + setup.announce_net_req(nym_address2.clone(), announcer2.clone()); assert_eq!( setup.query_all_with_limit(Some(10), None), PagedServicesListResponse { services: vec![ - service_info(1, nym_address1.clone(), owner1.clone()), - service_info(2, nym_address1.clone(), owner1.clone()), - service_info(3, nym_address2.clone(), owner1.clone()), - service_info(4, nym_address1.clone(), owner2.clone()), - service_info(5, nym_address2.clone(), owner2.clone()), + service_info(1, nym_address1.clone(), announcer1.clone()), + service_info(2, nym_address1.clone(), announcer1.clone()), + service_info(3, nym_address2.clone(), announcer1.clone()), + service_info(4, nym_address1.clone(), announcer2.clone()), + service_info(5, nym_address2.clone(), announcer2.clone()), ], per_page: 10, start_next_after: Some(5), @@ -260,9 +260,9 @@ fn paging_works() { setup.query_all_with_limit(Some(3), None), PagedServicesListResponse { services: vec![ - service_info(1, nym_address1.clone(), owner1.clone()), - service_info(2, nym_address1.clone(), owner1.clone()), - service_info(3, nym_address2.clone(), owner1.clone()), + service_info(1, nym_address1.clone(), announcer1.clone()), + service_info(2, nym_address1.clone(), announcer1.clone()), + service_info(3, nym_address2.clone(), announcer1.clone()), ], per_page: 3, start_next_after: Some(3), @@ -272,8 +272,8 @@ fn paging_works() { setup.query_all_with_limit(Some(3), Some(3)), PagedServicesListResponse { services: vec![ - service_info(4, nym_address1.clone(), owner2.clone()), - service_info(5, nym_address2.clone(), owner2.clone()), + service_info(4, nym_address1.clone(), announcer2.clone()), + service_info(5, nym_address2.clone(), announcer2.clone()), ], per_page: 3, start_next_after: Some(5), @@ -284,8 +284,14 @@ fn paging_works() { #[test] fn service_id_increases_for_new_services() { let mut setup = TestSetup::new(); - setup.announce_net_req(NymAddress::new("nymAddress1"), Addr::unchecked("owner1")); - setup.announce_net_req(NymAddress::new("nymAddress2"), Addr::unchecked("owner2")); + setup.announce_net_req( + NymAddress::new("nymAddress1"), + Addr::unchecked("announcer1"), + ); + setup.announce_net_req( + NymAddress::new("nymAddress2"), + Addr::unchecked("announcer2"), + ); assert_eq!( setup @@ -301,29 +307,49 @@ fn service_id_increases_for_new_services() { #[test] fn service_id_is_not_resused_when_deleting_and_then_adding_a_new_service() { let mut setup = TestSetup::new(); - setup.announce_net_req(NymAddress::new("nymAddress1"), Addr::unchecked("owner1")); - setup.announce_net_req(NymAddress::new("nymAddress2"), Addr::unchecked("owner2")); - setup.announce_net_req(NymAddress::new("nymAddress3"), Addr::unchecked("owner3")); + setup.announce_net_req( + NymAddress::new("nymAddress1"), + Addr::unchecked("announcer1"), + ); + setup.announce_net_req( + NymAddress::new("nymAddress2"), + Addr::unchecked("announcer2"), + ); + setup.announce_net_req( + NymAddress::new("nymAddress3"), + Addr::unchecked("announcer3"), + ); - setup.delete(1, Addr::unchecked("owner1")); - setup.delete(3, Addr::unchecked("owner3")); + setup.delete(1, Addr::unchecked("announcer1")); + setup.delete(3, Addr::unchecked("announcer3")); assert_eq!( setup.query_all().services, vec![service_info( 2, NymAddress::new("nymAddress2"), - Addr::unchecked("owner2") + Addr::unchecked("announcer2") )] ); - setup.announce_net_req(NymAddress::new("nymAddress4"), Addr::unchecked("owner4")); + setup.announce_net_req( + NymAddress::new("nymAddress4"), + Addr::unchecked("announcer4"), + ); assert_eq!( setup.query_all().services, vec![ - service_info(2, NymAddress::new("nymAddress2"), Addr::unchecked("owner2")), - service_info(4, NymAddress::new("nymAddress4"), Addr::unchecked("owner4")) + service_info( + 2, + NymAddress::new("nymAddress2"), + Addr::unchecked("announcer2") + ), + service_info( + 4, + NymAddress::new("nymAddress4"), + Addr::unchecked("announcer4") + ) ] ); } diff --git a/contracts/service-provider-directory/src/state/services.rs b/contracts/service-provider-directory/src/state/services.rs index aded675b43..f658c0a3b3 100644 --- a/contracts/service-provider-directory/src/state/services.rs +++ b/contracts/service-provider-directory/src/state/services.rs @@ -4,21 +4,21 @@ use nym_service_provider_directory_common::{NymAddress, Service, ServiceId}; use crate::{ constants::{ - MAX_NUMBER_OF_ALIASES_FOR_NYM_ADDRESS, MAX_NUMBER_OF_PROVIDERS_PER_OWNER, - SERVICES_NYM_ADDRESS_IDX_NAMESPACE, SERVICES_OWNER_IDX_NAMESPACE, SERVICES_PK_NAMESPACE, - SERVICE_DEFAULT_RETRIEVAL_LIMIT, SERVICE_MAX_RETRIEVAL_LIMIT, + MAX_NUMBER_OF_ALIASES_FOR_NYM_ADDRESS, MAX_NUMBER_OF_PROVIDERS_PER_ANNOUNCER, + SERVICES_ANNOUNCER_IDX_NAMESPACE, SERVICES_NYM_ADDRESS_IDX_NAMESPACE, + SERVICES_PK_NAMESPACE, SERVICE_DEFAULT_RETRIEVAL_LIMIT, SERVICE_MAX_RETRIEVAL_LIMIT, }, error::{ContractError, Result}, }; struct ServiceIndex<'a> { pub(crate) nym_address: MultiIndex<'a, String, Service, ServiceId>, - pub(crate) owner: MultiIndex<'a, Addr, Service, ServiceId>, + pub(crate) announcer: MultiIndex<'a, Addr, Service, ServiceId>, } impl<'a> IndexList for ServiceIndex<'a> { fn get_indexes(&'_ self) -> Box> + '_> { - let v: Vec<&dyn Index> = vec![&self.nym_address, &self.owner]; + let v: Vec<&dyn Index> = vec![&self.nym_address, &self.announcer]; Box::new(v.into_iter()) } } @@ -30,10 +30,10 @@ fn services<'a>() -> IndexedMap<'a, ServiceId, Service, ServiceIndex<'a>> { SERVICES_PK_NAMESPACE, SERVICES_NYM_ADDRESS_IDX_NAMESPACE, ), - owner: MultiIndex::new( - |d| d.owner.clone(), + announcer: MultiIndex::new( + |d| d.announcer.clone(), SERVICES_PK_NAMESPACE, - SERVICES_OWNER_IDX_NAMESPACE, + SERVICES_ANNOUNCER_IDX_NAMESPACE, ), }; IndexedMap::new(SERVICES_PK_NAMESPACE, indexes) @@ -60,13 +60,13 @@ pub fn load_id(store: &dyn Storage, service_id: ServiceId) -> Result { }) } -pub fn load_owner(store: &dyn Storage, owner: Addr) -> Result> { +pub fn load_announcer(store: &dyn Storage, announcer: Addr) -> Result> { let services = services() .idx - .owner - .prefix(owner) + .announcer + .prefix(announcer) .range(store, None, None, Order::Ascending) - .take(MAX_NUMBER_OF_PROVIDERS_PER_OWNER as usize) + .take(MAX_NUMBER_OF_PROVIDERS_PER_ANNOUNCER as usize) .collect::>>()?; Ok(services) } @@ -173,13 +173,13 @@ mod tests { } #[test] - fn load_by_owner_works() { + fn load_by_announcer_works() { let mut deps = instantiate_test_contract(); save(deps.as_mut().storage, &service_fixture_with_address("a")).unwrap(); save(deps.as_mut().storage, &service_fixture_with_address("b")).unwrap(); save(deps.as_mut().storage, &service_fixture_with_address("c")).unwrap(); assert_eq!( - load_owner(&deps.storage, Addr::unchecked("steve")).unwrap(), + load_announcer(&deps.storage, Addr::unchecked("steve")).unwrap(), vec![ (1, service_fixture_with_address("a")), (2, service_fixture_with_address("b")), @@ -189,13 +189,13 @@ mod tests { } #[test] - fn load_by_wrong_owner_returns_empty() { + fn load_by_wrong_announcer_returns_empty() { let mut deps = instantiate_test_contract(); save(deps.as_mut().storage, &service_fixture_with_address("a")).unwrap(); save(deps.as_mut().storage, &service_fixture_with_address("b")).unwrap(); save(deps.as_mut().storage, &service_fixture_with_address("c")).unwrap(); assert_eq!( - load_owner(&deps.storage, Addr::unchecked("timmy")).unwrap(), + load_announcer(&deps.storage, Addr::unchecked("timmy")).unwrap(), vec![] ); } diff --git a/contracts/service-provider-directory/src/test_helpers/fixture.rs b/contracts/service-provider-directory/src/test_helpers/fixture.rs index f25eb4b51f..3310eb0024 100644 --- a/contracts/service-provider-directory/src/test_helpers/fixture.rs +++ b/contracts/service-provider-directory/src/test_helpers/fixture.rs @@ -9,7 +9,7 @@ pub fn service_fixture() -> Service { Service { nym_address: NymAddress::new("nym"), service_type: ServiceType::NetworkRequester, - owner: Addr::unchecked("steve"), + announcer: Addr::unchecked("steve"), block_height: 12345, deposit: nyms(100), } @@ -19,19 +19,23 @@ pub fn service_fixture_with_address(nym_address: &str) -> Service { Service { nym_address: NymAddress::new(nym_address), service_type: ServiceType::NetworkRequester, - owner: Addr::unchecked("steve"), + announcer: Addr::unchecked("steve"), block_height: 12345, deposit: nyms(100), } } -pub fn service_info(service_id: ServiceId, nym_address: NymAddress, owner: Addr) -> ServiceInfo { +pub fn service_info( + service_id: ServiceId, + nym_address: NymAddress, + announcer: Addr, +) -> ServiceInfo { ServiceInfo { service_id, service: Service { nym_address, service_type: ServiceType::NetworkRequester, - owner: owner, + announcer, block_height: 12345, deposit: nyms(100), }, diff --git a/contracts/service-provider-directory/src/test_helpers/helpers.rs b/contracts/service-provider-directory/src/test_helpers/helpers.rs index d056bce836..c34749d633 100644 --- a/contracts/service-provider-directory/src/test_helpers/helpers.rs +++ b/contracts/service-provider-directory/src/test_helpers/helpers.rs @@ -85,7 +85,7 @@ pub fn instantiate_test_contract() -> OwnedDeps, service: &Service) -> ServiceId { let msg: ExecuteMsg = service.clone().into(); - let info = mock_info(service.owner.as_str(), &coins(100, "unym")); + let info = mock_info(service.announcer.as_str(), &coins(100, "unym")); let res = crate::execute(deps, mock_env(), info, msg).unwrap(); let service_id: ServiceId = get_attribute( &res, @@ -97,8 +97,8 @@ pub fn announce_service(deps: DepsMut<'_>, service: &Service) -> ServiceId { service_id } -pub fn delete_service(deps: DepsMut<'_>, service_id: ServiceId, owner: &str) { +pub fn delete_service(deps: DepsMut<'_>, service_id: ServiceId, announcer: &str) { let msg = ExecuteMsg::DeleteId { service_id }; - let info = mock_info(owner, &[]); + let info = mock_info(announcer, &[]); crate::execute(deps, mock_env(), info, msg).unwrap(); } diff --git a/contracts/service-provider-directory/src/test_helpers/test_setup.rs b/contracts/service-provider-directory/src/test_helpers/test_setup.rs index ca7cc6d520..65f4f6353c 100644 --- a/contracts/service-provider-directory/src/test_helpers/test_setup.rs +++ b/contracts/service-provider-directory/src/test_helpers/test_setup.rs @@ -14,9 +14,15 @@ use crate::test_helpers::helpers::get_app_attribute; const DENOM: &str = "unym"; const ADDRESSES: &[&str] = &[ - "user", "admin", "owner", "owner1", "owner2", "owner3", "owner4", + "user", + "admin", + "announcer", + "announcer1", + "announcer2", + "announcer3", + "announcer4", ]; -const WEALTHY_ADDRESSES: &[&str] = &["wealthy_owner_1", "wealthy_owner_2"]; +const WEALTHY_ADDRESSES: &[&str] = &["wealthy_announcer_1", "wealthy_announcer_2"]; /// Helper for being able to systematic integration tests pub struct TestSetup { @@ -100,11 +106,11 @@ impl TestSetup { self.query(&QueryMsg::All { limit, start_after }) } - pub fn announce_net_req(&mut self, address: NymAddress, owner: Addr) -> AppResponse { + pub fn announce_net_req(&mut self, address: NymAddress, announcer: Addr) -> AppResponse { let resp = self .app .execute_contract( - owner, + announcer, self.addr.clone(), &ExecuteMsg::Announce { nym_address: address, @@ -123,17 +129,17 @@ impl TestSetup { resp } - pub fn try_delete(&mut self, service_id: ServiceId, owner: Addr) -> Result { + pub fn try_delete(&mut self, service_id: ServiceId, announcer: Addr) -> Result { self.app.execute_contract( - owner, + announcer, self.addr.clone(), &ExecuteMsg::DeleteId { service_id }, &[], ) } - pub fn delete(&mut self, service_id: ServiceId, owner: Addr) -> AppResponse { - let delete_resp = self.try_delete(service_id, owner).unwrap(); + pub fn delete(&mut self, service_id: ServiceId, announcer: Addr) -> AppResponse { + let delete_resp = self.try_delete(service_id, announcer).unwrap(); assert_eq!( get_app_attribute(&delete_resp, "wasm-delete_id", "action"), "delete_id" @@ -141,10 +147,10 @@ impl TestSetup { delete_resp } - pub fn delete_nym_address(&mut self, nym_address: NymAddress, owner: Addr) -> AppResponse { + pub fn delete_nym_address(&mut self, nym_address: NymAddress, announcer: Addr) -> AppResponse { self.app .execute_contract( - owner, + announcer, self.addr.clone(), &ExecuteMsg::DeleteNymAddress { nym_address }, &[],