feat(ADR-006): POAP v2

contracts/poap/src/contract_tests.rs

@@ -7,7 +7,7 @@ use crate::ExecuteMsg::{
     Approve, ApproveAll, Burn, Mint, MintTo, Revoke, RevokeAll, SendNft, SetMintStartEndTime,
     SetMintable, SetTransferable, TransferNft, UpdateMinter,
 };
-use crate::{ExecuteMsg, Extension, InstantiateMsg, PoapContract};
+use crate::{ContractError, ExecuteMsg, Extension, InstantiateMsg, PoapContract};
 use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
 use cosmwasm_std::{to_binary, Addr, CosmosMsg, Deps, DepsMut, Empty, Env, Timestamp, WasmMsg};
 use cw721::{Cw721Query, NftInfoResponse};
@@ -236,6 +236,33 @@ fn admin_can_mint_if_not_mintable() {
     assert_poap_minted(&contract, deps.as_ref(), poap_id, ADMIN.to_string());
 }
 
+#[test]
+fn user_cant_mint_more_then_1_poap() {
+    let mut deps = mock_dependencies();
+    let contract = setup_contract(deps.as_mut(), true, true, None, None);
+    let poap_id = contract.generate_poap_id(&deps.storage).unwrap();
+
+    let _ = contract
+        .execute(
+            deps.as_mut(),
+            mock_env(),
+            mock_info(USER, &[]),
+            Mint { extension: None },
+        )
+        .unwrap();
+    assert_poap_minted(&contract, deps.as_ref(), poap_id, USER.to_string());
+
+    let err = contract
+        .execute(
+            deps.as_mut(),
+            mock_env(),
+            mock_info(USER, &[]),
+            Mint { extension: None },
+        )
+        .unwrap_err();
+    assert_eq!(ContractError::PoapAlreadyMinted {}, err);
+}
+
 #[test]
 fn user_can_mint_after_start_time() {
     let mut deps = mock_dependencies();

contracts/poap/src/error.rs

@@ -29,6 +29,9 @@
     #[error("Mint is not allowed")]
     MintDisabled {},
 
+    #[error("POAP already minted")]
+    PoapAlreadyMinted {},
+
     #[error("You don't have the permission to mint")]
     MintUnauthorized {},
 
@@ -43,14 +46,14 @@
 }
 
 impl From<Cw721BaseContractError> for ContractError {
     fn from(error: Cw721BaseContractError) -> Self {
         match error {
             Cw721BaseContractError::Std(e) => ContractError::Std(e),
             Cw721BaseContractError::Ownership(e) => ContractError::Ownership(e),
             Cw721BaseContractError::Version(e) => ContractError::Version(e),
             Cw721BaseContractError::Claimed {} => ContractError::Claimed {},
             Cw721BaseContractError::Expired {} => ContractError::Expired {},
             Cw721BaseContractError::ApprovalNotFound { spender } => {
                 ContractError::ApprovalNotFound { spender }
             }
         }

contracts/poap/src/execute.rs

@@ -42,7 +42,7 @@
 
         // Get the minter address or fallback to the sender address.
         let minter = msg
             .minter
             .map(|minter| deps.api.addr_validate(&minter))
             .transpose()?;
         self.minter.save(deps.storage, &minter)?;
@@ -54,7 +54,7 @@
             && msg.mint_end_time.is_some()
             && msg.mint_start_time.unwrap() >= msg.mint_end_time.unwrap()
         {
             return Err(ContractError::InvalidTimestampValues {});
         }
 
         self.mint_start_time
@@ -73,31 +73,31 @@
     ) -> Result<Response<C>, ContractError> {
         match msg {
             ExecuteMsg::TransferNft {
                 recipient,
                 token_id,
             } => self.transfer_poap(deps, env, info, recipient, token_id),
             ExecuteMsg::SendNft {
                 contract,
                 msg,
                 token_id,
             } => self.send_poap(deps, env, info, contract, token_id, msg),
             ExecuteMsg::UpdateMinter { minter } => self.update_minter(deps, env, info, minter),
             ExecuteMsg::SetMintable { mintable } => self.set_mintable(deps, env, info, mintable),
             ExecuteMsg::SetTransferable { transferable } => {
                 self.set_transferable(deps, env, info, transferable)
             }
             ExecuteMsg::SetMintStartEndTime {
                 start_time,
                 end_time,
             } => self.set_mint_start_end_time(deps, env, info, start_time, end_time),
             ExecuteMsg::Mint { extension } => self.mint(deps, env, info, extension),
             ExecuteMsg::MintTo { extension, users } => {
                 self.mint_to(deps, env, info, users, extension)
             }
             _ => self
                 .cw721_base
                 .execute(deps, env, info, msg.into())
                 .map_err(|e| e.into()),
         }
     }
 }
