feat(contract): add contract enabled switch

contract/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "meta-names-contract"
-version = "0.5.0"
+version = "0.6.0"
 authors = ["Yeboster"]
 edition = "2021"
 

contract/src/contract.rs

@@ -68,6 +68,8 @@ pub fn transfer_from(
     to: Address,
     token_id: u128,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     let mut state = state;
     let mut nft_events = nft_actions::execute_transfer_from(
         &ctx,
@@ -94,6 +96,8 @@ pub fn transfer_domain(
     to: Address,
     domain: String,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     let token_id = state.pns.get_token_id(&domain);
     assert!(token_id.is_some(), "{}", ContractError::DomainNotMinted);
 
@@ -107,6 +111,8 @@ pub fn approve(
     approved: Option<Address>,
     token_id: u128,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     let mut state = state;
     let events = nft_actions::execute_approve(
         &ctx,
@@ -124,6 +130,8 @@ pub fn approve_domain(
     approved: Option<Address>,
     domain: String,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     assert!(
         state.pns.is_minted(&domain),
         "{}",
@@ -142,6 +150,8 @@ pub fn set_approval_for_all(
     operator: Address,
     approved: bool,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     let mut state = state;
     let events = nft_actions::execute_set_approval_for_all(
         &ctx,
@@ -161,6 +171,8 @@ pub fn mint(
     token_uri: Option<String>,
     parent_id: Option<String>,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     // Basic validations
     assert!(!state.pns.is_minted(&domain), "{}", ContractError::Minted);
 
@@ -221,6 +233,8 @@ pub fn on_mint_callback(
     state: ContractState,
     msg: MintMsg,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     assert_callback_success(&callback_ctx);
 
     action_mint(ctx, state, msg.domain, msg.to, msg.token_uri, msg.parent_id)
@@ -234,6 +248,8 @@ pub fn mint_record(
     class: RecordClass,
     data: Vec<u8>,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     let mut state = state;
     let events = pns_actions::execute_record_mint(
         &ctx,
@@ -256,6 +272,8 @@ pub fn update_record(
     class: RecordClass,
     data: Vec<u8>,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     let mut state = state;
     let events = pns_actions::execute_record_update(
         &ctx,
@@ -277,6 +295,8 @@ pub fn delete_record(
     domain: String,
     class: RecordClass,
 ) -> (ContractState, Vec<EventGroup>) {
+    assert_contract_enabled(&state);
+
     let mut state = state;
     let events = pns_actions::execute_record_delete(
         &ctx,
@@ -333,3 +353,11 @@ pub fn update_config(
 
     (state, vec![])
 }
+
+fn assert_contract_enabled(state: &ContractState) {
+    assert!(
+        state.config.contract_enabled,
+        "{}",
+        ContractError::ContractDisabled
+    );
+}

contract/src/error.rs

@@ -4,6 +4,9 @@ use thiserror::Error;
 /// This enum describes nft contract errors
 #[derive(Error, Debug)]
 pub enum ContractError {
+    #[error("The contract is disabled")]
+    ContractDisabled,
+
     #[error("The specified domain is not minted")]
     DomainNotMinted,
 

contract/src/state.rs

@@ -41,10 +41,11 @@ pub enum UserRole {
 
 #[derive(ReadWriteRPC, ReadWriteState, CreateTypeSpec, PartialEq, Eq, Default, Clone, Debug)]
 pub struct ContractConfig {
-    pub whitelist_enabled: bool,
+    pub contract_enabled: bool,
     pub mint_count_limit_enabled: bool,
     pub mint_count_limit: u32,
     pub payable_mint_info: PayableMintInfo,
+    pub whitelist_enabled: bool,
 }
 
 #[derive(ReadWriteState, CreateTypeSpec, PartialEq, Eq, Default, Clone, Debug)]

contract/tests/cucumber.rs

@@ -30,6 +30,7 @@ fn get_address_for_user(user: String) -> u8 {
     match user.as_str() {
         "Alice" => ALICE_ADDRESS,
         "Bob" => BOB_ADDRESS,
+        "contract" => SYSTEM_ADDRESS,
         _ => panic!("Unknown user"),
     }
 }
@@ -62,6 +63,7 @@ fn get_record_class_given(class: String) -> RecordClass {
 #[given(regex = "a meta names contract")]
 fn meta_names_contract(world: &mut ContractWorld) {
     let config = ContractConfig {
+        contract_enabled: true,
         payable_mint_info: PayableMintInfo {
             token: Some(mock_address(PAYABLE_TOKEN_ADDRESS)),
             receiver: Some(mock_address(ALICE_ADDRESS)),
@@ -86,6 +88,11 @@ fn meta_names_contract(world: &mut ContractWorld) {
 fn update_contract_config(world: &mut ContractWorld, user: String, key: String, value: String) {
     let res = catch_unwind(|| {
         let new_config = match key.as_str() {
+            "contract_enabled" => {
+                let mut new_config = world.state.config.clone();
+                new_config.contract_enabled = value == "true";
+                new_config
+            }
             "whitelist_enabled" => {
                 let mut new_config = world.state.config.clone();
                 new_config.whitelist_enabled = value == "true";

contract/tests/features/mint.feature

@@ -6,6 +6,13 @@ Feature: Mint feature
     When Alice mints 'meta.name' domain without fees and a parent
     Then Alice owns 'meta.name' domain
 
+  Scenario: The mint does not occur when the contract is disabled
+    Given a meta names contract
+    And Alice user with the admin role
+    And contract config 'contract_enabled' is 'false'
+    When Alice mints 'meta.name' domain without a parent
+    Then 'meta.name' domain is not minted
+
   Scenario: The minting process of a domain without any parent, carried out by an administrator user, is executed correctly
     Given a meta names contract
     And Alice user with the admin role