test: add missing E2E tests for Erc721

examples/erc721/src/lib.rs

@@ -65,6 +65,27 @@ impl Erc721Example {
         Ok(())
     }
 
+    pub fn safe_mint(
+        &mut self,
+        to: Address,
+        token_id: U256,
+        data: Bytes,
+    ) -> Result<(), Vec<u8>> {
+        self.pausable.when_not_paused()?;
+
+        self.erc721._safe_mint(to, token_id, &data)?;
+
+        // Update the extension's state.
+        self.enumerable._add_token_to_all_tokens_enumeration(token_id);
+        self.enumerable._add_token_to_owner_enumeration(
+            to,
+            token_id,
+            &self.erc721,
+        )?;
+
+        Ok(())
+    }
+
     pub fn safe_transfer_from(
         &mut self,
         from: Address,

examples/erc721/tests/abi/mod.rs

@@ -18,7 +18,7 @@ sol!(
         function setApprovalForAll(address operator, bool approved) external;
         function totalSupply() external view returns (uint256 totalSupply);
         function transferFrom(address from, address to, uint256 tokenId) external;
-
+        function safeMint(address to, uint256 tokenId, bytes calldata data) external;
         function mint(address to, uint256 tokenId) external;
         function burn(uint256 tokenId) external;
 

examples/erc721/tests/erc721.rs

@@ -1352,6 +1352,238 @@
     Ok(())
 }
 
+#[e2e::test]
+async fn safe_mint_to_eoa(alice: Account) -> eyre::Result<()> {
+    let contract_addr = alice.as_deployer().deploy().await?.address()?;
+    let contract = Erc721::new(contract_addr, &alice.wallet);
+    let alice_addr = alice.address();
+
+    // Test case 1: Blank data
+    let token_id = random_token_id();
+    let data = Bytes::new();
+    let receipt =
+        receipt!(contract.safeMint(alice_addr, token_id, data))?;
+    assert!(receipt.emits(Erc721::Transfer {
+        from: Address::ZERO,
+        to: alice_addr,
+        tokenId: token_id,
+    }));
+    let Erc721::ownerOfReturn { ownerOf } =
+        contract.ownerOf(token_id).call().await?;
+    assert_eq!(alice_addr, ownerOf);
+    let Erc721::balanceOfReturn { balance } =
+        contract.balanceOf(alice.address()).call().await?;
+    let one = uint!(1_U256);
+    assert_eq!(balance, one);
+
+    // Test case 2: Custom data
+    let token_id = random_token_id();
+    let data: Bytes = fixed_bytes!("deadbeef").into();
+    let receipt =
+        receipt!(contract.safeMint(alice_addr, token_id, data))?;
+    assert!(receipt.emits(Erc721::Transfer {
+        from: Address::ZERO,
+        to: alice_addr,
+        tokenId: token_id,
+    }));
+    let Erc721::ownerOfReturn { ownerOf } =
+        contract.ownerOf(token_id).call().await?;
+    assert_eq!(alice_addr, ownerOf);
+
+    let Erc721::balanceOfReturn { balance } =
+        contract.balanceOf(alice.address()).call().await?;
+    let two = uint!(2_U256);
+    assert_eq!(balance, two);
+
+    Ok(())
+}
+
+#[e2e::test]
+async fn safe_mint_to_receiver_contract(alice: Account) -> eyre::Result<()> {
+    let contract_addr = alice.as_deployer().deploy().await?.address()?;
+    let contract = Erc721::new(contract_addr, &alice.wallet);
+    let receiver_address =
+        receiver::deploy(&alice.wallet, ERC721ReceiverMock::RevertType::None)
+            .await?;
+
+    // Test case 1: Blank data
+    let token_id = random_token_id();
+    let data = Bytes::new();
+    let receipt = receipt!(contract.safeMint(
+        receiver_address,
+        token_id,
+        data.clone()
+    ))?;
+    assert!(receipt.emits(Erc721::Transfer {
+        from: Address::ZERO,
+        to: receiver_address,
+        tokenId: token_id,
+    }));
+    assert!(receipt.emits(ERC721ReceiverMock::Received {
+        operator: alice.address(),
+        from: Address::ZERO,
+        tokenId: token_id,
+        data: data,
+    }));
+    let Erc721::ownerOfReturn { ownerOf } =
+        contract.ownerOf(token_id).call().await?;
+    assert_eq!(receiver_address, ownerOf);
+    let Erc721::balanceOfReturn { balance } =
+        contract.balanceOf(receiver_address).call().await?;
+    let one = uint!(1_U256);
+    assert_eq!(balance, one);
+
+    // Test case 2: Custom data
+    let token_id = random_token_id();
+    let data: Bytes = fixed_bytes!("deadbeef").into();
+    let receipt = receipt!(contract.safeMint(
+        receiver_address,
+        token_id,
+        data.clone()
+    ))?;
+    assert!(receipt.emits(Erc721::Transfer {
+        from: Address::ZERO,
+        to: receiver_address,
+        tokenId: token_id,
+    }));
+    assert!(receipt.emits(ERC721ReceiverMock::Received {
+        operator: alice.address(),
+        from: Address::ZERO,
+        tokenId: token_id,
+        data: data,
+    }));
+    let Erc721::ownerOfReturn { ownerOf } =
+        contract.ownerOf(token_id).call().await?;
+    assert_eq!(receiver_address, ownerOf);
+
+    let Erc721::balanceOfReturn { balance } =
+        contract.balanceOf(receiver_address).call().await?;
+    let two = uint!(2_U256);
+    assert_eq!(balance, two);
+
+    Ok(())
+}
+
+#[e2e::test]
+async fn error_when_safe_mint_to_invalid_receiver_contract(
+    alice: Account,
+) -> eyre::Result<()> {
+    let contract_addr = alice.as_deployer().deploy().await?.address()?;
+    let contract = Erc721::new(contract_addr, &alice.wallet);
+
+    let token_id = random_token_id();
+    let data: Bytes = fixed_bytes!("deadbeef").into();
+
+    let err = send!(contract.safeMint(contract_addr, token_id, data))
+        .expect_err("should not safe mint the token to invalid receiver");
+
+    assert!(err.reverted_with(Erc721::ERC721InvalidReceiver {
+        receiver: contract_addr
+    }));
+
+    Ok(())
+}
+
+#[e2e::test]
+async fn error_when_safe_mint_to_invalid_sender_with_data(
+    alice: Account,
+    bob: Account,
+) -> eyre::Result<()> {
+    let contract_addr = alice.as_deployer().deploy().await?.address()?;
+    let contract = Erc721::new(contract_addr, &alice.wallet);
+
+    let token_id = random_token_id();
+    let data: Bytes = fixed_bytes!("deadbeef").into();
+
+    _ = watch!(contract.mint(alice.address(), token_id))?;
+
+    let err = send!(contract.safeMint(bob.address(), token_id, data))
+        .expect_err("should not safe mint an existing token");
+
+    assert!(err
+        .reverted_with(Erc721::ERC721InvalidSender { sender: Address::ZERO }));
+
+    Ok(())
+}
+
+#[e2e::test]
+async fn error_when_receiver_reverts_with_reason_on_safe_mint_with_data(
+    alice: Account,
+) -> eyre::Result<()> {
+    let contract_addr = alice.as_deployer().deploy().await?.address()?;
+    let contract = Erc721::new(contract_addr, &alice.wallet);
+
+    let receiver_address = receiver::deploy(
+        &alice.wallet,
+        ERC721ReceiverMock::RevertType::RevertWithMessage,
+    )
+    .await?;
+
+    let token_id = random_token_id();
+    let data: Bytes = fixed_bytes!("deadbeef").into();
+
+    let err = send!(contract.safeMint(receiver_address, token_id, data))
+        .expect_err("should not safe mint when receiver errors with reason");
+
+    assert!(err.reverted_with(Erc721::Error {
+        message: "ERC721ReceiverMock: reverting".to_string()
+    }));
+
+    Ok(())
+}
+
+#[e2e::test]
+async fn error_when_receiver_reverts_without_reason_on_safe_mint_with_data(
+    alice: Account,
+) -> eyre::Result<()> {
+    let contract_addr = alice.as_deployer().deploy().await?.address()?;
+    let contract = Erc721::new(contract_addr, &alice.wallet);
+
+    let receiver_address = receiver::deploy(
+        &alice.wallet,
+        ERC721ReceiverMock::RevertType::RevertWithoutMessage,
+    )
+    .await?;
+
+    let token_id = random_token_id();
+    let data: Bytes = fixed_bytes!("deadbeef").into();
+
+    let err = send!(contract.safeMint(receiver_address, token_id, data))
+        .expect_err(
+            "should not safe mint when receiver reverts without reason",
+        );
+
+    assert!(err.reverted_with(Erc721::ERC721InvalidReceiver {
+        receiver: receiver_address
+    }));
+
+    Ok(())
+}
+
+#[e2e::test]
+async fn error_when_receiver_panics_on_safe_mint_with_data(
+    alice: Account,
+) -> eyre::Result<()> {
+    let contract_addr = alice.as_deployer().deploy().await?.address()?;
+    let contract = Erc721::new(contract_addr, &alice.wallet);
+
+    let receiver_address =
+        receiver::deploy(&alice.wallet, ERC721ReceiverMock::RevertType::Panic)
+            .await?;
+
+    let token_id = random_token_id();
+    let data: Bytes = fixed_bytes!("deadbeef").into();
+
+    let err = send!(contract.safeMint(receiver_address, token_id, data))
+        .expect_err("should not safe mint when receiver panics");
+
+    assert!(err.reverted_with(Erc721::Panic {
+        code: U256::from(PanicCode::DivisionByZero as u8)
+    }));
+
+    Ok(())
+}
+
 // ============================================================================
 // Integration Tests: ERC-721 Pausable Extension
 // ============================================================================
@@ -1615,6 +1847,47 @@
     Ok(())
 }
 
