@paimaexample/evm-contracts 0.3.0

package/test/src/InverseAppProjected1155.t.sol

@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.18;
+
+import "../lib/cheatcodes.sol";
+import "../lib/console.sol";
+import "../lib/ctest.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
+import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC4906Agnostic} from "../../src/contracts/token/IERC4906Agnostic.sol";
+import {InverseAppProjected1155} from "../../src/contracts/token/InverseAppProjected1155.sol";
+import {IInverseAppProjected1155} from "../../src/contracts/token/IInverseAppProjected1155.sol";
+import {IInverseProjected1155} from "../../src/contracts/token/IInverseProjected1155.sol";
+import {IUri} from "../../src/contracts/token/IUri.sol";
+
+contract MockTokenUri is IUri {
+    using Strings for uint256;
+
+    function uri(uint256 id) external view override returns (string memory) {
+        return string.concat("mock://", id.toString());
+    }
+}
+
+contract InverseAppProjected1155Test is CTest, ERC1155Holder {
+    using Strings for uint256;
+
+    CheatCodes vm = CheatCodes(HEVM_ADDRESS);
+    InverseAppProjected1155 public token;
+    uint256 ownedTokenId;
+    string baseURI = "192.168.0.1/";
+    address alice = 0x078D888E40faAe0f32594342c85940AF3949E666;
+
+    function setUp() public {
+        token = new InverseAppProjected1155("ABC", "XYZ", address(this));
+        ownedTokenId = token.mint(1000, bytes(""), bytes(""));
+        token.setBaseURI(baseURI);
+    }
+
+    function test_CanBurn() public {
+        uint256 amount = token.balanceOf(address(this), ownedTokenId);
+        vm.expectEmit(true, true, true, true);
+        emit IERC1155.TransferSingle(
+            address(this),
+            address(this),
+            address(0),
+            ownedTokenId,
+            amount
+        );
+        token.burn(ownedTokenId, amount);
+    }
+
+    function test_CanBurnBatch() public {
+        uint256 balance = token.balanceOf(address(this), ownedTokenId);
+
+        uint256[] memory ids = new uint256[](2);
+        ids[0] = ownedTokenId;
+        ids[1] = ownedTokenId;
+        uint256[] memory values = new uint256[](2);
+        values[0] = balance / 2;
+        values[1] = balance / 4;
+
+        uint256 balanceBefore = token.balanceOf(address(this), ownedTokenId);
+        uint256 supplyBefore = token.totalSupply(ownedTokenId);
+        vm.expectEmit(true, true, true, true);
+        emit IERC1155.TransferBatch(address(this), address(this), address(0), ids, values);
+        token.burnBatch(ids, values);
+
+        assertEq(
+            token.balanceOf(address(this), ownedTokenId),
+            balanceBefore - values[0] - values[1]
+        );
+        assertEq(token.totalSupply(ownedTokenId), supplyBefore - values[0] - values[1]);
+    }
+
+    function test_CanMint() public {
+        address minter = alice;
+        uint256 userNonce = token.currentNonce(minter) + 1;
+        uint256 tokenId = token.currentTokenId();
+        uint256 value = 500;
+        uint256 tokenValueUserBefore = token.balanceOf(minter, tokenId);
+
+        vm.prank(minter);
+        vm.expectEmit(true, true, true, true);
+        emit IInverseAppProjected1155.Minted(tokenId, minter, userNonce, value);
+        token.mint(value, bytes(""), bytes(""));
+
+        assertEq(token.balanceOf(minter, tokenId), tokenValueUserBefore + value);
+    }
+
+    function test_CanMintNoVerificationData() public {
+        address minter = alice;
+        uint256 userNonce = token.currentNonce(minter) + 1;
+        uint256 tokenId = token.currentTokenId();
+        uint256 value = 500;
+        uint256 tokenValueUserBefore = token.balanceOf(minter, 0);
+
+        vm.prank(minter);
+        vm.expectEmit(true, true, true, true);
+        emit IInverseAppProjected1155.Minted(tokenId, minter, userNonce, value);
+        token.mint(value, bytes(""));
+
+        assertEq(token.balanceOf(minter, tokenId), tokenValueUserBefore + value);
+    }
+
+    function test_CanTransfer() public {
+        address sender = address(this);
+        address recipient = alice;
+
+        uint256 tokenValueMinterBefore = token.balanceOf(sender, ownedTokenId);
+        uint256 tokenValueRecipientBefore = token.balanceOf(recipient, ownedTokenId);
+        uint256 value = tokenValueMinterBefore - 100;
+
+        token.safeTransferFrom(sender, recipient, ownedTokenId, value, bytes(""));
+
+        assertEq(token.balanceOf(sender, ownedTokenId), tokenValueMinterBefore - value);
+        assertEq(token.balanceOf(recipient, ownedTokenId), tokenValueRecipientBefore + value);
+    }
+
+    function test_TokenUriUsesBaseUriByDefault() public {
+        address user = address(this);
+        uint256 value = 1000;
+        uint256 tokenId = token.mint(value, bytes(""), bytes(""));
+        uint256 userTokenId = token.currentNonce(user);
+        string memory result = token.uri(tokenId);
+        assertEq(
+            result,
+            string.concat(
+                baseURI,
+                "eip155:",
+                block.chainid.toString(),
+                "/",
+                Strings.toHexString(uint160(user), 20),
+                "/",
+                userTokenId.toString(),
+                "/",
+                value.toString(),
+                ".json"
+            )
+        );
+    }
+
+    function test_TokenUriUsingCustomBaseUri() public {
+        address user = address(this);
+        uint256 value = 1000;
+        uint256 tokenId = token.mint(value, bytes(""), bytes(""));
+        uint256 userTokenId = token.currentNonce(user);
+        string memory customUri = "1.1.0.0/";
+        string memory result = token.uri(tokenId, customUri);
+        assertEq(
+            result,
+            string.concat(
+                customUri,
+                "eip155:",
+                block.chainid.toString(),
+                "/",
+                Strings.toHexString(uint160(user), 20),
+                "/",
+                userTokenId.toString(),
+                "/",
+                value.toString(),
+                ".json"
+            )
+        );
+    }
+
+    function test_TokenUriUsingCustomUriInterface() public {
+        IUri tokenUriInterface = new MockTokenUri();
+        string memory result = token.uri(ownedTokenId, tokenUriInterface);
+        assertEq(result, string.concat("mock://", ownedTokenId.toString()));
+    }
+
+    function test_SupportsInterface() public {
+        assertTrue(token.supportsInterface(type(IERC165).interfaceId));
+        assertTrue(token.supportsInterface(type(IERC1155).interfaceId));
+        assertTrue(token.supportsInterface(type(IInverseProjected1155).interfaceId));
+        assertTrue(token.supportsInterface(type(IInverseAppProjected1155).interfaceId));
+    }
+
+    function test_UpdateMetadataEmitsEvent() public {
+        uint256 tokenId = 1;
+        vm.expectEmit(true, true, true, true);
+        emit IERC4906Agnostic.MetadataUpdate(tokenId);
+        token.updateMetadata(tokenId);
+    }
+
+    function test_UpdateMetadataBatchEmitsEvent() public {
+        uint256 fromTokenId = 1;
+        uint256 toTokenId = 10;
+        vm.expectEmit(true, true, true, true);
+        emit IERC4906Agnostic.BatchMetadataUpdate(fromTokenId, toTokenId);
+        token.updateMetadataBatch(fromTokenId, toTokenId);
+    }
+
+    function test_CannotSetBaseUriUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        token.setBaseURI("test");
+    }
+
+    function test_CannotSetBaseExtensionUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        token.setBaseExtension("test");
+    }
+}