@@ -124,9 +124,9 @@
         self.assert_is_transferable(deps.storage)?;
 
         return self
             .cw721_base
             .transfer_nft(deps, env, info, recipient, token_id)
             .map_err(|e| e.into());
     }
 
     /// Send a POAP to a contract and trigger an action on the contract.
@@ -146,9 +146,9 @@
         self.assert_is_transferable(deps.storage)?;
 
         return self
             .cw721_base
             .send_nft(deps, env, info, contract, token_id, msg)
             .map_err(|e| e.into());
     }
 
     /// Updates who have the minting permissions, this action can be executed only from
@@ -166,10 +166,10 @@
         self.minter.save(deps.storage, &new_minter)?;
 
         Ok(Response::new()
             .add_attribute("action", "update_minter")
             .add_attribute("sender", info.sender)
             .add_attribute(
                 "new_minter",
                 new_minter.map_or_else(|| "none".to_string(), |minter| minter.to_string()),
             ))
     }
@@ -188,7 +188,7 @@
         self.is_mintable.save(deps.storage, &mintable)?;
 
         Ok(Response::new()
             .add_attribute("action", "set_mintable")
             .add_attribute("sender", info.sender)
             .add_attribute("mintable", mintable.to_string()))
     }
@@ -207,7 +207,7 @@
         self.is_transferable.save(deps.storage, &transferable)?;
 
         Ok(Response::new()
             .add_attribute("action", "set_transferable")
             .add_attribute("sender", info.sender)
             .add_attribute("transferable", transferable.to_string()))
     }
@@ -239,14 +239,14 @@
         self.mint_end_time.save(deps.storage, &end_time)?;
 
         Ok(Response::new()
             .add_attribute("action", "set_mint_start_end_time")
             .add_attribute("sender", info.sender)
             .add_attribute(
                 "start_time",
                 start_time.map_or_else(|| "none".to_string(), |t| t.to_string()),
             )
             .add_attribute(
                 "end_time",
                 end_time.map_or_else(|| "none".to_string(), |t| t.to_string()),
             ))
     }
@@ -263,7 +263,7 @@
         let token_id = self.mint_to_user(deps.storage, &info.sender, extension)?;
 
         Ok(Response::new()
             .add_attribute("action", "mint")
             .add_attribute("owner", info.sender)
             .add_attribute("token_id", token_id))
     }
@@ -293,7 +293,7 @@
         }
 
         Ok(Response::new()
             .add_attribute("action", "mint_to")
             .add_attribute("minter", info.sender)
             .add_attribute("token_ids", minted_tokens.join(", ")))
     }
@@ -331,9 +331,9 @@
         // Generate the token id
         let token_id = self.generate_poap_id(storage)?;
         self.cw721_base
             .tokens
             .update(storage, &token_id, |old| match old {
                 Some(_) => Err(ContractError::Claimed {}),
                 None => Ok(token),
             })?;
 
@@ -392,6 +392,18 @@
             return Err(ContractError::MintDisabled {});
         }
 
+        // Check if this user have already minted a poap.
+        if !self
+            .cw721_base
+            .tokens
+            .idx
+            .owner
+            .prefix(user.clone())
+            .is_empty(storage)
+        {
+            return Err(ContractError::PoapAlreadyMinted {});
+        }
+
         // Check if we have a mint start time
         if let Some(start_time) = self.mint_start_time.load(storage)? {
             // Check if the event has started.