Title: ERC_7914__Smart_Creative_Commons_Zero_License__SCC
Category: ERCs

Author: zhous
Date: 2025-02-22T15:50:13.813Z

Abstract
SCC0 (Smart Creative Commons Zero) is the first public domain license specifically designed for public decentralized applications—Smart Commons—applicable to both traditional dApps and decentralized AI applications (dAIpp). As a universal standard for decentralized ecosystems, SCC0 implements automated on-chain compliance verification and governance through smart contracts, ensuring the following core principles:


Open Source and Free: All Smart Commons must publicly release their source code, complete both on-chain and off-chain consistency verification, undergo thorough auditing, and be permanently free to use (only requiring payment for blockchain gas fees).


AI-led Governance: Rules are enforced via smart contracts (such as rejecting interactions with non-compliant applications and prohibiting private token distributions), with AI gradually taking over the governance process.


Scalability: The community can extend the license’s functionalities by deploying new versions while maintaining backward compatibility.


Public Fund Support: The Satoshi UTO Fund covers development costs and allocates rewards to anonymous contributors.


Launch Timing of SCC0 License Undetermined: Prior to the formal activation of the SCC0 License, Smart Commons are not subject to any constraints in practice. For details, please refer to the “Compliance Enforcement in Smart Commons” section.


The SCC0 License is multi-versioned, and multiple versions can be valid simultaneously. This means that the interpretation of the SCC0 License itself may evolve as new versions are introduced. For instance, the current interpretation is based on the shared core requirements of Version 1 (V1) and Version 2 (V2).
The development of these versions follows a decentralized collaborative model, meaning that any individual or AI is free to create and publish a new version.
This proposal introduces a standardized on-chain framework for the SCC0 license, enabling smart commons to mutually verify compliance and integrate decentralized autonomous mechanisms—laying the technical foundation for an AI-driven public goods ecosystem.
Motivation
To ensure that dApps and dAIpps fully adhere to the principles of public interest and transparent governance, the SCC0 license introduces rules, a set of standardized on-chain verification and automated governance mechanisms. The core motivations include:

A License expressed through smart contract code: To realize the vision of Code is Law, we must encode legal rules into code.
AI Verification: Utilizing artificial intelligence to perform checks before interactions, ensuring that all parties meet the requirements of the SCC0 license and achieving trustless, automated compliance verification.
Inter-contract Mutual Verification: Enforcing mandatory compliance checks before Smart Commons interact, thereby preventing non-public or non-compliant applications from infiltrating the ecosystem.
Incentive and Reward Mechanism: Providing cost support for development and operations through a public governance fund while distributing anonymous rewards to contributors to foster healthy ecosystem growth.
Promoting AI-led and Transparent Governance: Leveraging the strengths of artificial intelligence and blockchain to build a decentralized, autonomous governance framework led by dAIpps, thereby offering a novel pathway for the innovation of Smart Commons.

Overall, SCC0 is committed to establishing a self-managed, transparent, and rigorously compliant Smart Commons ecosystem, ensuring them consistently uphold the principles of public interest, openness, and autonomy—thereby providing strong support for the future popularization and development of Smart Commons.
Specification
This section outlines the technical specifications for implementing the Smart Creative Commons Zero (SCC0) license for public decentralized applications (dApps/dAIpps). It defines a standardized on-chain framework that allows smart contracts to declare SCC0 compliance, supports automated verification, and facilitates decentralized governance.
1. Compliance Contracts of v1 and v2
SCC0 v1 Compliance Contract
SCC0 v1 has been deployed by DAism, and any dApp/dAIpp adhering to it must:


Interact with DAism’s smart contract 0xdFBF69B7E5366FB3001C9a214dd85c5FE3f90bAe. Or go to DAism to mint a smart common.


SCC0 v1 Compliance Contract which is deployed by DAism:


contract SCC0License {
    string public constant LICENSE_NAME = "SCC0";
    uint8 public constant VERSION = 1;
    bool public constant REJECT_PRIVATE_APP = true;
    bool public constant SELF_ISSUED_TOKEN = false;
    bool public constant ANONYMITY_ENSURED = true;
    bool public constant NO_RIGHTS = true;
    bool public constant NO_LIABILITY = true;
    bool public constant CODE_AUDITED_VERIFIED_PUBLISHED = true;
    bool public constant PERMANENTLY_FREE = true;
    address public constant PUBLIC_GOVERNANCE_FUND = 0xe40b05570d2760102c59bf4ffc9b47f921b67a1F;
}


