Merge remote-tracking branch 'origin/main' into feature/erc20-natspec

# Conflicts:
#	src/ERC20/ERC20/ERC20Facet.sol

Author: Haroldwonder

README.md

@@ -30,7 +30,7 @@ If this feature ban breaks your mind, just realize that this smart contract libr
 
 4. ### No public or private or internal variables
 
-   No contract or library may have variables declared private or public or internal. For example: `uint256 public counter;`. These visibility labels are not needed because the library uses ERC-8042 Diamond Storage through out.
+   No contract or library may have variables declared private or public or internal. For example: `uint256 public counter;`. These visibility labels are not needed because the library uses ERC-8042 Diamond Storage throughout.
 
 5. ### No private functions
 

script/ERC20.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.13;
 
 import {Script} from "forge-std/Script.sol";
-import {ERC20} from "../src/ERC20/ERC20.sol";
+import {ERC20} from "../src/ERC20/ERC20/ERC20.sol";
 
 contract CounterScript is Script {
     ERC20 public erc20;

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

@@ -1,14 +1,8 @@
-// SPDX-License-Identifier: UNLICENSED
+// SPDX-License-Identifier: MIT
 pragma solidity >=0.8.30;
 
-/**
- * @title ERC20
- * @notice A full ERC-20 token implementation using ERC-8042 diamond storage.
- * @dev This implementation appears minimal but fully complies with the ERC-20 standard. 
- * It avoids Solidity inheritance, constructors, and modifiers as per Compose conventions,
- * and uses ERC-6093 custom errors for efficient error handling.
- */
-contract ERC20 {
+
+contract ERC20Facet {
 
     /// @notice Thrown when an account has insufficient balance for a transfer or burn.
     /// @param _sender Address attempting the transfer.

src/ERC20/ERC20/libraries/LibERC20.sol

@@ -1,7 +1,15 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.30;
 
-library LibERC20 {    
+library LibERC20 {
+
+    // ERC-6093: Custom errors for ERC-20
+    error ERC20InsufficientBalance(address _sender, uint256 _balance, uint256 _needed);
+    error ERC20InvalidSender(address _sender);
+    error ERC20InvalidReceiver(address _receiver);
+    error ERC20InsufficientAllowance(address _spender, uint256 _allowance, uint256 _needed);
+    
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
 
     // Struct storage position defined by keccak256 hash 
     // of diamond storage identifier
@@ -23,5 +31,59 @@ library LibERC20 {
         assembly {
             s.slot := position
         }
+    }   
+
+    function mint(address _account, uint256 _value) internal {
+        ERC20Storage storage s = getStorage();
+        if (_account == address(0)) {
+            revert ERC20InvalidReceiver(address(0));
+        }
+        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[_account] = accountBalance - _value;
+            s.totalSupply -= _value;
+        }
+        emit Transfer(_account, address(0), _value);
     }
+
+    function transferFrom(address _from, address _to, uint256 _value) internal {
+        ERC20Storage storage s = getStorage();
+        if (_from == address(0)) {
+            revert ERC20InvalidSender(address(0));
+        }
+        if (_to == address(0)) {
+            revert ERC20InvalidReceiver(address(0));
+        }
+        uint256 currentAllowance = s.allowances[_from][msg.sender];
+        if (currentAllowance < _value) {
+            revert ERC20InsufficientAllowance(msg.sender, currentAllowance, _value);
+        }
+        uint256 fromBalance = s.balanceOf[_from];
+        if (fromBalance < _value) {
+            revert ERC20InsufficientBalance(msg.sender, fromBalance, _value);
+        }
+        unchecked {
+            s.allowances[_from][msg.sender] = currentAllowance - _value;
+            s.balanceOf[_from] = fromBalance - _value;
+            s.balanceOf[_to] += _value;
+        }
+        emit Transfer(_from, _to, _value);
+    }
+
+    
 }

src/ERC20/ERC20/libraries/LibERC20Transfer.sol

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.30;
+
+
+/// @notice Interface for contracts that want to support safeTransfers.
+interface IERC721Receiver {
+    function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data) external returns (bytes4);
+}
+
+
+/// @title ERC-721 token (zero-dependency implementation)
+/// @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 ERC721Facet {
+
+    // ERC-6093: Custom errors for ERC-721
+    error ERC721InvalidOwner(address _owner);
+    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);
+    error ERC721InvalidApprover(address _approver);
+    error ERC721InvalidOperator(address _operator);
+
+    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
+    event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
+    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
+
+    // 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 => string tokenURI) tokenURIOf;
+        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 name() external view returns (string memory) {
+        return getStorage().name;
+    }
+
+    function symbol() external view returns (string memory) {
+        return getStorage().symbol;
+    }   
+
+    function balanceOf(address _owner) external view returns (uint256) {
+        if (_owner == address(0)) {
+            revert ERC721InvalidOwner(_owner);
+        }
+        return getStorage().balanceOf[_owner];
+    }
+
+    function ownerOf(uint256 _tokenId) public view returns (address) {
+        address owner = getStorage().ownerOf[_tokenId];
+        if (owner == address(0)) {
+            revert ERC721NonexistentToken(_tokenId);
+        } 
+        return owner;
+    }
+
+    function getApproved(uint256 _tokenId) external view returns (address) {
+        address owner = getStorage().ownerOf[_tokenId];
+        if (owner == address(0)) {
+            revert ERC721NonexistentToken(_tokenId);
+        }
+        return getStorage().approved[_tokenId];
+    }
+
+    function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
+        return getStorage().isApprovedForAll[_owner][_operator];
+    }
+
+    function approve(address _approved, uint256 _tokenId) external {
+        ERC721Storage storage s = getStorage();
+        address owner = s.ownerOf[_tokenId];
+        if (owner == address(0)) {
+            revert ERC721NonexistentToken(_tokenId);
+        }
+        if (msg.sender != owner && !s.isApprovedForAll[owner][msg.sender]) {
+            revert ERC721InvalidApprover(_approved);
+        }        
+        s.approved[_tokenId] = _approved;
+        emit Approval(owner, _approved, _tokenId);        
+    }
+
+    function setApprovalForAll(address _operator, bool _approved) external {
+        if (_operator == address(0)) {
+            revert ERC721InvalidOperator(_operator);
+        }
+        getStorage().isApprovedForAll[msg.sender][_operator] = _approved;
+        emit ApprovalForAll(msg.sender, _operator, _approved);
+    }
+
+    function internalTransferFrom(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 transferFrom(address _from, address _to, uint256 _tokenId) external {
+        internalTransferFrom(_from, _to, _tokenId);
+    }
+
+    function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
+        internalTransferFrom(_from, _to, _tokenId);
+
+        // If _to is a contract, check for IERC721Receiver implementation
+        if (_to.code.length > 0) {
+            try IERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, "") returns (bytes4 retval) {
+                if (retval != IERC721Receiver.onERC721Received.selector) {
+                    revert ERC721InvalidReceiver(_to);
+                }
+            } catch (bytes memory reason) {
+                if (reason.length == 0) {
+                    // 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 safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata _data) external {
+        internalTransferFrom(_from, _to, _tokenId);
+        // If _to is a contract, check for IERC721Receiver implementation
+        if (_to.code.length > 0) {
+            try IERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data) returns (bytes4 retval) {
+                if (retval != IERC721Receiver.onERC721Received.selector) {
+                    revert ERC721InvalidReceiver(_to);
+                }
+            } catch (bytes memory reason) {
+                if (reason.length == 0) {
+                    // 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))
+                    }
+                }
+            }
+        }
+    }   
+}