How to make a XRC-20 Royalty Token with Foundry

how-to/XRC20/Foundry/Contract.flattened.sol

@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.14;
+
+/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
+/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
+/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
+/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
+abstract contract ERC20 {
+    /*//////////////////////////////////////////////////////////////
+                                 EVENTS
+    //////////////////////////////////////////////////////////////*/
+
+    event Transfer(address indexed from, address indexed to, uint256 amount);
+
+    event Approval(address indexed owner, address indexed spender, uint256 amount);
+
+    /*//////////////////////////////////////////////////////////////
+                            METADATA STORAGE
+    //////////////////////////////////////////////////////////////*/
+
+    string public name;
+
+    string public symbol;
+
+    uint8 public immutable decimals;
+
+    /*//////////////////////////////////////////////////////////////
+                              ERC20 STORAGE
+    //////////////////////////////////////////////////////////////*/
+
+    uint256 public totalSupply;
+
+    mapping(address => uint256) public balanceOf;
+
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    /*//////////////////////////////////////////////////////////////
+                            EIP-2612 STORAGE
+    //////////////////////////////////////////////////////////////*/
+
+    uint256 internal immutable INITIAL_CHAIN_ID;
+
+    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
+
+    mapping(address => uint256) public nonces;
+
+    /*//////////////////////////////////////////////////////////////
+                               CONSTRUCTOR
+    //////////////////////////////////////////////////////////////*/
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        uint8 _decimals
+    ) {
+        name = _name;
+        symbol = _symbol;
+        decimals = _decimals;
+
+        INITIAL_CHAIN_ID = block.chainid;
+        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                               ERC20 LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function approve(address spender, uint256 amount) public virtual returns (bool) {
+        allowance[msg.sender][spender] = amount;
+
+        emit Approval(msg.sender, spender, amount);
+
+        return true;
+    }
+
+    function transfer(address to, uint256 amount) public virtual returns (bool) {
+        balanceOf[msg.sender] -= amount;
+
+        // Cannot overflow because the sum of all user
+        // balances can't exceed the max uint256 value.
+        unchecked {
+            balanceOf[to] += amount;
+        }
+
+        emit Transfer(msg.sender, to, amount);
+
+        return true;
+    }
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) public virtual returns (bool) {
+        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
+
+        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
+
+        balanceOf[from] -= amount;
+
+        // Cannot overflow because the sum of all user
+        // balances can't exceed the max uint256 value.
+        unchecked {
+            balanceOf[to] += amount;
+        }
+
+        emit Transfer(from, to, amount);
+
+        return true;
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                             EIP-2612 LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function permit(
+        address owner,
+        address spender,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) public virtual {
+        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
+
+        // Unchecked because the only math done is incrementing
+        // the owner's nonce which cannot realistically overflow.
+        unchecked {
+            address recoveredAddress = ecrecover(
+                keccak256(
+                    abi.encodePacked(
+                        "\x19\x01",
+                        DOMAIN_SEPARATOR(),
+                        keccak256(
+                            abi.encode(
+                                keccak256(
+                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
+                                ),
+                                owner,
+                                spender,
+                                value,
+                                nonces[owner]++,
+                                deadline
+                            )
+                        )
+                    )
+                ),
+                v,
+                r,
+                s
+            );
+
+            require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
+
+            allowance[recoveredAddress][spender] = value;
+        }
+
+        emit Approval(owner, spender, value);
+    }
+
+    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
+        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
+    }
+
+    function computeDomainSeparator() internal view virtual returns (bytes32) {
+        return
+            keccak256(
+                abi.encode(
+                    keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
+                    keccak256(bytes(name)),
+                    keccak256("1"),
+                    block.chainid,
+                    address(this)
+                )
+            );
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                        INTERNAL MINT/BURN LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function _mint(address to, uint256 amount) internal virtual {
+        totalSupply += amount;
+
+        // Cannot overflow because the sum of all user
+        // balances can't exceed the max uint256 value.
+        unchecked {
+            balanceOf[to] += amount;
+        }
+
+        emit Transfer(address(0), to, amount);
+    }
+
+    function _burn(address from, uint256 amount) internal virtual {
+        balanceOf[from] -= amount;
+
+        // Cannot underflow because a user's balance
+        // will never be larger than the total supply.
+        unchecked {
+            totalSupply -= amount;
+        }
+
+        emit Transfer(from, address(0), amount);
+    }
+}
+
+contract RoyaltyToken is ERC20 {
+
+    address public royaltyAddress;
+    uint256 public royaltyFeePercentage;
+
+    constructor(
+        string memory _name, 
+        string memory _symbol, 
+        uint8 _decimals,
+        uint256 _royaltyFeePercentage,
+        uint256 _initialSupply
+    ) ERC20(_name, _symbol, _decimals) {
+        royaltyAddress = msg.sender;
+        royaltyFeePercentage = _royaltyFeePercentage;
+        _mint(msg.sender, _initialSupply);
+    }
+
+    function transferWithRoyalty (address to, uint256 amount) public returns (bool) {
+        uint256 royaltyAmount = amount * royaltyFeePercentage / 100;
+
+        transfer(royaltyAddress, royaltyAmount);
+
+        transfer(to, amount - royaltyAmount);
+
+        return true;
+    }
+
+    function transfer(address to, uint256 amount) public virtual override returns (bool) {
+        uint256 royaltyAmount = amount * royaltyFeePercentage / 100;
+
+        balanceOf[msg.sender] -= amount;
+
+        // Cannot overflow because the sum of all user
+        // balances can't exceed the max uint256 value.
+        unchecked {
+            balanceOf[to] += amount - royaltyAmount;
+            balanceOf[royaltyAddress] += royaltyAmount;
+        }
+        //transfer to the royalty address
+        emit Transfer(msg.sender, royaltyAddress, royaltyAmount);
+        //transfer to the original address
+        emit Transfer(msg.sender, to, amount - royaltyAmount);
+
+        return true;
+    }
+}

