Detailed Instructions

Begin by selecting a real-world asset (RWA) with clear title, verifiable value, and a predictable revenue stream, such as commercial real estate or fine art. The legal structure is paramount; you must create a Special Purpose Vehicle (SPV) or a trust to hold the underlying asset. This legal entity issues the tokens, representing fractional ownership shares. Draft a detailed offering memorandum that complies with relevant securities regulations (e.g., SEC Reg D 506c in the US). This document must specify investor accreditation requirements, redemption rights, and the legal recourse for token holders.

• Sub-step 1: Conduct due diligence on the asset's provenance, valuation, and title history.
• Sub-step 2: Engage legal counsel to establish the SPV and draft the security token offering (STO) terms.
• Sub-step 3: Define the token's economic rights (e.g., profit share, voting) and legal enforceability.

Tip: Jurisdictions like Switzerland or Singapore offer clearer regulatory frameworks for security tokens, which can streamline the process.

Detailed Instructions

Develop the smart contracts that will represent the fractionalized ownership. Use a standard like ERC-3643 (for permissioned security tokens) or ERC-1400 for their built-in compliance features, such as transfer restrictions and investor whitelists. The core contract must be linked to the legal entity's details and include functions for distributing dividends or rental income to token holders. Implement a multi-signature wallet (e.g., using Gnosis Safe) controlled by the asset manager and legal representatives for treasury operations.

• Sub-step 1: Choose a blockchain with institutional-grade security and compliance tools, like Ethereum, Polygon, or a private consortium chain.
• Sub-step 2: Code the minting logic, tying the total token supply to 100% of the asset's equity.
• Sub-step 3: Integrate an oracle (e.g., Chainlink) to feed off-chain data, like property valuation updates or revenue reports, onto the blockchain.

solidityCopy
// Example snippet for a basic ERC-3643 compliant token constructor
import "@erc3643/tokens/contracts/ERC3643.sol";

contract RealEstateToken is ERC3643 {
    address public propertyRegistry;
    constructor(
        string memory name,
        string memory symbol,
        address _propertyRegistry
    ) ERC3643(name, symbol) {
        propertyRegistry = _propertyRegistry;
        // Set up compliance modules here
    }
}

Tip: Thoroughly audit the smart contracts with a firm like OpenZeppelin or ConsenSys Diligence before deployment.

Detailed Instructions

Token value depends on the integrity of the underlying asset. Implement a robust proof-of-asset system. For physical assets, use IoT sensors (e.g., for warehouse inventory) or regular audits by licensed third parties (e.g., for real estate) to generate verifiable data. This data should be hashed and anchored to the blockchain. The physical asset must be held by a licensed, insured qualified custodian independent of the issuer. For legal assets like invoices, use a verified data provider to confirm their authenticity and status.

• Sub-step 1: Contract a certified custodian and define the audit schedule and reporting standards.
• Sub-step 2: Set up a data pipeline where audit reports or sensor feeds are signed by the verifier and their hash is stored on-chain.
• Sub-step 3: Create a transparent dashboard for token holders to view custody certificates and recent verification proofs.

Tip: Projects like Provenance or Centrifuge provide frameworks for bridging real-world asset data onto blockchains, which can accelerate this step.

Detailed Instructions

Execute the primary issuance to accredited investors. This is typically done through a whitelisted private sale. Use the smart contract's mint function to create tokens and distribute them to investor wallets upon receipt of fiat or stablecoin payments, ensuring KYC/AML checks are completed on-chain via integrated providers. Following the primary sale, list the token on a licensed security token exchange or an Alternative Trading System (ATS) to enable secondary liquidity. Platforms like tZERO, INX, or ADDX are designed for this purpose.

• Sub-step 1: Onboard investors through a compliance portal that verifies accreditation and executes the subscription agreement.
• Sub-step 2: Mint tokens to investor addresses upon successful fund transfer to the SPV's custody account.
• Sub-step 3: Apply for listing on a regulated exchange, providing all legal and audit documentation.
• Sub-step 4: Integrate with DeFi protocols carefully; use permissioned pools in lending protocols like Maple Finance or Centrifuge Tinlake for compliant yield generation.

solidityCopy
// Example of a conditional mint function for whitelisted investors
function mintToInvestor(address investor, uint256 amount) external onlyIssuer {
    require(complianceModule.isWhitelisted(investor), "Not KYC'd");
    require(investorFundsReceived[investor] >= amount, "Funds not received");
    _mint(investor, amount);
    investorFundsReceived[investor] -= amount;
}

Tip: Maintain a clear record of all token holders for tax reporting and corporate action communications, as mandated by securities law.

Detailed Instructions

Active management of the tokenized asset is required. This includes collecting revenue (e.g., rent), paying expenses (e.g., maintenance, taxes), and distributing net proceeds to token holders via the smart contract. Automate distributions where possible using smart contract functions triggered by the asset manager. You must provide continuous disclosure, issuing regular financial and operational reports to token holders, similar to a public company. The smart contract's compliance module must be updated to reflect changes in securities law or investor status.

• Sub-step 1: Schedule and execute periodic yield distributions using the contract's distributeDividends function, funded from the SPV's treasury.
• Sub-step 2: Submit quarterly and annual reports, hashed and timestamped on-chain, to a designated document repository.
• Sub-step 3: Re-verify investor accreditation status annually and update the on-chain whitelist.
• Sub-step 4: Manage corporate actions like asset refinancing or sale, which may require a token holder vote implemented via a governance contract.