+#[e2e::test]
+async fn error_when_safe_mint_in_paused_state(
+    alice: Account,
+) -> eyre::Result<()> {
+    let contract_addr = alice.as_deployer().deploy().await?.address()?;
+    let contract = Erc721::new(contract_addr, &alice.wallet);
+
+    let alice_addr = alice.address();
+    let token_id = random_token_id();
+
+    let Erc721::balanceOfReturn { balance: initial_alice_balance } =
+        contract.balanceOf(alice_addr).call().await?;
+
+    let _ = watch!(contract.pause())?;
+
+    let err = send!(contract.safeMint(
+        alice_addr,
+        token_id,
+        fixed_bytes!("deadbeef").into()
+    ))
+    .expect_err("should return `EnforcedPause`");
+    assert!(err.reverted_with(Erc721::EnforcedPause {}));
+
+    let err = contract
+        .ownerOf(token_id)
+        .call()
+        .await
+        .expect_err("should return `ERC721NonexistentToken`");
+
+    assert!(
+        err.reverted_with(Erc721::ERC721NonexistentToken { tokenId: token_id })
+    );
+
+    let Erc721::balanceOfReturn { balance: alice_balance } =
+        contract.balanceOf(alice_addr).call().await?;
+
+    assert_eq!(initial_alice_balance, alice_balance);
+
+    Ok(())
+}
+
 // ============================================================================
 // Integration Tests: ERC-721 Burnable Extension
 // ============================================================================