how-to/XRC20/Foundry/RoyaltyToken.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.14;
+
+import { ERC20 } from "solmate/tokens/ERC20.sol";
+
+contract RoyaltyToken is ERC20 {
+
+    address public royaltyAddress;
+    uint256 public royaltyFeePercentage;
+
+    constructor(
+        string memory _name, 
+        string memory _symbol, 
+        uint8 _decimals,
+        uint256 _royaltyFeePercentage,
+        uint256 _initialSupply
+    ) ERC20(_name, _symbol, _decimals) {
+        royaltyAddress = msg.sender;
+        royaltyFeePercentage = _royaltyFeePercentage;
+        _mint(msg.sender, _initialSupply);
+    }
+
+    function transferWithRoyalty (address to, uint256 amount) public returns (bool) {
+        uint256 royaltyAmount = amount * royaltyFeePercentage / 100;
+
+        transfer(royaltyAddress, royaltyAmount);
+
+        transfer(to, amount - royaltyAmount);
+
+        return true;
+    }
+
+    function transfer(address to, uint256 amount) public virtual override returns (bool) {
+        uint256 royaltyAmount = amount * royaltyFeePercentage / 100;
+
+        balanceOf[msg.sender] -= amount;
+
+        // Cannot overflow because the sum of all user
+        // balances can't exceed the max uint256 value.
+        unchecked {
+            balanceOf[to] += amount - royaltyAmount;
+            balanceOf[royaltyAddress] += royaltyAmount;
+        }
+        //transfer to the royalty address
+        emit Transfer(msg.sender, royaltyAddress, royaltyAmount);
+        //transfer to the original address
+        emit Transfer(msg.sender, to, amount - royaltyAmount);
+
+        return true;
+    }
+}

how-to/XRC20/Foundry/RoyaltyToken.t.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.14;
+
+import {RoyaltyToken} from "src//RoyaltyToken.sol";
+
+import "forge-std/Test.sol";
+
+contract RoyaltyTokenTest is Test {
+    RoyaltyToken public token;
+    uint256 public royaltyFeePercentage = 2;
+    uint256 public initialSupply = 10 ** 4;
+
+
+    function setUp() public {
+       token = new RoyaltyToken("RoyaltyToken", "ROYT", 18, royaltyFeePercentage, initialSupply);
+    }
+
+    function testTransfer() public {
+        address alice = address(1);
+        address bob = address(2);
+
+        token.transfer(alice, 1000);
+
+        assertEq(token.balanceOf(alice), 980);
+        assertEq(token.balanceOf(address(this)), 9020);
+
+        hoax(alice);
+        token.transfer(bob, 100);
+
+        assertEq(token.balanceOf(alice), 880);
+        assertEq(token.balanceOf(bob), 98);
+        assertEq(token.balanceOf(address(this)), 9022);
+    }
+}