package/test/src/InverseAppProjectedNft.t.sol

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.18;
+
+import "../lib/cheatcodes.sol";
+import "../lib/console.sol";
+import "../lib/ctest.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {ERC721Holder} from "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC4906} from "@openzeppelin/contracts/interfaces/IERC4906.sol";
+import {InverseAppProjectedNft} from "../../src/contracts/token/InverseAppProjectedNft.sol";
+import {IInverseAppProjectedNft} from "../../src/contracts/token/IInverseAppProjectedNft.sol";
+import {ITokenUri} from "../../src/contracts/token/ITokenUri.sol";
+
+contract MockTokenUri is ITokenUri {
+    using Strings for uint256;
+
+    function tokenURI(uint256 tokenId) external view override returns (string memory) {
+        return string.concat("mock://", tokenId.toString());
+    }
+}
+
+contract MockDataReceiver {
+    bytes public dataReceived;
+    function onERC721Received(
+        address,
+        address,
+        uint256,
+        bytes calldata data
+    ) public returns (bytes4) {
+        dataReceived = data;
+        return this.onERC721Received.selector;
+    }
+}
+
+contract InverseAppProjectedNftTest is CTest, ERC721Holder {
+    using Strings for uint256;
+
+    CheatCodes vm = CheatCodes(HEVM_ADDRESS);
+    InverseAppProjectedNft public nft;
+    uint256 ownedTokenId;
+    string baseURI = "192.168.0.1/";
+    address alice = 0x078D888E40faAe0f32594342c85940AF3949E666;
+
+    function setUp() public {
+        nft = new InverseAppProjectedNft("ABC", "XYZ", address(this));
+        ownedTokenId = nft.mint(address(this));
+        nft.setBaseURI(baseURI);
+    }
+
+    function test_CanBurn() public {
+        nft.burn(ownedTokenId);
+    }
+
+    function test_CanMint() public {
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit IInverseAppProjectedNft.Minted(2, address(this), 2);
+        nft.mint(address(this), bytes(""), bytes(""));
+    }
+
+    function test_CanMintNoData() public {
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit IInverseAppProjectedNft.Minted(2, address(this), 2);
+        nft.mint(address(this), bytes(""));
+    }
+
+    function test_CanMintNoDataNoVerificationData() public {
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit IInverseAppProjectedNft.Minted(2, address(this), 2);
+        nft.mint(address(this));
+    }
+
+    function test_MintPassesDataToReceiver() public {
+        MockDataReceiver receiver = new MockDataReceiver();
+        bytes memory data = bytes("data");
+        nft.mint(address(receiver), "", data);
+        assertEq(keccak256(receiver.dataReceived()), keccak256(data));
+    }
+
+    function test_CanTransfer() public {
+        nft.transferFrom(address(this), alice, ownedTokenId);
+    }
+
+    function test_TokenUriUsesBaseUriByDefault() public {
+        string memory result = nft.tokenURI(ownedTokenId);
+        assertEq(
+            result,
+            string.concat(
+                "192.168.0.1/eip155:31337/",
+                Strings.toHexString(uint160(address(this)), 20),
+                "/",
+                "1.json"
+            )
+        );
+    }
+
+    function test_TokenUriUsingCustomBaseUri() public {
+        string memory result = nft.tokenURI(ownedTokenId, "1.1.0.0/");
+        assertEq(
+            result,
+            string.concat(
+                "1.1.0.0/eip155:31337/",
+                Strings.toHexString(uint160(address(this)), 20),
+                "/",
+                "1.json"
+            )
+        );
+    }
+
+    function test_TokenUriUsingCustomUriInterface() public {
+        ITokenUri tokenUriInterface = new MockTokenUri();
+        string memory result = nft.tokenURI(ownedTokenId, tokenUriInterface);
+        assertEq(result, string.concat("mock://", ownedTokenId.toString()));
+    }
+
+    function test_SupportsInterface() public {
+        assertTrue(nft.supportsInterface(type(IERC165).interfaceId));
+        assertTrue(nft.supportsInterface(type(IERC721).interfaceId));
+        assertTrue(nft.supportsInterface(bytes4(0x49064906)));
+    }
+
+    function test_UpdateMetadataEmitsEvent() public {
+        uint256 tokenId = 1;
+        vm.expectEmit(true, true, true, true);
+        emit IERC4906.MetadataUpdate(tokenId);
+        nft.updateMetadata(tokenId);
+    }
+
+    function test_UpdateMetadataBatchEmitsEvent() public {
+        uint256 fromTokenId = 1;
+        uint256 toTokenId = 10;
+        vm.expectEmit(true, true, true, true);
+        emit IERC4906.BatchMetadataUpdate(fromTokenId, toTokenId);
+        nft.updateMetadataBatch(fromTokenId, toTokenId);
+    }
+
+    function test_CannotMintToZeroAddress() public {
+        vm.expectRevert("InverseAppProjectedNft: zero receiver address");
+        nft.mint(address(0));
+    }
+
+    function test_CannotBurnUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert("InverseAppProjectedNft: not owner");
+        nft.burn(ownedTokenId);
+    }
+
+    function test_CannotSetBaseUriUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        nft.setBaseURI("test");
+    }
+
+    function test_CannotSetBaseExtensionUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        nft.setBaseExtension("test");
+    }
+}

