Marketplace contract split
=====

<style>.markdown-body { max-width: 1500px; }</style>

classDiagram
    class IMarketplace {
        <<interface>>
        +getConfiguration(): IConfigurationStrategy
        +getAccessControl(): IAccessControlStrategy
        +getAssetManager(): IAssetManagementStrategy
        +getListingManager(): IListingManagementStrategy
        +getFinanceManager(): IFinanceManagementStrategy
        +setConfiguration(strategy: IConfigurationStrategy)
        +setAccessControl(strategy: IAccessControlStrategy)
        +setAssetManager(strategy: IAssetManagementStrategy)
        +setListingManager(strategy: IListingManagementStrategy)
        +setFinanceManager(strategy: IFinanceManagementStrategy)
        +getMarketplaceFee(): uint256
        +setMarketplaceFee(fee: uint256)
    }

    
    class Marketplaceable {
        <<abstract>>
        -marketplace: IMarketplace
        -configuration: IConfigurationStrategy
        -accessControl: IAccessControlStrategy
        -assetManager: IAssetManagementStrategy
        -listingManager: IListingManagementStrategy
        -financeManager: IFinanceManagementStrategy
    }
    
    class DomainManagementStrategy {
        <<interface>>
        +getRNS(): IRNS
        +setRNS(IRNS rns)
        +getRNSDomain(): bytes32
        +setRNSDomain(bytes32 rnsDomain)
        +getRNSNameGenStrategy(): RNSNameGenerationStrategy
        +setRNSNameGenStrategy(RNSNameGenerationStrategy strategy)
    }
    
    class DomainManager {
        <<abstract>>
        -rns: IRNS
        -rnsDomain: bytes32
        -rnsNameGenerationStrategy: DomainNameGenStrategy
    }
    
    class Marketplace {
        <<contract>>  
        -configuration: IConfigurationStrategy
        -accessControl: IAccessControlStrategy
        -assetManager: IAssetManagementStrategy
        -listingManager: IListingManagementStrategy
        -financeManager: IFinanceManagementStrategy
        -fee: uint256
    }
    
    class IConfigurationStrategy {
        <<interface>>
        +getValueFor(configuration: bytes32): bool
        +setValueFor(configuration: bytes32, value: bool)
    }
    
    class MarketplaceConfiguration {
        <<contract>>
        -marketplaceAccessControl: IAccessControlStrategy
        -settings: mapping[bytes32 => bool]
    }
    
    class IAccessControlStrategy {
        <<interface>>
        +addRole(roleName: bytes32)
        +isRoleMember(roleName: bytes32, account: address): bool
        +addRoleMember(roleName: bytes32, account: address)
        +removeRoleMember(roleName: bytes32, account: address)
        +transferOwnership(account: address)
        +isOwnerRole(ownerAddr: address)
        +isAdministrator(adminAddr: address)
        +addAdministrator(adminAddr: address)
        +removeAdministrator(adminAddr: address)
    }
    
    class MarketplaceAccessControl {
        <<contract>>
        -marketplaceConfiguration: IConfigurationStrategy
        -owner: bytes32
        -administrator: bytes32
        -assetManager: bytes32
        -assetValidatorManager: bytes32
        -assetValidator: bytes32
        -financeManager: bytes32
        -finance: bytes32
        -assetProviderManager: bytes32
        -assetProvider: bytes32
    }
    
    class IAssetManagementStrategy {
        <<interface>>
        +registerAsset(assetId: bytes32)
        +createAssetIdForToken(tokenAddr: address, tokenId: uint256): bytes32
        +getAsset(assetId: bytes32): Asset
    }
    
    class SponsorAccessControl {
        <<abstract>>
        +addSponsorToWhitelist(sponsor: address)
        +removeSponsorFromWhitelist(sponsor: address)
        +isSponsorToWhitelisted(sponsor: address): bool
    }
    
    class AssetManager {
        <<contract>>
    }
    
    class IListingManagementStrategy {
        <<interface>>
    }
    
    class ListingManager {
        <<contract>>
    }
    
    class ISponsorshipManagement {
        <<interface>>
        +setSponsorPolicyType(policyType: SponsorPolicyType)
        +setSponsorPolicyFee(uint8 fee)
    }
    
    
    class SponsorshipManager {
        <<abstract>>
    }
    
    class FinanceManager {
        <<abstract>>
    }
    
    
    IMarketplace <|-- Marketplace
    IMarketplace <|-- Marketplaceable
    
    Marketplace o--> IConfigurationStrategy
    IConfigurationStrategy <|-- MarketplaceConfiguration
    MarketplaceConfiguration o--> Marketplaceable
    MarketplaceConfiguration --|> SaleStrategyManagement
    
    Marketplace o--> IAccessControlStrategy
    MarketplaceAccessControl o--> Marketplaceable
    MarketplaceAccessControl --|> SponsorAccessControl
    
    SponsorshipManager --|> ISponsorshipManagement
    
    AssetManager --|> IAssetManagementStrategy
    SponsorshipManager <|-- AssetManager
    Marketplace o--> IAssetManagementStrategy
    AssetManager o--> Marketplaceable
    
    ListingManager --|> IListingManagementStrategy
    ListingManager --|> IncrementalIDGenerationStrategy
    ListingManager --|> ISaleStrategy
    Marketplace o--> IListingManagementStrategy
    ListingManager o--> Marketplaceable
    
    FinanceManager --|> IFinanceManagementStrategy
    Marketplace o--> IFinanceManagementStrategy
    FinanceManager o--> Marketplaceable
    

