Royalty-Splitting Smart Contract

What it does:
Automatically splits revenue or royalties from digital content, NFT sales, streaming, or creator collaborations among multiple stakeholders on-chain.

Why it matters:
Eliminates disputes, ensures fair compensation for creators, collaborators, and platforms, and makes payments transparent, instant, and auditable.

How it works:

Content or NFT creators define stakeholders (co-creators, platforms, managers) and their percentage shares
Revenue from sales, streaming, or digital content usage is sent to the contract
Smart contract calculates each stakeholder’s share based on predefined percentages
Funds are distributed automatically to all stakeholders instantly
Distribution history is immutable and publicly auditable on-chain
Allows updates to stakeholder shares or adding new collaborators with proper authorization
Can integrate with NFT marketplaces, streaming platforms, or content licensing contracts for automated payouts

      // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title MediaRoyaltySplitter
 * @author Nam
 * @notice Splits revenue and royalties among creators, collaborators, and platforms
 */
contract MediaRoyaltySplitter {

    address public admin;

    struct Stakeholder {
        address payable account;
        uint256 share; // basis points (1% = 100)
    }

    Stakeholder[] public stakeholders;
    uint256 public totalShares; // max 10000 (100%)

    // -------------------- EVENTS --------------------

    event StakeholderAdded(address indexed account, uint256 share);
    event StakeholderUpdated(address indexed account, uint256 oldShare, uint256 newShare);
    event RevenueReceived(address indexed from, uint256 amount);
    event RevenueDistributed(uint256 amount);

    // -------------------- MODIFIERS --------------------

    modifier onlyAdmin() {
        require(msg.sender == admin, "Not admin");
        _;
    }

    // -------------------- CONSTRUCTOR --------------------

    constructor() {
        admin = msg.sender;
    }

    // -------------------- STAKEHOLDER MANAGEMENT --------------------

    function addStakeholder(address payable _account, uint256 _share) external onlyAdmin {
        require(_account != address(0), "Invalid account");
        require(_share &gt; 0, "Share must be &gt;0");
        require(totalShares + _share &lt;= 10000, &quot;Exceeds 100%&quot;);

        stakeholders.push(Stakeholder({account: _account, share: _share}));
        totalShares += _share;

        emit StakeholderAdded(_account, _share);
    }

    function updateStakeholder(uint256 index, uint256 newShare) external onlyAdmin {
        require(index &lt; stakeholders.length, &quot;Invalid index&quot;);
        uint256 oldShare = stakeholders[index].share;
        totalShares = totalShares - oldShare + newShare;
        require(totalShares  0, "No stakeholders");
        for (uint256 i = 0; i &lt; stakeholders.length; i++) {
            uint256 payment = (amount * stakeholders[i].share) / 10000;
            stakeholders[i].account.transfer(payment);
        }
        emit RevenueDistributed(amount);
    }
}