drops stoneage Synthesizer

extracts IIPToken interface to be reused on Tokenizer and Permissioner
fixes linearization of dependencies on IPToken

Signed-off-by: Stefan Adolf <[email protected]>

Author: elmariachi111

script/dev/Synthesizer.s.sol

@@ -5,7 +5,9 @@ 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 { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
 import { IPermissioner, TermsAcceptedPermissioner } from "../../src/Permissioner.sol";
 import { CommonScript } from "./Common.sol";
@@ -60,3 +62,4 @@ contract FixtureTokenizer is CommonScript {
         console.log("IPTS_ADDRESS=%s", address(tokenContract));
     }
 }
+

script/dev/Tokenizer.s.sol

@@ -0,0 +1,18 @@
+// 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);
+}

src/IIPToken.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)
@@ -59,6 +55,10 @@ contract IPToken is ERC20BurnableUpgradeable, OwnableUpgradeable {
         return _metadata;
     }
 
+    function balanceOf(address account) public view override(ERC20Upgradeable, IIPToken) returns (uint256) {
+        return ERC20Upgradeable.balanceOf(account);
+    }
+
     /**
      * @notice the supply of IP Tokens is controlled by the tokenizer contract.
      * @param receiver address

src/IPToken.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()));
     }
 }

src/Permissioner.sol

@@ -8,7 +8,8 @@ import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/O
 import { ReentrancyGuardUpgradeable } from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import { IPNFT } from "./IPNFT.sol";
-import { IPToken, Metadata } from "./IPToken.sol";
+import { Metadata } from "./IIPToken.sol";
+import { IPToken } from "./IPToken.sol";
 import { Tokenizer, MustControlIpnft } from "./Tokenizer.sol";
 import { SchmackoSwap, ListingState } from "./SchmackoSwap.sol";
 import { IPermissioner, TermsAcceptedPermissioner } from "./Permissioner.sol";
@@ -133,7 +134,7 @@ contract SalesShareDistributor is UUPSUpgradeable, OwnableUpgradeable, Reentranc
      *         Requires the originalOwner to behave honestly / in favor of the IPT holders
      *         Requires the caller to have approved `paidPrice` of `paymentToken` to this contract
      *
-     * @param   tokenContract IPToken  the IPToken token contract
+     * @param   tokenContract IIPToken  the IPToken token contract
      * @param   paymentToken  IERC20   the payment token contract address
      * @param   paidPrice     uint256  the price the NFT has been sold for
      * @param   permissioner  IPermissioner   the permissioner that permits claims

src/SalesShareDistributor.sol

@@ -6,7 +6,8 @@ import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/O
 import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import { Clones } from "@openzeppelin/contracts/proxy/Clones.sol";
 import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
-import { IPToken, Metadata as TokenMetadata } from "./IPToken.sol";
+import { IIPToken, Metadata as TokenMetadata } from "./IIPToken.sol";
+import { IPToken } from "./IPToken.sol";
 import { WrappedIPToken } from "./WrappedIPToken.sol";
 
 import { IPermissioner } from "./Permissioner.sol";
@@ -33,14 +34,14 @@ contract Tokenizer is UUPSUpgradeable, OwnableUpgradeable, IControlIPTs {
         string symbol
     );
 
-    event TokenWrapped(IERC20Metadata tokenContract, IPToken wrappedIpt); 
-    event IPTokenImplementationUpdated(IPToken indexed old, IPToken indexed _new);
+    event TokenWrapped(IERC20Metadata tokenContract, IIPToken wrappedIpt);
+    event IPTokenImplementationUpdated(IIPToken indexed old, IIPToken indexed _new);
     event PermissionerUpdated(IPermissioner indexed old, IPermissioner indexed _new);
 
     IPNFT internal ipnft;
 
     /// @dev a map of all IPTs. We're staying with the the initial term "synthesized" to keep the storage layout intact
-    mapping(uint256 => IPToken) public synthesized;
+    mapping(uint256 => IIPToken) public synthesized;
 
     /// @dev not used, needed to ensure that storage slots are still in order after 1.1 -> 1.2, use ipTokenImplementation
     /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
@@ -105,7 +106,7 @@ contract Tokenizer is UUPSUpgradeable, OwnableUpgradeable, IControlIPTs {
         ipTokenImplementation = _ipTokenImplementation;
     }
 
-    /** 
+    /**
      * @dev sets legacy IPTs on the tokenized mapping
      */
     function reinit(WrappedIPToken _wrappedIpTokenImplementation) public onlyOwner reinitializer(6) {
@@ -158,12 +159,17 @@ contract Tokenizer is UUPSUpgradeable, OwnableUpgradeable, IControlIPTs {
         token.issue(_msgSender(), tokenAmount);
     }
 
-    function attachIpt(
-        uint256 ipnftId,
-        string memory agreementCid,
-        bytes calldata signedAgreement,
-        IERC20Metadata tokenContract
-    ) external {
+    /**
+     * @notice since 1.4 allows attaching an existing ERC20 contract as IPT
+     * @param ipnftId the token id on the underlying nft collection
+     * @param agreementCid a content hash that contains legal terms for IP token owners
+     * @param signedAgreement the sender's signature over the signed agreemeent text (must be created on the client)
+     * @return IPToken a wrapped IPToken that represents the tokenized ipnft for permissioners and carries metadata
+     */
+    function attachIpt(uint256 ipnftId, string memory agreementCid, bytes calldata signedAgreement, IERC20Metadata tokenContract)
+        external
+        returns (IIPToken)
+    {
         if (_msgSender() != controllerOf(ipnftId)) {
             revert MustControlIpnft();
         }
@@ -187,6 +193,7 @@ contract Tokenizer is UUPSUpgradeable, OwnableUpgradeable, IControlIPTs {
         );
         emit TokenWrapped(tokenContract, wrappedIpt);
         permissioner.accept(wrappedIpt, _msgSender(), signedAgreement);
+        return wrappedIpt;
     }
 
     /**