Compliance
with One Line of Code

Our Products

Sanction List

Avoid exposure to known bad actors and prevent them from interacting with your products.

Credit Ratings

Tap into under-collateralized financial products with real-time on-chain credit ratings.

NFT Allowlist Tool

Define flexible user verifications and constraints with token issuance models, such as NFTs.

Compliance: KYC

Ensure standard KYC/AML (Know Your Customer / Anti Money Laundering) regulatory compliance in your ecosystem.

Legal Docs

Align and safeguard your products with living legal documents.

Connect smart contracts with up-to-date
off-chain data without oracles.

Molecule Protocol is a hackathon winning composable middleware that enable smart contracts to access updatable off-chain data and services without the need of oracles.

Featured Use Case

Add one line of code for Making your Dapp Compliant with General Sanction Lists

Service provider feature allows designated service providers to create their own custom access lists to block addresses that are associated with illicit parties/activities.

Add Custom access list for your Dapp using Molecule Service provider feature

Custom access list feature allows Molecule users to create their own custom access lists to block addresses on-demand.

How to Integrate Solidity

Frequently Asked Questions

What is Molecule Protocol?

How to Integrate Molecule Protocol?

By utilizing the capabilities of the Molecule Controller, the incorporation of contract-based check() into Smart contracts is made straightforward, thereby enabling a smooth assimilation of the Molecule Protocol. Decentralized applications (Dapps) can seamlessly adopt this functionality by making use of the Query functions available within the Molecule General AML Controller contract. This integration facilitates the imposition of restrictions on addresses subject to general sanctions, while affording the flexibility to incorporate personalized sanction lists.

Furthermore, users have the option to craft their own Molecule Controller smart contract by utilizing the provided template. This empowers them to integrate multiple logic contracts into their custom controller, enabling a tailored approach to address verification and sanctions enforcement.

Below is an illustrative code snippet demonstrating the implementation of the Molecule General Sanction Controller within a smart contract

pragma solidity ^0.8.0;
import "https://github.com/molecule-protocol/molecule-core/blob/main/src/v2/interfaces/IMoleculeController.sol";
import "./MyCustomController.sol";
contract MyContract {
    MyCustomController public myCustomController;
    IMoleculeController public moleculeGeneralSanctionController;
    uint[] public regionalIds;
    constructor(MyCustomController _myCustomController, IMoleculeController _moleculeGeneralSanctionController) {
        myCustomController = _myCustomController;
        moleculeGeneralSanctionController = _moleculeGeneralSanctionController;
    }
    function addRegionalId(uint _regionalId) external {
        regionalIds.push(_regionalId);
    }
    function myFunction() external {
        require(moleculeGeneralSanctionController.check(regionalIds, msg.sender), "Address is sanctioned.");
        require(myCustomController.check(msg.sender), "Address is not authorized.");
        // Access allowed to function code here
    }
}

Check out the docs for further details

What are Molecule Controller and Molecule Logic Contracts?

The Molecule Protocol comprises essential components: the Molecule Controller and Molecule Logic contracts. The Controller’s role is to dynamically maintain the General Sanction List, adapting it according to region-specific criteria such as US, UK, and EU designations. In parallel, Molecule Logic contracts are designed to seamlessly embed within Controller Smart contracts. This integration empowers developers to enforce meticulous access controls in line with the Protocol’s framework.

Adding to this adaptability, users have the autonomy to incorporate custom Logic contracts into their individualized Controller contracts. This not only enhances flexibility but also enables precise customisation to meet specific operational needs.

Beyond these core elements, the Molecule Protocol extends its functionality through distinct token contracts: ERC20m, ERC721m, ERC1155m, and “soulbound” tokens. Each contract type boasts specialised access control mechanisms and logic gating. This diversification enriches the Protocol’s capacity for finely tuned control and tailored operational logic.

General Sanction List vs Service Provide Sanction List

The General Sanction List is a collection of on-chain data containing addresses that are sanctioned based on specific regions (such as US, UK, UN, etc.). These data are updated periodically by the Molecule Protocol and are provided free of cost. The Protocol's functionality can be easily integrated into Smart contracts and Dapps. On the other hand, the Molecule App offers advanced features that enable registered users to create custom sanctioned lists, which can be integrated into their Smart contracts and Dapps with just one line of code.

What are NFT-based Allowlists?

Through the Molecule Platform, users can create specific SoulBound NFT Smart contracts and issue NFT-based access passes to the respective users. This feature falls under the service provider category, where registered Molecule users are promoted as service providers. These service providers can create and mint NFTs for their Dapp users, as well as restrict functions on the Smart contract to a list of desired addresses.

Still have questions?

If you cannot find the answer to your question in our FAQ, you can always contact us.

Compliancewith One Line of Code