Improved Unit & Integration Test

contracts/interfaces/ip-org/IIPOrg.sol

@@ -6,7 +6,6 @@ import { IPAsset } from "contracts/lib/IPAsset.sol";
 
 /// @notice IP Org Interface
 interface IIPOrg {
-
     /// @notice Returns the current owner of the IP asset within th IP Org.
     function ownerOf(uint256 id) external view returns (address);
 
@@ -37,4 +36,8 @@ interface IIPOrg {
     /// @notice Returns the Ip Org asset type for a given IP Org asset.
     function ipOrgAssetType(uint256 id_) external view returns (uint8);
 
+    /// @notice Gets the global IP asset id associated with this IP Org asset.
+    /// @param id_ The local id of the IP Org wrapped IP asset.
+    /// @return The global identifier of the IP asset.
+    function ipAssetId(uint256 id_) external returns (uint256);
 }

contracts/ip-org/IPOrg.sol

@@ -85,11 +85,11 @@ contract IPOrg is
     }
 
     /// @notice Gets the global IP asset id associated with this IP Org asset.
-    /// @param id The local id of the IP Org wrapped IP asset.
+    /// @param id_ The local id of the IP Org wrapped IP asset.
     /// @return The global identifier of the IP asset.
-    function ipAssetId(uint256 id) public returns (uint256) {
+    function ipAssetId(uint256 id_) public returns (uint256) {
         address registrationModule = address(MODULE_REGISTRY.protocolModule(REGISTRATION_MODULE_KEY));
-        return IRegistrationModule(registrationModule).ipAssetId(address(this), id);
+        return IRegistrationModule(registrationModule).ipAssetId(address(this), id_);
     }
 
     /// @notice Initializes an IP Org.

contracts/ip-org/IPOrgController.sol

@@ -208,15 +208,6 @@ contract IPOrgController is
         }
     }
 
-    /// @dev Checks whether an IP Org exists, throwing if not.
-    /// @param ipOrg_ The address of the IP Org being queried.
-    function _assertIPOrgExists(address ipOrg_) internal view {
-        IPOrgControllerStorage storage $ = _getIpOrgControllerStorage();
-        if (!$.ipOrgs[ipOrg_].registered) {
-            revert Errors.IPOrgController_IPOrgNonExistent();
-        }
-    }
-
     /// @dev Authorizes upgrade to a new contract address via UUPS.
     function _authorizeUpgrade(address) 
         internal 

contracts/lib/Errors.sol

