ERC721 and ERC20 facets

Author: mudgen

src/ERC20/ERC20/ERC20.sol src/ERC20/ERC20/ERC20Facet.solsrc/ERC20/ERC20/ERC20.sol renamed to src/ERC20/ERC20/ERC20Facet.sol

@@ -2,7 +2,7 @@
 pragma solidity >=0.8.30;
 
 
-contract ERC20 {
+contract ERC20Facet {
 
     // ERC-6093: Custom errors for ERC-20
     error ERC20InsufficientBalance(address _sender, uint256 _balance, uint256 _needed);

src/ERC20/ERC20/libraries/LibERC20.sol

@@ -31,22 +31,34 @@ library LibERC20 {
         assembly {
             s.slot := position
         }
-    }
+    }   
 
-    function transfer(address _to, uint256 _value) internal {
+    function mint(address _account, uint256 _value) internal {
         ERC20Storage storage s = getStorage();
-        if (_to == address(0)) {
+        if (_account == address(0)) {
             revert ERC20InvalidReceiver(address(0));
         }
-        uint256 fromBalance = s.balanceOf[msg.sender];
-        if (fromBalance < _value) {
-            revert ERC20InsufficientBalance(msg.sender, fromBalance, _value);
+        unchecked {
+            s.totalSupply += _value;
+            s.balanceOf[_account] += _value;
+        }
+        emit Transfer(address(0), _account, _value);
+    }
+
+    function burn(address _account, uint256 _value) internal {
+        ERC20Storage storage s = getStorage();
+        if (_account == address(0)) {
+            revert ERC20InvalidSender(address(0));
+        }
+        uint256 accountBalance = s.balanceOf[_account];
+        if (accountBalance < _value) {
+            revert ERC20InsufficientBalance(_account, accountBalance, _value);
         }
         unchecked {
-            s.balanceOf[msg.sender] = fromBalance - _value;
-            s.balanceOf[_to] += _value;
+            s.balanceOf[_account] = accountBalance - _value;
+            s.totalSupply -= _value;
         }
-        emit Transfer(msg.sender, _to, _value);
+        emit Transfer(_account, address(0), _value);
     }
 
     function transferFrom(address _from, address _to, uint256 _value) internal {
@@ -71,5 +83,7 @@ library LibERC20 {
             s.balanceOf[_to] += _value;
         }
         emit Transfer(_from, _to, _value);
-    }    
+    }
+
+    
 }

src/ERC721/ERC721/ERC721.sol src/ERC721/ERC721/ERC721Facet.solsrc/ERC721/ERC721/ERC721.sol renamed to src/ERC721/ERC721/ERC721Facet.sol

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: UNLICENSED
+// SPDX-License-Identifier: MIT
 pragma solidity >=0.8.30;
 
 
@@ -12,7 +12,7 @@ interface IERC721Receiver {
 /// @notice A complete, dependency-free ERC-721 implementation using the project's storage pattern.
 /// @dev This contract provides metadata, ownership, approvals, safe transfers (with local IERC721Receiver check),
 /// minting, burning, and helpers. It intentionally avoids external imports.
-contract ERC721 {
+contract ERC721Facet {
 
     // ERC-6093: Custom errors for ERC-721
     error ERC721InvalidOwner(address _owner);
@@ -168,6 +168,8 @@ contract ERC721 {
                     // non-IERC721Receiver implementer
                     revert ERC721InvalidReceiver(_to);
                 } else {
+                    // Return the revert reason
+                    // "memory-safe" means we used memory safely so Solidity does not disable optimizations
                     assembly ("memory-safe") {
                         revert(add(reason, 0x20), mload(reason))
                     }
@@ -212,41 +214,13 @@ contract ERC721 {
                     // non-IERC721Receiver implementer
                     revert ERC721InvalidReceiver(_to);
                 } else {
+                    // Return the revert reason
+                    // "memory-safe" means we used memory safely so Solidity does not disable optimizations                    
                     assembly ("memory-safe") {
                         revert(add(reason, 0x20), mload(reason))
                     }
                 }
             }
         }
-    }
-
-    function _mint(address _to, uint256 _tokenId) internal {
-        ERC721Storage storage s = getStorage();
-        if (_to == address(0)) {
-            revert ERC721InvalidReceiver(address(0));
-        }
-        if (s.ownerOf[_tokenId] != address(0)) {
-            revert ERC721NonexistentToken(_tokenId);
-        }
-        s.ownerOf[_tokenId] = _to;
-        unchecked {
-            s.balanceOf[_to]++;
-        }
-        emit Transfer(address(0), _to, _tokenId);
-    }
-
-    function _burn(uint256 _tokenId) internal {
-        ERC721Storage storage s = getStorage();
-        address owner = s.ownerOf[_tokenId];
-        if (owner == address(0)) {
-            revert ERC721NonexistentToken(_tokenId);
-        }
-        delete s.ownerOf[_tokenId];
-        delete s.approved[_tokenId];
-        unchecked {
-            s.balanceOf[owner]--;
-        }
-        emit Transfer(owner, address(0), _tokenId);
-    }
-    
+    }   
 }

src/ERC721/ERC721/libraries/LibERC721.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+library LibERC721 {
+
+    // ERC-6093: Custom errors for ERC-721    
+    error ERC721NonexistentToken(uint256 _tokenId);    
+    error ERC721IncorrectOwner(address _sender, uint256 _tokenId, address _owner);
+    error ERC721InvalidSender(address _sender);
+    error ERC721InvalidReceiver(address _receiver);
+    error ERC721InsufficientApproval(address _operator, uint256 _tokenId);
+
+
+    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
+    
+    // Struct storage position defined by keccak256 hash 
+    // of diamond storage identifier
+    bytes32 constant STORAGE_POSITION = keccak256("compose.erc721");
+
+    // Storage defined using the ERC-8042 standard
+    // @custom:storage-location erc8042:compose.erc721
+    struct ERC721Storage {
+        string name;
+        string symbol;        
+        mapping(uint256 tokenId => address owner) ownerOf;
+        mapping(address owner => uint256 balance) balanceOf;
+        mapping(uint256 tokenId => address approved) approved;
+        mapping(address owner => mapping(address operator => bool approved)) isApprovedForAll;   
+    }
+
+    function getStorage() internal pure returns (ERC721Storage storage s) {
+        bytes32 position = STORAGE_POSITION;
+        assembly {
+            s.slot := position
+        }
+    }
+
+    function transferFrom(address _from, address _to, uint256 _tokenId) internal {
+        ERC721Storage storage s = getStorage();
+         if (_to == address(0)) {
+            revert ERC721InvalidReceiver(address(0));
+        }
+        address owner = s.ownerOf[_tokenId];
+        if (owner == address(0)) {
+            revert ERC721NonexistentToken(_tokenId);
+        }
+        if (owner != _from) {
+            revert ERC721IncorrectOwner(_from, _tokenId, owner);
+        }        
+        if (msg.sender != _from) {
+            if(!s.isApprovedForAll[_from][msg.sender] && msg.sender != s.approved[_tokenId]) {
+                revert ERC721InsufficientApproval(msg.sender, _tokenId);
+            }
+        }
+        delete s.approved[_tokenId];
+        unchecked {
+            s.balanceOf[_from]--;
+            s.balanceOf[_to]++;
+        }
+        s.ownerOf[_tokenId] = _to;        
+        emit Transfer(_from, _to, _tokenId);
+    }
+
+    function mint(address _to, uint256 _tokenId) internal {
+        ERC721Storage storage s = getStorage();
+        if (_to == address(0)) {
+            revert ERC721InvalidReceiver(address(0));
+        }
+        if (s.ownerOf[_tokenId] != address(0)) {
+            revert ERC721InvalidSender(address(0));
+        }
+        s.ownerOf[_tokenId] = _to;
+        unchecked {
+            s.balanceOf[_to]++;
+        }
+        emit Transfer(address(0), _to, _tokenId);
+    }
+
+    function burn(uint256 _tokenId) internal {
+        ERC721Storage storage s = getStorage();
+        address owner = s.ownerOf[_tokenId];
+        if (owner == address(0)) {
+            revert ERC721NonexistentToken(_tokenId);
+        }
+        delete s.ownerOf[_tokenId];
+        delete s.approved[_tokenId];
+        unchecked {
+            s.balanceOf[owner]--;
+        }
+        emit Transfer(owner, address(0), _tokenId);
+    }
+
+
+
+}