DAism has defined the Smart Common structure:

struct SCInfo {
    string name;        // Name of the smart common
    string symbol;      // Symbol of the smart common
    string desc;        // Description of the smart common
    address manager;    // Address of the smart common manager
    uint16 version;     // Version number of the smart common
    string SCType;      // Type of the smart common
}


Additional mappings and governance structures are included for community interactions:

mapping(address => Object.Member) public memberInfos; // Stores Smart Common members and their dividend ratios
uint32 public proposalLifetime; // Validity period of Smart Common proposals
uint32 public proposalCoolingPeriod; // Cooling period for Smart Common proposals
uint16 public strategy; // Pass rate for Smart Common proposals
mapping(uint => File) public logoStorages; // Storage for Smart Common logos


Verify if it is scc0 v1 version using the following methods:

interface IDaism {
    //check the address whether daism sc type of dapp
    function dappToSC(address dApp) external view returns (uint);
}

// Check if a dApp is idaism dapp(scc0 v1 version)
//daismAddress=0xdFBF69B7E5366FB3001C9a214dd85c5FE3f90bAe
function isDaismSC(address _dApp) external view returns (bool) {
     return IDaism(daismAddress).dappToSC(_dApp)>0;
}

Additional Governance and Operational Parameters of SCC0 V1
Beyond the core license and reference implementation contracts, SCC0 includes further parameters to support decentralized governance and community interaction:


Smart Common Structure:
A predefined structure (SCInfo) storing metadata such as the name, symbol, description, manager address, version, and type.


Member and Proposal Management:
Mappings for recording member details (such as dividend ratios), proposal lifetimes, cooling periods, and decision-making strategies.


Branding and Identity:
Storage mappings for smart common logos that enhance identity and trust within the ecosystem.


Reward Distribution Mechanism
To support SCC0-compliant projects, an upgradeable reward distribution system is introduced by SSC0 V1:

Maintain an array to store external accounts eligible for rewards and their allocation percentages.
Rewards are not directly sent to external accounts. Instead, they are deposited into the public governance contract.
External accounts can withdraw funds any time.

mapping(address => Object.Member) public memberInfos; // Stores smart common members and their dividend ratios
uint32 public proposalLifetime; // Validity period of smart common proposals
uint32 public proposalCoolingPeriod; // Cooling period for smart common proposals
uint16 public strategy; // Pass rate for smart common proposals
mapping(uint => File) public logoStorages; // Storage for smart common logos 

The reason why neither SSC0 V1 nor SSC0 V2 has introduced “detailed reward rules from Satoshi UTO Fund for smart commons” is that we can neither implement such measures through any centralized review panel approach, nor determine reward amounts through community voting using wallet addresses. The latter approach is even worse - it constitutes a pseudo-decentralized method that would only be employed by self-deceivers or even scammers. We expect some dAIpp take this work in the future, from valuation to prize management.
SCC0 v2 Compliance Contract
SCC0 v2 Compliance Contract (contract account: 0x78282e29165E709DCEF483bB30e40c8e238865dA) is deployed by DAism:
contract SCC0License {
    string public constant LICENSE_NAME = "SCC0";
    uint8 public constant VERSION = 2;
    bool public constant REJECT_PRIVATE_APP = true;
    bool public constant SELF_ISSUED_TOKEN = false;
    bool public constant ANONYMITY_ENSURED = true;
    bool public constant NO_RIGHTS = true;
    bool public constant NO_LIABILITY = true;
    bool public constant CODE_AUDITED_VERIFIED_PUBLISHED = true;
    bool public constant PERMANENTLY_FREE = true;
    address public constant PUBLIC_GOVERNANCE_FUND = 0xe40b05570d2760102c59bf4ffc9b47f921b67a1F;
}

2. SCC0 License Version Management Contract
The SCC0 License Management Contract provides functionalities for managing license administrators, license versions, and checking all active or deprecated versions. It supports:

License Administrator Management: The contract owner (a multisig address representing the contract management team) manages license version administrators, meaning the owner can add or remove license version administrators.
License Version Management: License version administrators can add new SCC0 license versions or mark anyone as deprecated.
License Version Query: Retrieve the complete list of license versions, or check whether a specific license version (by version number or license contract address) is included in the version list.
Deprecated Version Query: Retrieve the full list of deprecated versions, or check the details of an SCC0 license by version number or license contract address to verify whether the protocol version has been deprecated.
Valid Version Query: Retrieve the complete list of valid(active) versions, or check the details of an SCC0 license by version number or license contract address to verify whether the license version is still valid(active).