## Deployment

    sequenceDiagram
    Alice ->> RSKNode: deploy Marketplace
    RSKNode -->> Alice: Marketplace contract address
    Alice ->> RSKNode: deploy Configuration
    RSKNode -->> Alice: Configuration contract address
    Alice ->> Marketplace: setConfiguration(address)
    activate Marketplace
        Marketplace ->> Marketplace: store address
        Marketplace ->> Marketplace: has access control address
        Note over Marketplace: AccessControl NOT deployed yet
        
        Marketplace ->> Marketplace: has asset manager address
        Note over Marketplace: AssetManager NOT deployed yet
        Marketplace --> Alice: 
    deactivate Marketplace
        
    Alice ->> RSKNode: deploy AccessControl
    RSKNode -->> Alice: AccessControl contract address
    Alice ->> Marketplace: setAccessControl(address)
    activate Marketplace
        Marketplace ->> Marketplace: store address
        Marketplace ->> Marketplace: has configuration address
        loop ADDRESS IS NOT 0
            Marketplace ->> Configuration: setAccessControl(address)
            activate Configuration
                Configuration ->> Configuration: store address
            deactivate Configuration
        end
        
        Marketplace ->> Marketplace: has asset manager address
        Note over Marketplace: AssetManager NOT deployed yet
        Marketplace --> Alice: 
    deactivate Marketplace
        
    Alice ->> RSKNode: deploy AssetManager
    RSKNode -->> Alice: AssetManager contract address
    Alice ->> Marketplace: setAssetManager(address)
    activate Marketplace
        Marketplace ->> Marketplace: store address
        Marketplace ->> Marketplace: has configuration address
        loop ADDRESS IS NOT 0
            Marketplace ->> Configuration: setAssetManager(address)
            activate Configuration
                Configuration ->> Configuration: store address
            deactivate Configuration
        end
        
        Marketplace ->> Marketplace: has asset manager address
        loop ADDRESS IS NOT 0
            Marketplace ->> AccessControl: setAssetManager(address)
            activate AccessControl
                AccessControl ->> AccessControl: store address
            deactivate AccessControl
    deactivate Marketplace
        end

## Inter-contract communication (Asset registration example)

    sequenceDiagram
    Bob ->> AssetManager: registerAsset(assetId)
    AssetManager ->> Marketplaceable: getConfiguration()
    activate Marketplaceable
        Marketplaceable ->> Marketplaceable: has configuration address
        loop ADDRESS IS 0
            Marketplaceable ->> Marketplace: getConfiguration()
            Marketplaceable ->> Marketplaceable: store address
    deactivate Marketplaceable
        end
    
    Marketplaceable -->> AssetManager: configuration contract address
    AssetManager ->> Configuration: isWhitelistedAssetProviderRequired()
    loop Provider WL is required
        AssetManager ->> Marketplaceable: getAccessControl()
        activate Marketplaceable
            Marketplaceable ->> Marketplaceable: has access control address
            loop ADDRESS IS 0
                Marketplaceable ->> Marketplace: getAccessControl()
                Marketplaceable ->> Marketplaceable: store address
        deactivate Marketplaceable
            end

        Marketplaceable -->> AssetManager: access control contract address
        AssetManager ->> AccessControl: isAssetProvider(msg.sender)
    end