package/test/src/InverseBaseProjected1155.t.sol

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.18;
+
+import "../lib/cheatcodes.sol";
+import "../lib/console.sol";
+import "../lib/ctest.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
+import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC4906Agnostic} from "../../src/contracts/token/IERC4906Agnostic.sol";
+import {InverseBaseProjected1155} from "../../src/contracts/token/InverseBaseProjected1155.sol";
+import {IInverseBaseProjected1155} from "../../src/contracts/token/IInverseBaseProjected1155.sol";
+import {IInverseProjected1155} from "../../src/contracts/token/IInverseProjected1155.sol";
+import {IUri} from "../../src/contracts/token/IUri.sol";
+
+contract MockTokenUri is IUri {
+    using Strings for uint256;
+
+    function uri(uint256 id) external view override returns (string memory) {
+        return string.concat("mock://", id.toString());
+    }
+}
+
+contract InverseBaseProjected1155Test is CTest, ERC1155Holder {
+    using Strings for uint256;
+
+    CheatCodes vm = CheatCodes(HEVM_ADDRESS);
+    InverseBaseProjected1155 public token;
+    uint256 ownedTokenId;
+    string baseURI = "192.168.0.1/";
+    address alice = 0x078D888E40faAe0f32594342c85940AF3949E666;
+
+    function setUp() public {
+        token = new InverseBaseProjected1155("ABC", "XYZ", address(this));
+        ownedTokenId = token.mint(1000, bytes(""), "");
+        token.setBaseURI(baseURI);
+    }
+
+    function test_CanBurn() public {
+        uint256 amount = token.balanceOf(address(this), ownedTokenId);
+        token.burn(ownedTokenId, amount);
+    }
+
+    function test_CanBurnBatch() public {
+        uint256 balance = token.balanceOf(address(this), ownedTokenId);
+
+        uint256[] memory ids = new uint256[](2);
+        ids[0] = ownedTokenId;
+        ids[1] = ownedTokenId;
+        uint256[] memory values = new uint256[](2);
+        values[0] = balance / 2;
+        values[1] = balance / 4;
+
+        uint256 balanceBefore = token.balanceOf(address(this), ownedTokenId);
+        uint256 supplyBefore = token.totalSupply(ownedTokenId);
+        vm.expectEmit(true, true, true, true);
+        emit IERC1155.TransferBatch(address(this), address(this), address(0), ids, values);
+        token.burnBatch(ids, values);
+
+        assertEq(
+            token.balanceOf(address(this), ownedTokenId),
+            balanceBefore - values[0] - values[1]
+        );
+        assertEq(token.totalSupply(ownedTokenId), supplyBefore - values[0] - values[1]);
+    }
+
+    function test_CanMint() public {
+        address minter = alice;
+        uint256 tokenId = token.currentTokenId();
+        uint256 value = 500;
+        uint256 tokenValueUserBefore = token.balanceOf(minter, tokenId);
+
+        vm.prank(minter);
+        vm.expectEmit(true, true, true, true);
+        emit IInverseBaseProjected1155.Minted(tokenId, value, "abcd");
+        token.mint(value, bytes(""), "abcd");
+
+        assertEq(token.balanceOf(minter, tokenId), tokenValueUserBefore + value);
+    }
+
+    function test_CanTransfer() public {
+        address sender = address(this);
+        address recipient = alice;
+
+        uint256 tokenValueMinterBefore = token.balanceOf(sender, ownedTokenId);
+        uint256 tokenValueRecipientBefore = token.balanceOf(recipient, ownedTokenId);
+        uint256 value = tokenValueMinterBefore - 100;
+
+        token.safeTransferFrom(sender, recipient, ownedTokenId, value, bytes(""));
+
+        assertEq(token.balanceOf(sender, ownedTokenId), tokenValueMinterBefore - value);
+        assertEq(token.balanceOf(recipient, ownedTokenId), tokenValueRecipientBefore + value);
+    }
+
+    function test_TokenUriUsesBaseUriByDefault() public {
+        uint256 value = 1000;
+        uint256 tokenId = token.mint(value, bytes(""), "");
+        string memory result = token.uri(tokenId);
+        assertEq(
+            result,
+            string.concat(
+                baseURI,
+                "eip155:",
+                block.chainid.toString(),
+                "/",
+                tokenId.toString(),
+                ".json"
+            )
+        );
+    }
+
+    function test_TokenUriUsingCustomBaseUri() public {
+        uint256 value = 1000;
+        uint256 tokenId = token.mint(value, bytes(""), "");
+        string memory customUri = "1.1.0.0/";
+        string memory result = token.uri(tokenId, customUri);
+        assertEq(
+            result,
+            string.concat(
+                customUri,
+                "eip155:",
+                block.chainid.toString(),
+                "/",
+                tokenId.toString(),
+                ".json"
+            )
+        );
+    }
+
+    function test_TokenUriUsingCustomUriInterface() public {
+        IUri tokenUriInterface = new MockTokenUri();
+        string memory result = token.uri(ownedTokenId, tokenUriInterface);
+        assertEq(result, string.concat("mock://", ownedTokenId.toString()));
+    }
+
+    function test_SupportsInterface() public {
+        assertTrue(token.supportsInterface(type(IERC165).interfaceId));
+        assertTrue(token.supportsInterface(type(IERC1155).interfaceId));
+        assertTrue(token.supportsInterface(type(IInverseProjected1155).interfaceId));
+        assertTrue(token.supportsInterface(type(IInverseBaseProjected1155).interfaceId));
+    }
+
+    function test_UpdateMetadataEmitsEvent() public {
+        uint256 tokenId = 1;
+        vm.expectEmit(true, true, true, true);
+        emit IERC4906Agnostic.MetadataUpdate(tokenId);
+        token.updateMetadata(tokenId);
+    }
+
+    function test_UpdateMetadataBatchEmitsEvent() public {
+        uint256 fromTokenId = 1;
+        uint256 toTokenId = 10;
+        vm.expectEmit(true, true, true, true);
+        emit IERC4906Agnostic.BatchMetadataUpdate(fromTokenId, toTokenId);
+        token.updateMetadataBatch(fromTokenId, toTokenId);
+    }
+
+    function test_CannotSetBaseUriUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        token.setBaseURI("test");
+    }
+
+    function test_CannotSetBaseExtensionUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        token.setBaseExtension("test");
+    }
+}