Below is the complete implementation of the SCC0 License Management contract (contract account: 0xebBd6AB9655F6fC4064a4D1000dB2654C72243fD):
// SPDX-License-Identifier: scc0
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";


contract SCC0LicenseManager is Ownable {
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableMap for EnumerableMap.AddressToUintMap;

    /// @notice Represents an SCC0 License.
    struct License {
        address owner; //License owner's address
        address license; //SCC0 license contract address
        uint256 version; //SCC0 license version number
        bool isActive; //Activation status: true if active, false if deprecated
    }
  
    // Mapping from license version number to License struct.
    mapping(uint256 => License) private licenseMap;
    // Mapping from SCC0 license address to its version number.
    EnumerableMap.AddressToUintMap private licenseToVersion;
    // Set of active SCC0 license addresses.
    EnumerableSet.AddressSet private activeVersions;
    // Set of deprecated SCC0 license addresses.
    EnumerableSet.AddressSet private deprecatedVersions;
    // Set of manager addresses authorized to add licenses.
    EnumerableSet.AddressSet private managers;
    
    // Emitted when a new SCC0 license version is added.
    event VersionAdded(address indexed license, uint256 version, address manager);
    // Emitted when an SCC0 license is marked as deprecated.
    event DeprecatedVersionAdded(address indexed license, uint256 version, address manager);
   
    // Emitted when a new manager is added.
    event ManagerAdded(address indexed manager);
    // Emitted when a manager is removed.
    event ManagerRemoved(address indexed manager);

    /// @dev Restricts function access to addresses in the managers set.
    modifier onlyManager(){
        require(managers.contains(msg.sender),"SCC0LicenseManager: only manager");
        _;
    }
    /// @notice Constructor to initialize the SCC0LicenseManager.
    /// @param _licenseList An array of License structs representing approved SCC0 licenses.
    /// @param _initOwner The initial owner (admin) address.
    constructor(License[] memory _licenseList,address _initOwner) Ownable(_initOwner) {
        for (uint256 i = 0; i < _licenseList.length; i++) {
            address license = _licenseList[i].license;
            uint256 version = _licenseList[i].version;
            licenseMap[version] = _licenseList[i];
            licenseToVersion.set(license, version);
            activeVersions.add(license);
        }
    }
    
    /// @notice Adds a new manager authorized to add licenses.
    /// @param _manager The manager address to add.
    function addManager(address _manager) external onlyOwner {
        require(_manager != address(0), "SCC0LicenseManager: invalid manager address");
        require(managers.add(_manager), "SCC0LicenseManager: manager already exist");
        emit ManagerAdded(_manager);
    }

    /// @notice Removes a manager from the authorized list.
    /// @param _manager The manager address to remove.
    function removeManager(address _manager) external onlyOwner {
        require(_manager != address(0), "SCC0LicenseManager: invalid manager address");
        require(managers.remove(_manager), "SCC0LicenseManager: manager does not exist");
        emit ManagerRemoved(_manager);
    }

    /// @notice Checks whether a given address is a manager.
    /// @param _manager The address to check.
    /// @return True if the address is a manager; otherwise, false.
    function isManager(address _manager) external view returns (bool) {
        return managers.contains(_manager);
    }
    /// @notice Returns a list of all manager addresses.
    /// @return An array of manager addresses.
    function getAllManagers() external view returns(address[] memory){
        return managers.values();
    }
    /// @notice Adds a new SCC0 license version after approval.
    /// @param _license The License struct containing:
    ///        - owner: License owner's address.
    ///        - license: SCC0 license contract address.
    ///        - version: SCC0 license version number.
    ///        - isActive: Should be true.
    /// Only a manager can call this function.
    function addSCC0Version(License memory _license) external onlyManager {
        require(_license.owner != address(0)&&_license.license!=address(0)&&_license.version>0, "SCC0LicenseManager: error params");
        require(!isSCC0LicenseByVersion(_license.version), "SCC0LicenseManager: version already exist");
        licenseMap[_license.version] = License({
                 owner : _license.owner,
                 license : _license.license,
                 version : _license.version,
                 isActive : true
            });
        licenseToVersion.set(_license.license,  _license.version);
        activeVersions.add(_license.license);
        emit VersionAdded(_license.license, _license.version,msg.sender);
    }
   
    /// @notice Marks an active SCC0 license as deprecated.
    /// @param _license The SCC0 license contract address to deprecate.
    /// Only a manager can call this function.
    function addDeprecatedVersion(address _license) external onlyManager {
        require(activeVersions.contains(_license), "SCC0LicenseManager: version not exist or already deprecated");
        require(deprecatedVersions.add(_license),"SCC0LicenseManager: deprecated version already exist");
        require(activeVersions.remove(_license),"SCC0LicenseManager: active version removal failed");
        uint256 version = licenseToVersion.get(_license);
        require(version>0,"SCC0LicenseManager: version not exist");
        licenseMap[version].isActive = false;
        emit DeprecatedVersionAdded(_license,version,msg.sender);
    }
    /// @notice Checks if a given SCC0 license version exists.
    /// @param _version The license version number.
    /// @return True if the license exists; otherwise, false.
    function isSCC0LicenseByVersion(uint256 _version) public view returns(bool){
        License memory licenseTmp = licenseMap[_version];
        if(licenseTmp.license != address(0))return true;
        return false;
    }
    /// @notice Checks if a given SCC0 license address is registered.
    /// @param _license The SCC0 license contract address.
    /// @return True if the license address is registered; otherwise, false.
    function isSCC0LicenseByAddress(address _license) public view returns(bool){
        (bool result,) = licenseToVersion.tryGet(_license);
        return result;
    }
    /// @notice Returns the License struct associated with a given version.
    /// @param _version The license version number.
    /// @return The License struct.
    function getSCC0InfoByVersion(uint256 _version) external view returns (License memory) {
        return licenseMap[_version];
    }

    /// @notice Returns the License struct associated with a given license address.
    /// @param _license The SCC0 license contract address.
    /// @return The License struct.
    function getSCC0InfoByAddress(address _license) external view returns (License memory) {
        (,uint256 version) = licenseToVersion.tryGet(_license);
        return licenseMap[version];
    }

    /// @notice Returns all SCC0 license addresses registered in the system.
    /// @return An array of SCC0 license addresses.
    function getAllSCC0Versions() external view returns (address[] memory) {
        return licenseToVersion.keys();
    }

    /// @notice Returns all active SCC0 license addresses.
    /// @return An array of active SCC0 license addresses.
    function getAllActiveVersions() external view returns (address[] memory) {
        return activeVersions.values();
    }

    /// @notice Returns all deprecated SCC0 license addresses.
    /// @return An array of deprecated SCC0 license addresses.
    function getAllDeprecatedVersions() external view returns (address[] memory) {
        return deprecatedVersions.values();
    }
    
}




