feat(tokenizer): allow erc20 attachment as ipt

- drops stoneage Synthesizer
- extracts IIPToken interface to be reused on Tokenizer and Permissioner
- fixes linearization of dependencies on IPToken
- adds general erc20 metadata fields to shared IPT interface
- wrapping test case
- rollout script and disable fork test
- drops size checks on builds
- add sanity checks for ipt attachment on tokenizer

Author: 0xmme

.github/workflows/test.yml

@@ -25,10 +25,11 @@ jobs:
       - name: Install node dependencies
         run: yarn --frozen-lockfile
 
+        #todo: forge build --sizes
       - name: Run Forge build
         run: |
           forge --version
-          forge build --sizes
+          forge build
         id: build
 
       - name: Run Forge tests

README.md

@@ -100,12 +100,12 @@ VDAO_TOKEN_ADDRESS=0x19A3036b828bffB5E14da2659E950E76f8e6BAA2
 
 ---
 
-### upgrading to Tokenizer 1.3
+### upgrading to Tokenizer 1.4
 
-forge script --private-key=$PRIVATE_KEY --rpc-url=$RPC_URL script/prod/RolloutTokenizerV13.s.sol --broadcast
+forge script --private-key=$PRIVATE_KEY --rpc-url=$RPC_URL script/prod/RolloutTokenizerV14.s.sol --broadcast
 
-// 0xTokenizer 0xNewImpl 0xNewTokenImpl
-cast send --rpc-url=$RPC_URL --private-key=$PRIVATE_KEY 0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e "upgradeToAndCall(address,bytes)" 0x70e0bA845a1A0F2DA3359C97E0285013525FFC49 0x84646c1f000000000000000000000000998abeb3e57409262ae5b751f60747921b33613e
+// 0xTokenizer (address, bytes)(0xNewImpl, 0xNewWrappedIPTokenImpl 0xNewIPTokenImpl)
+cast send --rpc-url=$RPC_URL --private-key=$PRIVATE_KEY 0x58EB89C69CB389DBef0c130C6296ee271b82f436 "upgradeToAndCall(address,bytes)" 0x34A1D3fff3958843C43aD80F30b94c510645C316 0x8b3d19bb0000000000000000000000007fa9385be102ac3eac297483dd6233d62b3e14960000000000000000000000005b73c5498c1e3b4dba84de0f1833c4a029d90519
 
 ### Timelocked Tokens
 

script/dev/Synthesizer.s.sol

@@ -5,7 +5,10 @@ import "forge-std/Script.sol";
 import "forge-std/console.sol";
 import { IPNFT } from "../../src/IPNFT.sol";
 import { Tokenizer } from "../../src/Tokenizer.sol";
-import { Metadata, IPToken } from "../../src/IPToken.sol";
+import { Metadata } from "../../src/IIPToken.sol";
+import { IPToken } from "../../src/IPToken.sol";
+import { WrappedIPToken } from "../../src/WrappedIPToken.sol";
+
 import { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
 import { IPermissioner, TermsAcceptedPermissioner } from "../../src/Permissioner.sol";
 import { CommonScript } from "./Common.sol";
@@ -23,9 +26,13 @@ contract DeployTokenizer is CommonScript {
         IPToken initialIpTokenImplementation = new IPToken();
         tokenizer.setIPTokenImplementation(initialIpTokenImplementation);
 
+        WrappedIPToken initialWrappedIpTokenImplementation = new WrappedIPToken();
+        tokenizer.setWrappedIPTokenImplementation(initialWrappedIpTokenImplementation);
+
         vm.stopBroadcast();
         console.log("TOKENIZER_ADDRESS=%s", address(tokenizer));
         console.log("iptoken implementation=%s", address(initialIpTokenImplementation));
+        console.log("wrapped iptoken implementation=%s", address(initialWrappedIpTokenImplementation));
     }
 }
 

script/dev/Tokenizer.s.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import "forge-std/Script.sol";
+import { Tokenizer } from "../../src/Tokenizer.sol";
+import { IPToken } from "../../src/IPToken.sol";
+import { WrappedIPToken } from "../../src/WrappedIPToken.sol";
+import { console } from "forge-std/console.sol";
+
+contract RolloutTokenizerV14 is Script {
+    function run() public {
+        vm.startBroadcast();
+
+        // Deploy new implementations
+        IPToken ipTokenImplementation = new IPToken();
+        WrappedIPToken wrappedIpTokenImplementation = new WrappedIPToken();
+        Tokenizer newTokenizerImplementation = new Tokenizer();
+
+        // Prepare upgrade call data using reinit function
+        bytes memory upgradeCallData =
+            abi.encodeWithSelector(Tokenizer.reinit.selector, address(wrappedIpTokenImplementation), address(ipTokenImplementation));
+
+        console.log("IPTOKENIMPLEMENTATION=%s", address(ipTokenImplementation));
+        console.log("WRAPPEDTOKENIMPLEMENTATION=%s", address(wrappedIpTokenImplementation));
+        console.log("NEWTOKENIZER=%s", address(newTokenizerImplementation));
+        console.log("UpgradeCallData:");
+        console.logBytes(upgradeCallData);
+
+        vm.stopBroadcast();
+    }
+}

script/prod/RolloutTokenizerV13.s.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8;
+
+struct Metadata {
+    uint256 ipnftId;
+    address originalOwner;
+    string agreementCid;
+}
+
+interface IIPToken {
+    /// @notice the amount of tokens that ever have been issued (not necessarily == supply)
+    function totalIssued() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function metadata() external view returns (Metadata memory);
+    function issue(address, uint256) external;
+    function cap() external;
+    function uri() external view returns (string memory);
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
+    function decimals() external view returns (uint8);
+}

