refactor: shared ipt functions into lib

0xmme · 0xmme · commit 2fec1e19e69d · 2025-09-23T17:11:30.000+02:00
diff --git a/src/IPToken.sol b/src/IPToken.sol
@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.18;
 
-import { ERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
-import { ERC20BurnableUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol";
-import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
-import { Base64 } from "@openzeppelin/contracts/utils/Base64.sol";
-import { Tokenizer, MustControlIpnft } from "./Tokenizer.sol";
 import { IControlIPTs } from "./IControlIPTs.sol";
 import { IIPToken, Metadata } from "./IIPToken.sol";
+import { MustControlIpnft, Tokenizer } from "./Tokenizer.sol";
+import { IPTokenUtils } from "./libraries/IPTokenUtils.sol";
+import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import { ERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+import { ERC20BurnableUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol";
 
 error TokenCapped();
 
@@ -51,32 +50,53 @@ contract IPToken is IIPToken, ERC20Upgradeable, ERC20BurnableUpgradeable, Ownabl
         _;
     }
 
-    function metadata() external view returns (Metadata memory) {
+    function metadata() external view override returns (Metadata memory) {
         return _metadata;
     }
 
-    function balanceOf(address account) public view override(ERC20Upgradeable, IIPToken) returns (uint256) {
+    // Override ERC20 functions to resolve diamond inheritance
+    function totalSupply() public view override returns (uint256) {
+        return ERC20Upgradeable.totalSupply();
+    }
+
+    function balanceOf(address account) public view override returns (uint256) {
         return ERC20Upgradeable.balanceOf(account);
     }
 
-    function name() public view override(ERC20Upgradeable, IIPToken) returns (string memory) {
+    function transfer(address to, uint256 amount) public override returns (bool) {
+        return ERC20Upgradeable.transfer(to, amount);
+    }
+
+    function allowance(address owner, address spender) public view override returns (uint256) {
+        return ERC20Upgradeable.allowance(owner, spender);
+    }
+
+    function approve(address spender, uint256 amount) public override returns (bool) {
+        return ERC20Upgradeable.approve(spender, amount);
+    }
+
+    function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
+        return ERC20Upgradeable.transferFrom(from, to, amount);
+    }
+
+    function name() public view override returns (string memory) {
         return ERC20Upgradeable.name();
     }
 
-    function symbol() public view override(ERC20Upgradeable, IIPToken) returns (string memory) {
+    function symbol() public view override returns (string memory) {
         return ERC20Upgradeable.symbol();
     }
 
-    function decimals() public view override(ERC20Upgradeable, IIPToken) returns (uint8) {
+    function decimals() public view override returns (uint8) {
         return ERC20Upgradeable.decimals();
     }
+
     /**
      * @notice the supply of IP Tokens is controlled by the tokenizer contract.
      * @param receiver address
      * @param amount uint256
      */
-
-    function issue(address receiver, uint256 amount) external onlyTokenizerOrIPNFTController {
+    function issue(address receiver, uint256 amount) external override onlyTokenizerOrIPNFTController {
         if (capped) {
             revert TokenCapped();
         }
@@ -87,7 +107,7 @@ contract IPToken is IIPToken, ERC20Upgradeable, ERC20BurnableUpgradeable, Ownabl
     /**
      * @notice mark this token as capped. After calling this, no new tokens can be `issue`d
      */
-    function cap() external onlyTokenizerOrIPNFTController {
+    function cap() external override onlyTokenizerOrIPNFTController {
         capped = true;
         emit Capped(totalIssued);
     }
@@ -96,37 +116,7 @@ contract IPToken is IIPToken, ERC20Upgradeable, ERC20BurnableUpgradeable, Ownabl
      * @notice contract metadata, compatible to ERC1155
      * @return string base64 encoded data url
      */
-    function uri() external view returns (string memory) {
-        string memory tokenId = Strings.toString(_metadata.ipnftId);
-
-        string memory props = string.concat(
-            '"properties": {',
-            '"ipnft_id": ',
-            tokenId,
-            ',"agreement_content": "ipfs://',
-            _metadata.agreementCid,
-            '","original_owner": "',
-            Strings.toHexString(_metadata.originalOwner),
-            '","erc20_contract": "',
-            Strings.toHexString(address(this)),
-            '","supply": "',
-            Strings.toString(totalIssued),
-            '"}'
-        );
-
-        return string.concat(
-            "data:application/json;base64,",
-            Base64.encode(
-                bytes(
-                    string.concat(
-                        '{"name": "IP Tokens of IPNFT #',
-                        tokenId,
-                        '","description": "IP Tokens, derived from IP-NFTs, are ERC-20 tokens governing IP pools.","decimals": 18,"external_url": "https://molecule.xyz","image": "",',
-                        props,
-                        "}"
-                    )
-                )
-            )
-        );
+    function uri() external view override returns (string memory) {
+        return IPTokenUtils.generateURI(_metadata, address(this), totalIssued);
     }
 }
diff --git a/src/WrappedIPToken.sol b/src/WrappedIPToken.sol
@@ -2,11 +2,9 @@
 pragma solidity 0.8.18;
 
 import { IIPToken, Metadata } from "./IIPToken.sol";
-
+import { IPTokenUtils } from "./libraries/IPTokenUtils.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import { Base64 } from "@openzeppelin/contracts/utils/Base64.sol";
-import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 
 /**
  * @title WrappedIPToken
@@ -38,32 +36,52 @@ contract WrappedIPToken is IIPToken, Initializable {
     /**
      * @dev Returns the name of the token.
      */
-    function name() public view override returns (string memory) {
+    function name() public view returns (string memory) {
         return wrappedToken.name();
     }
 
     /**
      * @dev Returns the symbol of the token.
      */
-    function symbol() public view override returns (string memory) {
+    function symbol() public view returns (string memory) {
         return wrappedToken.symbol();
     }
 
     /**
      * @dev Returns the decimals places of the token.
      */
-    function decimals() public view override returns (uint8) {
+    function decimals() public view returns (uint8) {
         return wrappedToken.decimals();
     }
 
-    function totalIssued() public view override returns (uint256) {
+    function totalSupply() public view returns (uint256) {
         return wrappedToken.totalSupply();
     }
 
-    function balanceOf(address account) public view override returns (uint256) {
+    function balanceOf(address account) public view returns (uint256) {
         return wrappedToken.balanceOf(account);
     }
 
+    function transfer(address to, uint256 amount) public returns (bool) {
+        return wrappedToken.transfer(to, amount);
+    }
+
+    function allowance(address owner, address spender) public view returns (uint256) {
+        return wrappedToken.allowance(owner, spender);
+    }
+
+    function approve(address spender, uint256 amount) public returns (bool) {
+        return wrappedToken.approve(spender, amount);
+    }
+
+    function transferFrom(address from, address to, uint256 amount) public returns (bool) {
+        return wrappedToken.transferFrom(from, to, amount);
+    }
+
+    function totalIssued() public view override returns (uint256) {
+        return wrappedToken.totalSupply();
+    }
+
     function issue(address, uint256) public virtual override {
         revert("WrappedIPToken: cannot issue");
     }
@@ -73,38 +91,6 @@ contract WrappedIPToken is IIPToken, Initializable {
     }
 
     function uri() external view override returns (string memory) {
-        string memory tokenId = Strings.toString(_metadata.ipnftId);
-
-        string memory props = string.concat(
-            '"properties": {',
-            '"ipnft_id": ',
-            tokenId,
-            ',"agreement_content": "ipfs://',
-            _metadata.agreementCid,
-            '","original_owner": "',
-            Strings.toHexString(_metadata.originalOwner),
-            '","erc20_contract": "',
-            Strings.toHexString(address(wrappedToken)),
-            '","supply": "',
-            Strings.toString(wrappedToken.totalSupply()),
-            '"}'
-        );
-
-        return string.concat(
-            "data:application/json;base64,",
-            Base64.encode(
-                bytes(
-                    string.concat(
-                        '{"name": "IP Tokens of IPNFT #',
-                        tokenId,
-                        '","description": "IP Tokens, derived from IP-NFTs, are ERC-20 tokens governing IP pools.","decimals": ',
-                        Strings.toString(wrappedToken.decimals()),
-                        ',"external_url": "https://molecule.xyz","image": "",',
-                        props,
-                        "}"
-                    )
-                )
-            )
-        );
+        return IPTokenUtils.generateURI(_metadata, address(wrappedToken), wrappedToken.totalSupply());
     }
 }
diff --git a/src/libraries/IPTokenUtils.sol b/src/libraries/IPTokenUtils.sol
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8;
+
+import { Metadata } from "../IIPToken.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import { Base64 } from "@openzeppelin/contracts/utils/Base64.sol";
+import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
+
+/// @title IP Token Utilities Library
+/// @notice Shared utilities for IP Token contracts
+/// @dev Contains common functions used by both IPToken and WrappedIPToken
+library IPTokenUtils {
+    /// @notice Generates a base64-encoded data URL containing token metadata
+    /// @param metadata_ The metadata struct containing IPNFT information
+    /// @param tokenContract The ERC20 token contract address
+    /// @param supply The token supply to include in metadata
+    /// @return The complete data URL string
+    function generateURI(Metadata memory metadata_, address tokenContract, uint256 supply) internal view returns (string memory) {
+        string memory tokenId = Strings.toString(metadata_.ipnftId);
+
+        string memory props = string.concat(
+            '"properties": {',
+            '"ipnft_id": ',
+            tokenId,
+            ',"agreement_content": "ipfs://',
+            metadata_.agreementCid,
+            '","original_owner": "',
+            Strings.toHexString(metadata_.originalOwner),
+            '","erc20_contract": "',
+            Strings.toHexString(tokenContract),
+            '","supply": "',
+            Strings.toString(supply),
+            '"}'
+        );
+
+        return string.concat(
+            "data:application/json;base64,",
+            Base64.encode(
+                bytes(
+                    string.concat(
+                        '{"name": "IP Tokens of IPNFT #',
+                        tokenId,
+                        '","description": "IP Tokens, derived from IP-NFTs, are ERC-20 tokens governing IP pools.","decimals": ',
+                        Strings.toString(IERC20Metadata(tokenContract).decimals()),
+                        ',"external_url": "https://molecule.xyz","image": "",',
+                        props,
+                        "}"
+                    )
+                )
+            )
+        );
+    }
+}
diff --git a/test/Forking/Tokenizer14UpgradeForkTest.t.sol b/test/Forking/Tokenizer14UpgradeForkTest.t.sol
@@ -8,17 +8,21 @@ import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/
 
 import { IPNFT } from "../../src/IPNFT.sol";
 
-import { MustControlIpnft, AlreadyTokenized, Tokenizer } from "../../src/Tokenizer.sol";
-import { Tokenizer13 } from "../../src/helpers/test-upgrades/Tokenizer13.sol";
-import { IPToken13 } from "../../src/helpers/test-upgrades/IPToken13.sol";
-import { IPToken, TokenCapped } from "../../src/IPToken.sol";
 import { Metadata } from "../../src/IIPToken.sol";
-import { OnlyIssuerOrOwner } from "../../src/helpers/test-upgrades/IPToken12.sol";
+
 import { IIPToken } from "../../src/IIPToken.sol";
+import { IPToken, TokenCapped } from "../../src/IPToken.sol";
+
+import { BlindPermissioner, IPermissioner } from "../../src/Permissioner.sol";
+import { AlreadyTokenized, MustControlIpnft, Tokenizer } from "../../src/Tokenizer.sol";
 import { WrappedIPToken } from "../../src/WrappedIPToken.sol";
-import { IPermissioner, BlindPermissioner } from "../../src/Permissioner.sol";
-import { AcceptAllAuthorizer } from "../helpers/AcceptAllAuthorizer.sol";
+
 import { FakeERC20 } from "../../src/helpers/FakeERC20.sol";
+import { OnlyIssuerOrOwner } from "../../src/helpers/test-upgrades/IPToken12.sol";
+import { IPToken13 } from "../../src/helpers/test-upgrades/IPToken13.sol";
+import { Tokenizer13 } from "../../src/helpers/test-upgrades/Tokenizer13.sol";
+
+import { AcceptAllAuthorizer } from "../helpers/AcceptAllAuthorizer.sol";
 
 contract Tokenizer14UpgradeForkTest is Test {
     using SafeERC20Upgradeable for IPToken;
@@ -270,10 +274,10 @@ contract Tokenizer14UpgradeForkTest is Test {
         IIPToken iiptToken = IIPToken(address(newToken));
 
         // Test interface functions work
-        assertEq(iiptToken.name(), string.concat("IP Tokens of IPNFT #", vm.toString(newIpnftId)));
-        assertEq(iiptToken.symbol(), "NEW-IPT");
-        assertEq(iiptToken.decimals(), 18);
-        assertEq(iiptToken.balanceOf(alice), 1_000_000 ether);
+        assertEq(newToken.name(), string.concat("IP Tokens of IPNFT #", vm.toString(newIpnftId)));
+        assertEq(newToken.symbol(), "NEW-IPT");
+        assertEq(newToken.decimals(), 18);
+        assertEq(newToken.balanceOf(alice), 1_000_000 ether);
         assertEq(iiptToken.totalIssued(), 1_000_000 ether);
 
         // Test that metadata is accessible through interface
@@ -337,11 +341,8 @@ contract Tokenizer14UpgradeForkTest is Test {
         // Test that both IPToken and IIPToken interfaces work identically
         IIPToken interfaceToken = IIPToken(address(newToken));
 
-        // Compare results from both interfaces
-        assertEq(newToken.name(), interfaceToken.name());
-        assertEq(newToken.symbol(), interfaceToken.symbol());
-        assertEq(newToken.decimals(), interfaceToken.decimals());
-        assertEq(newToken.balanceOf(alice), interfaceToken.balanceOf(alice));
+        // Compare results from both interfaces (only IP-specific functions available on interface)
+        assertEq(newToken.totalIssued(), interfaceToken.totalIssued());
         assertEq(newToken.totalIssued(), interfaceToken.totalIssued());
 
         // Test metadata access
@@ -386,10 +387,11 @@ contract Tokenizer14UpgradeForkTest is Test {
         assertEq(address(tokenizer14.synthesized(newIpnftId)), address(wrappedToken));
 
         // Test the wrapped token implements IIPToken interface
-        assertEq(wrappedToken.name(), "Test Wrapped Token");
-        assertEq(wrappedToken.symbol(), "TWT");
-        assertEq(wrappedToken.decimals(), 18);
-        assertEq(wrappedToken.balanceOf(alice), 5_000_000 ether);
+        WrappedIPToken wrappedImpl = WrappedIPToken(address(wrappedToken));
+        assertEq(wrappedImpl.name(), "Test Wrapped Token");
+        assertEq(wrappedImpl.symbol(), "TWT");
+        assertEq(wrappedImpl.decimals(), 18);
+        assertEq(wrappedImpl.balanceOf(alice), 5_000_000 ether);
         assertEq(wrappedToken.totalIssued(), 5_000_000 ether);
 
         // Test metadata is accessible through interface
diff --git a/test/TokenizerWrapped.t.sol b/test/TokenizerWrapped.t.sol