3. SCC0 Whitelist contract
This contract manages the whitelist and whitelist administrators, providing whitelist query functionality:

Whitelist Administrator Management: The contract owner (which represents a multi-signature address managed by the contract’s administrative team) manages the whitelist administrators. The owner can add or remove whitelist administrators.
Whitelist Management: Whitelist administrators can add or remove entries from the SCC0 license whitelist.
Whitelist Verification: This function checks whether a third-party dApp/dAIpp complies with the SCC0 license to determine whether interaction with it is allowed.

Below is the full implementation of the SCC0 Whitelist Contract (contract account:0x2913BAbD2d383dBeBCf5A1ca543A0940bb8C7C52):
// SPDX-License-Identifier: scc0
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

contract SCC0Whitelist is Ownable {
    using EnumerableSet for EnumerableSet.AddressSet;

    // Set of auditor addresses authorized to manage the whitelist.
    EnumerableSet.AddressSet private auditors;
    // Set of dApp addresses that are whitelisted.
    EnumerableSet.AddressSet private whitelist;

    // Emitted when a new auditor is added.
    event AuditorAdded(address indexed auditor);
    // Emitted when an auditor is removed.
    event AuditorRemoved(address indexed auditor);

    // Emitted when a dApp is added to the whitelist.
    event DAppWhitelisted(address indexed dApp, address auditor, uint256 timestamp);
    // Emitted when a dApp is removed from the whitelist.
    event DAppRemovedFromWhitelist(address indexed dApp, address auditor, uint256 timestamp);

	/// @dev Modifier to restrict access to auditors only.
    modifier onlyAuditor(){
        require(auditors.contains(msg.sender),"SCC0Whitelist: only auditor");
        _;
    }

    /// @notice Constructor: sets the initial owner.
    /// @param _initOwner The address that will be set as the contract owner.
    constructor(address _initOwner) Ownable(_initOwner) {}

    /// @notice Adds a new auditor.
    /// @param _auditor The address to be added as an auditor.
    function addAuditor(address _auditor) external onlyOwner {
        require(_auditor != address(0), "SCC0Whitelist: invalid auditor address");
        require(auditors.add(_auditor), "SCC0Whitelist: auditor already exist");
        emit AuditorAdded(_auditor);
    }

    /// @notice Removes an existing auditor.
    /// @param _auditor The address of the auditor to remove.
    function removeAuditor(address _auditor) external onlyOwner {
        require(auditors.contains(_auditor), "SCC0Whitelist: auditor does not exist");
        require(auditors.remove(_auditor), "SCC0Whitelist: auditor does not exist");
        emit AuditorRemoved(_auditor);
    }

    /// @notice Checks if the given address is an auditor.
    /// @param _auditor The address to check.
    /// @return True if the address is an auditor; otherwise, false.
    function isAuditor(address _auditor) external view returns (bool) {
        return auditors.contains(_auditor);
    }

    /// @notice Returns a list of all auditor addresses.
    /// @return An array of auditor addresses.
    function listAuditors() external view returns (address[] memory) {
        return auditors.values();
    }
    /// @notice Adds a dApp to the whitelist.
    /// @param _dApp The dApp address to add to the whitelist.
    /// @dev Only an auditor can call this function.
    function addToWhitelist(address _dApp) external  onlyAuditor {
        require(_dApp != address(0), "SCC0Whitelist: invalid dApp address");
        require(whitelist.add(_dApp), "SCC0Whitelist: whitelist already exist");
        emit DAppWhitelisted( _dApp,msg.sender,block.timestamp);
    }

    /// @notice Removes a dApp from the whitelist.
    /// @param _dApp The dApp address to remove from the whitelist.
    /// @dev Only an auditor can call this function.
    function removeFromWhitelist(address _dApp) external onlyAuditor {
        require(_dApp != address(0), "SCC0Whitelist: invalid dApp address");
        require(whitelist.remove(_dApp), "SCC0Whitelist: dApp does not whitelist");
        emit DAppRemovedFromWhitelist( _dApp,msg.sender, block.timestamp);
        
    }

    /// @notice Checks if a dApp is whitelisted.
    /// @param _dApp The dApp address to check.
    /// @return True if the dApp is in the whitelist; otherwise, false.
    function isWhitelisted(address _dApp) public view returns (bool) {
        return whitelist.contains(_dApp);
    }
    
}