package/test/src/InverseBaseProjectedNft.t.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.18;
+
+import "../lib/cheatcodes.sol";
+import "../lib/console.sol";
+import "../lib/ctest.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {ERC721Holder} from "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC4906} from "@openzeppelin/contracts/interfaces/IERC4906.sol";
+import {InverseBaseProjectedNft} from "../../src/contracts/token/InverseBaseProjectedNft.sol";
+import {IInverseBaseProjectedNft} from "../../src/contracts/token/IInverseBaseProjectedNft.sol";
+import {ITokenUri} from "../../src/contracts/token/ITokenUri.sol";
+
+contract MockTokenUri is ITokenUri {
+    using Strings for uint256;
+
+    function tokenURI(uint256 tokenId) external view override returns (string memory) {
+        return string.concat("mock://", tokenId.toString());
+    }
+}
+
+contract MockDataReceiver {
+    bytes public dataReceived;
+    function onERC721Received(
+        address,
+        address,
+        uint256,
+        bytes calldata data
+    ) public returns (bytes4) {
+        dataReceived = data;
+        return this.onERC721Received.selector;
+    }
+}
+
+contract InverseBaseProjectedNftTest is CTest, ERC721Holder {
+    using Strings for uint256;
+
+    CheatCodes vm = CheatCodes(HEVM_ADDRESS);
+    InverseBaseProjectedNft public nft;
+    uint256 ownedTokenId;
+    string baseURI = "192.168.0.1/";
+    address alice = 0x078D888E40faAe0f32594342c85940AF3949E666;
+
+    function setUp() public {
+        nft = new InverseBaseProjectedNft("ABC", "XYZ", address(this));
+        ownedTokenId = nft.mint(address(this), "");
+        nft.setBaseURI(baseURI);
+    }
+
+    function test_CanBurn() public {
+        nft.burn(ownedTokenId);
+    }
+
+    function test_CanMint() public {
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit IInverseBaseProjectedNft.Minted(2, "abcd");
+        nft.mint(address(this), "abcd", bytes(""));
+    }
+
+    function test_CanMintNoData() public {
+        vm.prank(alice);
+        vm.expectEmit(true, true, true, true);
+        emit IInverseBaseProjectedNft.Minted(2, "abcd");
+        nft.mint(address(this), "abcd");
+    }
+
+    function test_MintPassesDataToReceiver() public {
+        MockDataReceiver receiver = new MockDataReceiver();
+        bytes memory data = bytes("data");
+        nft.mint(address(receiver), "", data);
+        assertEq(keccak256(receiver.dataReceived()), keccak256(data));
+    }
+
+    function test_CanTransfer() public {
+        nft.transferFrom(address(this), alice, ownedTokenId);
+    }
+
+    function test_TokenUriUsesBaseUriByDefault() public {
+        string memory result = nft.tokenURI(ownedTokenId);
+        assertEq(result, "192.168.0.1/eip155:31337/1.json");
+    }
+
+    function test_TokenUriUsingCustomBaseUri() public {
+        string memory result = nft.tokenURI(ownedTokenId, "1.1.0.0/");
+        assertEq(result, "1.1.0.0/eip155:31337/1.json");
+    }
+
+    function test_TokenUriUsingCustomUriInterface() public {
+        ITokenUri tokenUriInterface = new MockTokenUri();
+        string memory result = nft.tokenURI(ownedTokenId, tokenUriInterface);
+        assertEq(result, string.concat("mock://", ownedTokenId.toString()));
+    }
+
+    function test_SupportsInterface() public {
+        assertTrue(nft.supportsInterface(type(IERC165).interfaceId));
+        assertTrue(nft.supportsInterface(type(IERC721).interfaceId));
+        assertTrue(nft.supportsInterface(bytes4(0x49064906)));
+    }
+
+    function test_UpdateMetadataEmitsEvent() public {
+        uint256 tokenId = 1;
+        vm.expectEmit(true, true, true, true);
+        emit IERC4906.MetadataUpdate(tokenId);
+        nft.updateMetadata(tokenId);
+    }
+
+    function test_UpdateMetadataBatchEmitsEvent() public {
+        uint256 fromTokenId = 1;
+        uint256 toTokenId = 10;
+        vm.expectEmit(true, true, true, true);
+        emit IERC4906.BatchMetadataUpdate(fromTokenId, toTokenId);
+        nft.updateMetadataBatch(fromTokenId, toTokenId);
+    }
+
+    function test_CannotMintToZeroAddress() public {
+        vm.expectRevert("InverseBaseProjectedNft: zero receiver address");
+        nft.mint(address(0), "");
+    }
+
+    function test_CannotBurnUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert("InverseBaseProjectedNft: not owner");
+        nft.burn(ownedTokenId);
+    }
+
+    function test_CannotSetBaseUriUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        nft.setBaseURI("test");
+    }
+
+    function test_CannotSetBaseExtensionUnauthorized() public {
+        vm.prank(alice);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, alice));
+        nft.setBaseExtension("test");
+    }
+}