@@ -293,6 +293,7 @@ library Errors {
     error LicensingModule_InvalidAction();
     error LicensingModule_CallerNotLicensor();
     error LicensingModule_ParentLicenseNotActive();
+    error LicensingModule_DerivativeNotAllowed();
     error LicensingModule_InvalidIpa();
     error LicensingModule_CallerNotLicenseOwner();
     error LicensingModule_CantFindParentLicenseOrRelatedIpa();

contracts/modules/licensing/LicenseRegistry.sol

@@ -202,6 +202,10 @@ contract LicenseRegistry is ERC721 {
         return _licenses[id_].isReciprocal;
     }
 
+    function isDerivativeAllowed(uint256 id_) external view returns (bool) {
+        return _licenses[id_].derivativesAllowed;
+    }
+
     function derivativeNeedsApproval(uint256 id_) external view returns (bool) {
         return _licenses[id_].derivativeNeedsApproval;
     }

contracts/modules/licensing/LicensingModule.sol

@@ -139,6 +139,9 @@ contract LicensingModule is BaseModule, ILicensingModule {
             if (!LICENSE_REGISTRY.isLicenseActive(input.parentLicenseId)) {
                 revert Errors.LicensingModule_ParentLicenseNotActive();
             }
+            if (!LICENSE_REGISTRY.isDerivativeAllowed(input.parentLicenseId)) {
+                revert Errors.LicensingModule_DerivativeNotAllowed();
+            }
         }
         // If this is a derivative and parent is reciprocal, license parameters
         // cannot be changed in the new license
@@ -159,8 +162,7 @@ contract LicensingModule is BaseModule, ILicensingModule {
                     )
                 );
         } else {
-            // If this is not a derivative, or parent is not reciprocal, caller must be
-            // the licensor
+            // If this is not a derivative, or parent is not reciprocal, caller must be the licensor
             if (licensor != caller_) {
                 revert Errors.LicensingModule_CallerNotLicensor();
             }
@@ -196,14 +198,23 @@ contract LicensingModule is BaseModule, ILicensingModule {
             bool derivativesAllowed,
             bool isReciprocal,
             bool derivativeNeedsApproval
-        ) = _parseLicenseParameters(
-            ipOrg_,
-            input.params,
-            supportedParams
-        );
+        ) = _parseLicenseParameters(ipOrg_, input.params, supportedParams);
+
+        Licensing.LicenseStatus newLicenseStatus;
+        if (
+            input.parentLicenseId != 0 &&
+            LICENSE_REGISTRY.derivativeNeedsApproval(input.parentLicenseId)
+        ) {
+            // If parent license ID has `derivativeNeedsApproval` = true, then new license is pending licensor approval.
+            // This condition is triggered when parent's `isReciprocal` = false but `derivativeNeedsApproval` = true.
+            newLicenseStatus = Licensing.LicenseStatus.PendingLicensorApproval;
+        } else {
+            newLicenseStatus = Licensing.LicenseStatus.Active;
+        }
+
         // Create license
         Licensing.LicenseData memory newLicense = Licensing.LicenseData({
-            status: Licensing.LicenseStatus.Active,
+            status: newLicenseStatus,
             derivativesAllowed: derivativesAllowed,
             isReciprocal: isReciprocal,
             derivativeNeedsApproval: derivativeNeedsApproval,
@@ -221,17 +232,23 @@ contract LicensingModule is BaseModule, ILicensingModule {
         address ipOrg_,
         Licensing.ParamValue[] memory inputParams_,
         Licensing.ParamDefinition[] memory supportedParams_
-    ) private view returns (
-        Licensing.ParamValue[] memory licenseParams,
-        bool derivativesAllowed,
-        bool derivativeNeedsApproval,
-        bool isReciprocal
-    ) {
+    )
+        private
+        view
+        returns (
+            Licensing.ParamValue[] memory licenseParams,
+            bool derivativesAllowed,
+            bool isReciprocal,
+            bool derivativeNeedsApproval
+        )
+    {
         uint256 inputLength_ = inputParams_.length;
-        mapping(ShortString => bytes) storage _ipOrgValues = _ipOrgParamValues[ipOrg_];
+        mapping(ShortString => bytes) storage _ipOrgValues = _ipOrgParamValues[
+            ipOrg_
+        ];
         uint256 supportedLength = supportedParams_.length;
         licenseParams = new Licensing.ParamValue[](supportedLength);
-        
+
         // First, get ipOrg defaults
         for (uint256 i = 0; i < supportedLength; i++) {
             // For every supported parameter
@@ -283,7 +300,6 @@ contract LicensingModule is BaseModule, ILicensingModule {
             derivativeNeedsApproval = false;
             isReciprocal = false;
         }
-        return (licenseParams, derivativesAllowed, derivativeNeedsApproval, isReciprocal);
     }
 
     function _decideValueSource(
@@ -313,9 +329,7 @@ contract LicensingModule is BaseModule, ILicensingModule {
         ShortString tag,
         bytes memory resultValue,
         bool derivativesAllowed
-    ) private pure returns (bool) {
-
-    }
+    ) private pure returns (bool) {}
 
     /// Gets the licensor address for this IPA.
     function _getLicensor(

contracts/modules/registration/RegistrationModule.sol

@@ -64,6 +64,7 @@ contract RegistrationModule is BaseModule, IRegistrationModule, AccessControlled
     /// @param ipOrg_ The IP Org for which the hooks are being registered.
     /// @param hooks_ The addresses of the hooks to register.
     /// @param hooksConfig_ The configurations for the hooks.
+    /// @param registerParams_ The parameters for the registration.
     function registerHooks(
         HookType hType_,
         IIPOrg ipOrg_,
@@ -297,30 +298,29 @@ contract RegistrationModule is BaseModule, IRegistrationModule, AccessControlled
     /// @param toIpOrg_ The address of the new governing IP Org.
     /// @param toIpOrgType_ The type of the IP asset within the new IP Org.
     /// TODO(leeren) Expose this function to FE once IP Orgs are finalized.
-    function _transferIPAssetToIPOrg(
-        address fromIpOrg_,
-        uint256 fromIpOrgAssetId_,
-        address toIpOrg_,
-        uint8 toIpOrgType_,
-        address from_,
-        address to_
-    ) internal returns (uint256 ipAssetId_, uint256 ipOrgAssetId_) {
-        uint256 id = ipAssetId[address(fromIpOrg_)][fromIpOrgAssetId_];
-
-        address owner = IIPOrg(fromIpOrg_).ownerOf(ipOrgAssetId_);
-
-        delete ipAssetId[address(fromIpOrg_)][fromIpOrgAssetId_];
-        delete ipOrgAssets[id];
-        IIPOrg(fromIpOrg_).burn(ipOrgAssetId_);
-        IPA_REGISTRY.transferIPOrg(
-            ipAssetId_,
-            toIpOrg_
-        );
-        ipOrgAssetId_ = IIPOrg(toIpOrg_).mint(owner, toIpOrgType_);
-        IPOrgAsset memory ipOrgAsset = IPOrgAsset(toIpOrg_, ipOrgAssetId_);
-        ipOrgAssets[id] = ipOrgAsset;
-        ipAssetId[address(toIpOrg_)][ipOrgAssetId_] = id;
-    }
+    /// NOTE: This function is currently not used, but will be used in the future. Commented out for now.
+    // function _transferIPAssetToIPOrg(
+    //     address fromIpOrg_,
+    //     uint256 fromIpOrgAssetId_,
+    //     address toIpOrg_,
+    //     uint8 toIpOrgType_,
+    //     address from_,
+    //     address to_
+    // ) internal returns (uint256 ipAssetId_, uint256 ipOrgAssetId_) {
+    //     uint256 id = ipAssetId[address(fromIpOrg_)][fromIpOrgAssetId_];
+    //     address owner = IIPOrg(fromIpOrg_).ownerOf(ipOrgAssetId_);
+    //     delete ipAssetId[address(fromIpOrg_)][fromIpOrgAssetId_];
+    //     delete ipOrgAssets[id];
+    //     IIPOrg(fromIpOrg_).burn(ipOrgAssetId_);
+    //     IPA_REGISTRY.transferIPOrg(
+    //         ipAssetId_,
+    //         toIpOrg_
+    //     );
+    //     ipOrgAssetId_ = IIPOrg(toIpOrg_).mint(owner, toIpOrgType_);
+    //     IPOrgAsset memory ipOrgAsset = IPOrgAsset(toIpOrg_, ipOrgAssetId_);
+    //     ipOrgAssets[id] = ipOrgAsset;
+    //     ipAssetId[address(toIpOrg_)][ipOrgAssetId_] = id;
+    // }
 
 
     /// @dev Adds new IP asset types to an IP Org.