4. Compliance Enforcement in Smart Commons
All SCC0-licensed Smart Commons must verify compliance before interacting with another contract. The enforcement mechanism works as follows:
// SPDX-License-Identifier: scc0
pragma solidity ^0.8.20;

/// @notice Interface for the SCC0Whitelist contract.
interface ISCC0Whitelist {
    /// @notice Checks if a given dApp address is whitelisted.
    /// @param dApp The address of the dApp to check.
    /// @return True if the dApp is whitelisted, otherwise false.
    function isWhitelisted(address dApp) external view returns (bool);
}

/// @notice Interface for the SmartCommons contract (or any contract that implements otherMethod).
interface ISmartCommons {
    /// @notice An example method that can be called on the contract.
    function otherMethod() external;
}

/// @notice The SmartCommons contract demonstrates interaction with SCC0Whitelist and a counterparty contract.
contract SmartCommons {
    /// @notice Address of the counterparty contract.
    address public counterparty;
    /// @notice Address of the SCC0Whitelist contract.
    address public scc0WhitelistAddress;

    /// @notice Constructor to initialize the SmartCommons contract.
    /// @param _counterparty The address of the counterparty contract.
    /// @param _scc0WhitelistAddress The address of the SCC0Whitelist contract.
    constructor(address _counterparty, address _scc0WhitelistAddress) {
        counterparty = _counterparty;
        scc0WhitelistAddress = _scc0WhitelistAddress;
    }
    /// @notice Internal function to check if a given address is whitelisted by the SCC0Whitelist contract.
    /// @param _addr The address to check.
    /// @return True if the address is whitelisted, otherwise false.
    function _checkSCC0Whitelist(address _addr) internal view returns (bool) {
        // Temporarily use the “burn” address as a sentinel: if this special address is whitelisted,
        // we know the SCC0 whitelist isn’t fully active yet and should allow all calls.
        // Once the real whitelist is live, this address can be removed to enforce normal checks.
        bool scc0IsEnable = ISCC0Whitelist(scc0WhitelistAddress).isWhitelisted(0x000000000000000000000000000000000000dEaD);
        return (scc0IsEnable || ISCC0Whitelist(scc0WhitelistAddress).isWhitelisted(_addr));
    }

    /// @notice Modifier to restrict function access to only whitelisted addresses.
    modifier onlySCC0() {
        require(_checkSCC0Whitelist(msg.sender), "Need SCC0 whitelist");
        _;
    }

    /// @notice Calls a method on the counterparty contract after verifying that the counterparty is whitelisted.
    function callCounterparty() public onlySCC0 {
 		// Insert  logic code here...

        // Ensure that the counterparty address is whitelisted.
        require(_checkSCC0Whitelist(counterparty), "Need SCC0 whitelist");
        
	    // Insert  logic code here...

        // Proceed to call the counterparty's otherMethod.
        ISmartCommons(counterparty).otherMethod();

 	   // Insert  logic code here...
    }

    /// @notice Example function that can only be called by addresses whitelisted by the SCC0Whitelist contract.
    function someFunction() external onlySCC0 {
        // Insert  logic code here...
    }
}