Tip: Utilize decentralized identity and verifiable credentials solutions to streamline the ongoing KYC/AML re-verification process for investors.

Detailed Instructions

Begin by drafting the legal and technical specifications of the license. The license terms must be explicit about the scope of use, such as commercial rights, derivative creation permissions, and territorial restrictions. This is typically encoded in a license metadata file (e.g., JSON) that references a human-readable legal document.

• Sub-step 1: Specify the granted rights (e.g., personal, commercial, merchandising).
• Sub-step 2: Define the royalty structure, including percentage and payment address for secondary sales.
• Sub-step 3: Set restrictions and expiration clauses, if any, such as a time limit or a cap on units produced.

jsonCopy
{
  "license": "CC BY-NC 4.0",
  "commercialUse": false,
  "royaltyBPS": 1000,
  "royaltyReceiver": "0x742d35Cc6634C0532925a3b844Bc9e...",
  "attributes": [
    { "trait_type": "License Type", "value": "Non-Commercial" }
  ]
}

Tip: Use established standards like Creative Commons codes or custom schema extensions for interoperability.

Detailed Instructions

Integrate the license definition into the NFT's technical architecture. The most common method is to store a license identifier or a tokenURI pointing to the license metadata in the NFT's contract storage. For dynamic or updatable licenses, implement a mapping from tokenId to a license hash or a struct containing the terms.

• Sub-step 1: In your ERC-721/1155 contract, add a state variable like mapping(uint256 => string) private _licenseURIs.
• Sub-step 2: Create a function setLicenseURI(uint256 tokenId, string memory uri) with appropriate access control (e.g., onlyOwner).
• Sub-step 3: Emit a LicenseUpdated event upon any modification for off-chain indexers to track.

solidityCopy
// Example contract snippet
string public constant licenseStandard = "LICS-1";
mapping(uint256 => string) private _licenseURIs;
event LicenseUpdated(uint256 indexed tokenId, string licenseURI);

function setLicenseURI(uint256 tokenId, string memory uri) external onlyOwner {
    _licenseURIs[tokenId] = uri;
    emit LicenseUpdated(tokenId, uri);
}

Tip: Consider using an immutable IPFS hash (CID) for the license document to guarantee permanence and auditability.

Detailed Instructions

Ensure the financial terms of the license are automatically executed. Adhere to the EIP-2981: NFT Royalty Standard to declare royalty information. Marketplaces that support this standard will query your contract's royaltyInfo function to pay the designated percentage to the rights holder on each sale.

• Sub-step 1: Implement the royaltyInfo function in your NFT contract, returning the receiver address and royalty amount.
• Sub-step 2: Calculate the royalty using basis points (e.g., 1000 BPS = 10%) of the salePrice.
• Sub-step 3: For more complex logic (e.g., tiered royalties), store the royalty BPS in the license struct mapped to each token.

solidityCopy
// EIP-2981 implementation
function royaltyInfo(uint256 tokenId, uint256 salePrice)
    external
    view
    override
    returns (address receiver, uint256 royaltyAmount)
{
    receiver = royaltyReceiver; // Could be fetched from _licenseData[tokenId]
    royaltyAmount = (salePrice * royaltyBasisPoints) / 10000;
}

Tip: Use a proxy receiver contract that can split payments between multiple parties, such as the original creator and a licensor.

Detailed Instructions

The license must be bound to the token and seamlessly transfer with it. Override the _beforeTokenTransfer hook in your ERC-721 contract to include license state checks. This is crucial for enforcing license validity—for example, preventing the transfer of a token if its license has been revoked due to a breach of terms.

• Sub-step 1: Add a state variable mapping(uint256 => bool) public licenseRevoked.
• Sub-step 2: In _beforeTokenTransfer, require that !licenseRevoked[tokenId].
• Sub-step 3: Implement an adminRevokeLicense function that flips this flag, effectively freezing the asset's licensed utility.
• Sub-step 4: Ensure the full license metadata remains accessible to the new owner post-transfer.

solidityCopy
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
    internal
    virtual
    override
{
    super._beforeTokenTransfer(from, to, tokenId);
    require(!_licenseRevoked[tokenId], "License revoked: transfer blocked");
}

function revokeLicense(uint256 tokenId) external onlyLicensor {
    _licenseRevoked[tokenId] = true;
    emit LicenseRevoked(tokenId);
}

Tip: For non-revocable licenses, you can omit the transfer check, making the license a permanent, transferable right.

Detailed Instructions

Develop utilities that allow anyone to query and understand the active license. Build a verifier service or a frontend component that reads the on-chain license URI and the revocation status, then fetches and displays the human-readable terms. This is essential for license compliance and user trust.

• Sub-step 1: Write a script (e.g., in JavaScript) that uses ethers.js to call tokenURI(tokenId) and the custom getLicenseURI(tokenId) function.
• Sub-step 2: Fetch the JSON metadata from the returned URI (IPFS or HTTP).
• Sub-step 3: Parse the metadata to display key terms like commercialUse, royaltyBPS, and expiration.
• Sub-step 4: Call the licenseRevoked(tokenId) view function to display active/revoked status.

javascriptCopy
// Example verification snippet using ethers.js
const licenseURI = await nftContract.getLicenseURI(tokenId);
const metaResponse = await fetch(licenseURI);
const licenseMeta = await metaResponse.json();
const isRevoked = await nftContract.licenseRevoked(tokenId);
console.log(`License Active: ${!isRevoked}`);
console.log(`Terms: ${licenseMeta.license}`);

Tip: Consider publishing an open-source SDK or a widget that marketplaces can embed to standardize license display.