script/prod/RolloutTokenizerV14.s.sol

@@ -1,18 +1,14 @@
 // 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";
-
-struct Metadata {
-    uint256 ipnftId;
-    address originalOwner;
-    string agreementCid;
-}
+import { IIPToken, Metadata } from "./IIPToken.sol";
 
 error TokenCapped();
 
@@ -24,7 +20,7 @@ error TokenCapped();
  *         The owner can increase the token supply as long as it's not explicitly capped.
  * @dev formerly known as "molecules"
  */
-contract IPToken is ERC20BurnableUpgradeable, OwnableUpgradeable {
+contract IPToken is IIPToken, ERC20Upgradeable, ERC20BurnableUpgradeable, OwnableUpgradeable {
     event Capped(uint256 atSupply);
 
     /// @notice the amount of tokens that ever have been issued (not necessarily == supply)
@@ -35,12 +31,12 @@ contract IPToken is ERC20BurnableUpgradeable, OwnableUpgradeable {
 
     Metadata internal _metadata;
 
-    function initialize(uint256 ipnftId, string calldata name, string calldata symbol, address originalOwner, string memory agreementCid)
+    function initialize(uint256 ipnftId, string calldata name_, string calldata symbol_, address originalOwner, string memory agreementCid)
         external
         initializer
     {
         __Ownable_init();
-        __ERC20_init(name, symbol);
+        __ERC20_init(name_, symbol_);
         _metadata = Metadata({ ipnftId: ipnftId, originalOwner: originalOwner, agreementCid: agreementCid });
     }
 
@@ -59,11 +55,27 @@ contract IPToken is ERC20BurnableUpgradeable, OwnableUpgradeable {
         return _metadata;
     }
 
+    function balanceOf(address account) public view override(ERC20Upgradeable, IIPToken) returns (uint256) {
+        return ERC20Upgradeable.balanceOf(account);
+    }
+
+    function name() public view override(ERC20Upgradeable, IIPToken) returns (string memory) {
+        return ERC20Upgradeable.name();
+    }
+
+    function symbol() public view override(ERC20Upgradeable, IIPToken) returns (string memory) {
+        return ERC20Upgradeable.symbol();
+    }
+
+    function decimals() public view override(ERC20Upgradeable, IIPToken) 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 {
         if (capped) {
             revert TokenCapped();
@@ -109,7 +121,7 @@ contract IPToken is ERC20BurnableUpgradeable, OwnableUpgradeable {
                     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.to","image": "",',
+                        '","description": "IP Tokens, derived from IP-NFTs, are ERC-20 tokens governing IP pools.","decimals": 18,"external_url": "https://molecule.xyz","image": "",',
                         props,
                         "}"
                     )

src/IIPToken.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.18;
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
 import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import { SignatureChecker } from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
-import { IPToken, Metadata } from "./IPToken.sol";
+import { IIPToken, Metadata } from "./IIPToken.sol";
 
 error InvalidSignature();
 error Denied();
@@ -16,17 +16,17 @@ interface IPermissioner {
      * @param _for address
      * @param data bytes
      */
-    function accept(IPToken tokenContract, address _for, bytes calldata data) external;
+    function accept(IIPToken tokenContract, address _for, bytes calldata data) external;
 }
 
 contract BlindPermissioner is IPermissioner {
-    function accept(IPToken tokenContract, address _for, bytes calldata data) external {
+    function accept(IIPToken tokenContract, address _for, bytes calldata data) external {
         //empty
     }
 }
 
 contract ForbidAllPermissioner is IPermissioner {
-    function accept(IPToken, address, bytes calldata) external pure {
+    function accept(IIPToken, address, bytes calldata) external pure {
         revert Denied();
     }
 }
@@ -44,7 +44,7 @@ contract TermsAcceptedPermissioner is IPermissioner {
      * @param _for address the account that has created `signature`
      * @param signature bytes encoded signature, for eip155: `abi.encodePacked(r, s, v)`
      */
-    function accept(IPToken tokenContract, address _for, bytes calldata signature) external {
+    function accept(IIPToken tokenContract, address _for, bytes calldata signature) external {
         if (!isValidSignature(tokenContract, _for, signature)) {
             revert InvalidSignature();
         }
@@ -55,7 +55,7 @@ contract TermsAcceptedPermissioner is IPermissioner {
      * @notice checks whether `signer`'s `signature` of `specificTermsV1` on `tokenContract.metadata.ipnftId` is valid
      * @param tokenContract IPToken
      */
-    function isValidSignature(IPToken tokenContract, address signer, bytes calldata signature) public view returns (bool) {
+    function isValidSignature(IIPToken tokenContract, address signer, bytes calldata signature) public view returns (bool) {
         bytes32 termsHash = ECDSA.toEthSignedMessageHash(bytes(specificTermsV1(tokenContract)));
         return SignatureChecker.isValidSignatureNow(signer, termsHash, signature);
     }
@@ -78,7 +78,7 @@ contract TermsAcceptedPermissioner is IPermissioner {
      * @notice this yields the message text that claimers must present to proof they have accepted all terms
      * @param tokenContract IPToken
      */
-    function specificTermsV1(IPToken tokenContract) public view returns (string memory) {
+    function specificTermsV1(IIPToken tokenContract) public view returns (string memory) {
         return (specificTermsV1(tokenContract.metadata()));
     }
 }