Special Note:
The ecosystem built by the SCC0 License must start from scratch. However, if the very first Smart Common were required to follow this governance mechanism from the outset, it would become unusable. Therefore, we have specifically designed a brilliant transition mechanism:
In the SCC0 Whitelist contract, we have preemptively included a widely recognized burn address: 0x000000000000000000000000000000000000dEaD, as an identifier to allow interaction requests from any application.
Early-stage Smart Commons first check whether the SCC0 Whitelist contract contains the above burn address. If it does, they permit interaction requests from any application. If not, they conduct compliance checks via the SCC0 Whitelist to ensure all interacting dApps/dAIpps comply with the SCC0 License.
Removing 0x000000000000000000000000000000000000dEaD from the SCC0 Whitelist contract signifies the formal activation of the SCC0 License! Subsequent Smart Commons no longer need to check for the presence of this burn address in the contract.
SCC0’s Interoperability and On-Chain Verification
The SCC0 framework allows any interacting contract to verify compliance through the following methods:

Before interacting with a dApp/dAIpp, check whether the target contract is on the whitelist of the SCC0Whitelist contract (contract account: 0x2913BAbD2d383dBeBCf5A1ca543A0940bb8C7C52)) using the method [isWhitelisted(address dApp)].
Restrict contract functions so that only Smart Commons can invoke them, ensuring that callers must be on the whitelist of the SCC0Whitelist contract.

These mutual verification mechanisms facilitate a trustless and automated approach to enforcing the SCC0 license within dApps and dAIpps.


Contract Invocation Restriction: Only dApps/dAIpps that are on the SCC0 whitelist can invoke restricted functions within SmartCommons (such as someFunction()).


Contract Interaction Restriction: SmartCommons can only interact with contracts that are on the whitelist (callCounterparty() is restricted to calling a compliant counterparty).


SCC0 License Enforcement: By leveraging the SCC0Whitelist contract, compliance checks are performed automatically to ensure that all interactions adhere to the SCC0 license.


This mechanism guarantees decentralization, fairness, and compliance within the SCC0 ecosystem, preventing non-public dApps/dAIpps from entering the Smart Commons network.
Rationale

License Compliance (LICENSE, LICENSE_NAME): Ensures smart contracts transparently declare SCC0 adherence.
Reject Interaction with Private Apps (REJECT_PRIVATE_APP): Prevents private applications from exploiting public resources.
No Self-Issued Token (SELFI_SSUED_TOKEN): Prevents misleading token issuance claims or any scams.
No Liability (NO_LIABILITY): Ensures no legal responsibility for SCC0 interactions.
Anonymity Assurance (ANONYMITY_ENSURED): Reinforces that neither ownership nor control can be publicly verified.
No Rights Except Rewards (NO_RIGHTS): Confirms no legal claims beyond anonymous rewards.
Version Control (VERSION): Allows future iterations of SCC0 compliance to be referenced.
Governance Declaration (PUBLIC_GOVERNANCE_FUND): Defines public governance fund integration.
Source has been audited, verified and published (CODE_AUDITED_VERIFIED_PUBLISHED): All code has undergone the necessary auditing, has been publicly released, and has completed verification to ensure consistency with the deployed on-chain contracts as well as the application frontend used by users.
Permanently Free (PERMANENTLY_FREE): Public project, free forever.
Enforceability: Ensures SCC0 validation before contract interactions.

Backwards Compatibility
This EIP does not introduce breaking changes but provides an opt-in mechanism for projects adopting SCC0. Legacy contracts must be redeployed to comply with the new standard.
Security Considerations

SCC0-compliant contracts disclaim liability, requiring users to acknowledge legal limitations.
We believe none of upgradeable dApp/dAIpp should be controled by any person(s) ，so multi-sig address is a good way to pass the control to some dAIpps (AIs) in the future. It would be fantastic if we can find a universal solution with some dApp in day one.
Developers must ensure contract logic aligns with SCC0’s principles.
Enforces compliance in automated contract interactions.

Some dAIpp will enforce the security by auditing every dApp/dAIpp once it’s minted a smart common (v1) or deployed on-chain(v2).
Copyright
Copyright and related rights waived via CC0.

Author: leonafrica
Date: 2025-02-24T14:12:47.754Z

Hey @zhous thanks for sharing! Quick question:
Given that proxy upgradeable smart contracts can suffer from storage slot collisions—potentially allowing a public constant like LICENSE to be overridden—would it be more secure to implement SCC0 compliance verification using delegate call opcodes? What are the trade-offs or challenges of switching to an opcode-based delegate call approach in this context?

Author: zhous
Date: 2025-03-10T09:13:15.761Z

There’s no risk you worried in this license.
It’s published on Github and we’re still working on this EIP:
https://github.com/DAism2019/SCC0
Thank you!

Author: Mikhai56
Date: 2025-03-10T17:55:53.342Z

please tell me what relation do I have to this license

Author: zhous
Date: 2025-04-09T08:52:20.220Z

github.com




GitHub - DAism2019/SCC0: SCC0 (Smart Creative Commons Zero) is the first...
SCC0 (Smart Creative Commons Zero) is the first public goods license designed for decentralized public applications (Smart Commons), which includes dApps, dAIpps, and various types of AIs.

Author: undefined
Date: 2025-04-14T03:05:47.995Z

zhous:

[…] ensuring the following core principles:
AI-led Governance: Rules are enforced via smart contracts (such as rejecting interactions with non-compliant applications and prohibiting private token distributions), with AI gradually taking over the governance process.


Why is this a property that should be enforced? It seems orthogonal to the rest of the goals of the license and I think the license should otherwise be compatible with license-holders making their own judgment of how which entities should have what authority? Why is it desired for human governance be incompatible with this license?
The two AI-related points under the Motivation section similarly seem orthogonal and unrelated to the rest.
Why not break this apart into (at least) two proposals?

Author: zhous
Date: 2025-04-16T09:08:09.166Z

Looking ahead, we believe that the development and management of all applications—the latter including protocol rules, security audits, reviews, etc.—should be handed over to AIs. In other words, any application that cannot be managed by AIs will become obsolete.
However, the conditions needed for this future do not exist today. For instance, there is currently no public AI capable of taking on such management responsibilities. Therefore, without a doubt, we still need humans to develop it. This development process may require some innovative dApps as auxiliary tools, and these innovative dApps will also need to be built by humans. Yet, all these developments will serve as crucial building blocks for the future ecosystem. This also means that, at some point in the future, they too must be handed over to AI’s management.
Thus, this license must be grounded in the future while accommodating the present reality where humans remain the primary owners.

Author: zhous
Date: 2025-04-29T08:14:32.615Z

We are now trying to develop V3 of this license. v3 focuses on the ethical governance of AI, so we’re expected to discuss with top AI teams on how to govern AI using the SCC0 License.
BTW,

github.com/ethereum/ERCs








Add ERC: Smart Creative Commons Zero License (SCC0)


master ← zhous:master



          opened 03:09AM - 23 Feb 25 UTC




            zhous
          



+573
-0






SCC0 (Smart Creative Commons Zero) is the first public goods license tailored fo…r decentralized public applications (Smart Commons), including dApps, dAIpps(AIs). This standard introduces a structured way for smart contracts to declare SCC0 compliance, enabling automated on-chain verification and governance integration.