音乐NFT与电影配乐：从采样库到链上版权分账

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

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract FilmScoreNFT is ERC721, AccessControl, ReentrancyGuard {
    using Counters for Counters.Counter;

    bytes32 public constant COMPOSER_ROLE = keccak256("COMPOSER_ROLE");
    bytes32 public constant PRODUCER_ROLE = keccak256("PRODUCER_ROLE");
    bytes32 public constant DISTRIBUTOR_ROLE = keccak256("DISTRIBUTOR_ROLE");

    Counters.Counter private _tokenIdCounter;

    enum ScoreStatus {
        INCEPTION,      // 概念阶段
        COMPOSING,      // 作曲中
        RECORDING,      // 录制中
        MIXING,         // 混音中
        MASTERING,      // 母带制作中
        DELIVERED,      // 已交付
        PUBLISHED,      // 已发布
        TOKENIZED       // 已Token化
    }

    enum RevenueSource {
        BOX_OFFICE,         // 票房
        STREAMING,          // 流媒体
        SYNC_LICENSE,       // 同步授权
        PUBLIC_PERFORMANCE, // 公开表演
        MERCHANDISE,        // 周边商品
        SAMPLING            // 采样授权
    }

    struct SampleSource {
        uint256 sampleId;
        string title;
        string artist;
        string ipfsURI;
        uint256 royaltyPercentage;  // basis points
        bool isCleared;
        bool isNFT;
    }

    struct ScoreTrack {
        uint256 trackId;
        string title;
        uint256 duration;  // seconds
        string ipfsAudioURI;
        string ipfsMetadataURI;
        string bpm;
        string key;
        string genre;
        SampleSource[] samples;
        uint256 composerShare;  // basis points
        uint256 producerShare;  // basis points
        uint256 performerShare; // basis points
        bool isMastered;
    }

    struct FilmScore {
        uint256 scoreId;
        string filmTitle;
        string composer;
        string director;
        uint256 releaseYear;
        uint256 trackCount;
        uint256 totalDuration;  // seconds
        ScoreStatus status;
        string ipfsCoverURI;
        address[] contributors;
        uint256[] contributionShares;  // basis points
        uint256 totalRevenue;
        uint256 lastDistributionTime;
    }

    struct RevenueDistribution {
        uint256 distributionId;
        uint256 scoreId;
        RevenueSource source;
        uint256 amount;
        uint256 timestamp;
        uint256 recipientCount;
        bool isDistributed;
    }

    uint256 private _scoreCounter;
    uint256 private _distributionCounter;

    mapping(uint256 => FilmScore) public filmScores;
    mapping(uint256 => ScoreTrack[]) public scoreTracks;
    mapping(uint256 => RevenueDistribution) public distributions;
    mapping(uint256 => mapping(address => uint256)) public unclaimedRevenue;
    mapping(uint256 => address[]) public scoreContributors;

    uint256 public constant PLATFORM_FEE = 250; // 2.5% basis points
    uint256 public constant MIN_DISTRIBUTION_INTERVAL = 7 days;

    IERC20 public revenueToken;

    event ScoreCreated(uint256 indexed scoreId, string filmTitle, address indexed composer);
    event TrackAdded(uint256 indexed scoreId, uint256 indexed trackId, string title);
    event RevenueReceived(uint256 indexed scoreId, RevenueSource indexed source, uint256 amount);
    event RevenueDistributed(uint256 indexed distributionId, uint256 indexed scoreId, uint256 totalAmount);
    event RoyaltyClaimed(address indexed contributor, uint256 amount);
    event SampleCleared(uint256 indexed scoreId, uint256 indexed sampleId, address indexed sampleOwner);

    constructor(address _revenueToken) ERC721("FilmScoreNFT", "FSN") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(COMPOSER_ROLE, msg.sender);
        revenueToken = IERC20(_revenueToken);
    }

    function createScore(
        string memory _filmTitle,
        string memory _composer,
        string memory _director,
        uint256 _releaseYear,
        string memory _ipfsCoverURI,
        address[] memory _contributors,
        uint256[] memory _contributionShares
    ) external onlyRole(COMPOSER_ROLE) returns (uint256) {
        require(_contributors.length == _contributionShares.length, "Array length mismatch");

        uint256 totalShares = 0;
        for (uint256 i = 0; i < _contributionShares.length; i++) {
            totalShares += _contributionShares[i];
        }
        require(totalShares == 10000, "Total shares must be 10000 basis points");

        uint256 scoreId = _scoreCounter++;
        filmScores[scoreId] = FilmScore({
            scoreId: scoreId,
            filmTitle: _filmTitle,
            composer: _composer,
            director: _director,
            releaseYear: _releaseYear,
            trackCount: 0,
            totalDuration: 0,
            status: ScoreStatus.INCEPTION,
            ipfsCoverURI: _ipfsCoverURI,
            contributors: _contributors,
            contributionShares: _contributionShares,
            totalRevenue: 0,
            lastDistributionTime: 0
        });

        scoreContributors[scoreId] = _contributors;
        _tokenIdCounter.increment();
        _safeMint(msg.sender, _tokenIdCounter.current());

        emit ScoreCreated(scoreId, _filmTitle, msg.sender);
        return scoreId;
    }

    function addTrack(
        uint256 _scoreId,
        string memory _title,
        uint256 _duration,
        string memory _ipfsAudioURI,
        string memory _ipfsMetadataURI,
        string memory _bpm,
        string memory _key,
        string memory _genre,
        uint256 _composerShare,
        uint256 _producerShare,
        uint256 _performerShare
    ) external onlyRole(COMPOSER_ROLE) {
        FilmScore storage score = filmScores[_scoreId];
        require(score.status == ScoreStatus.INCEPTION || score.status == ScoreStatus.COMPOSING, "Invalid status");

        uint256 trackId = score.trackCount;
        ScoreTrack memory track = ScoreTrack({
            trackId: trackId,
            title: _title,
            duration: _duration,
            ipfsAudioURI: _ipfsAudioURI,
            ipfsMetadataURI: _ipfsMetadataURI,
            bpm: _bpm,
            key: _key,
            genre: _genre,
            samples: new SampleSource[](0),
            composerShare: _composerShare,
            producerShare: _producerShare,
            performerShare: _performerShare,
            isMastered: false
        });

        scoreTracks[_scoreId].push(track);
        score.trackCount++;
        score.totalDuration += _duration;

        emit TrackAdded(_scoreId, trackId, _title);
    }

    function addSampleToTrack(
        uint256 _scoreId,
        uint256 _trackId,
        string memory _title,
        string memory _artist,
        string memory _ipfsURI,
        uint256 _royaltyPercentage
    ) external onlyRole(COMPOSER_ROLE) {
        require(_trackId < scoreTracks[_scoreId].length, "Track not found");
        SampleSource memory sample = SampleSource({
            sampleId: scoreTracks[_scoreId][_trackId].samples.length,
            title: _title,
            artist: _artist,
            ipfsURI: _ipfsURI,
            royaltyPercentage: _royaltyPercentage,
            isCleared: false,
            isNFT: false
        });
        scoreTracks[_scoreId][_trackId].samples.push(sample);
    }

    function receiveRevenue(
        uint256 _scoreId,
        RevenueSource _source,
        uint256 _amount
    ) external nonReentrant {
        require(revenueToken.transferFrom(msg.sender, address(this), _amount), "Transfer failed");
        FilmScore storage score = filmScores[_scoreId];
        score.totalRevenue += _amount;

        emit RevenueReceived(_scoreId, _source, _amount);
        _distributeRevenue(_scoreId, _source, _amount);
    }

    function _distributeRevenue(
        uint256 _scoreId,
        RevenueSource _source,
        uint256 _amount
    ) internal {
        FilmScore storage score = filmScores[_scoreId];
        uint256 netAmount = _amount - (_amount * PLATFORM_FEE / 10000);
        uint256 distributionId = _distributionCounter++;

        distributions[distributionId] = RevenueDistribution({
            distributionId: distributionId,
            scoreId: _scoreId,
            source: _source,
            amount: netAmount,
            timestamp: block.timestamp,
            recipientCount: score.contributors.length,
            isDistributed: true
        });

        for (uint256 i = 0; i < score.contributors.length; i++) {
            address contributor = score.contributors[i];
            uint256 share = score.contributionShares[i];
            uint256 contributorAmount = netAmount * share / 10000;
            unclaimedRevenue[_scoreId][contributor] += contributorAmount;
        }

        score.lastDistributionTime = block.timestamp;
        emit RevenueDistributed(distributionId, _scoreId, netAmount);
    }

    function claimRoyalty(uint256 _scoreId) external nonReentrant {
        uint256 amount = unclaimedRevenue[_scoreId][msg.sender];
        require(amount > 0, "No unclaimed revenue");
        unclaimedRevenue[_scoreId][msg.sender] = 0;
        require(revenueToken.transfer(msg.sender, amount), "Transfer failed");
        emit RoyaltyClaimed(msg.sender, amount);
    }

    function getTrackSamples(
        uint256 _scoreId,
        uint256 _trackId
    ) external view returns (SampleSource[] memory) {
        require(_trackId < scoreTracks[_scoreId].length, "Track not found");
        return scoreTracks[_scoreId][_trackId].samples;
    }

    function getUnclaimedRevenue(uint256 _scoreId, address _contributor) external view returns (uint256) {
        return unclaimedRevenue[_scoreId][_contributor];
    }

    function supportsInterface(bytes4 interfaceId) public view override(ERC721, AccessControl) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
}

"""
Film Score NFT Platform - Smart Contract for Music Rights Management
Implements on-chain royalty distribution for film composers
"""

from typing import List, Dict, Optional, Tuple
from dataclasses import dataclass
from enum import Enum
import hashlib
import time
import json
from decimal import Decimal, ROUND_DOWN

class ScoreStatus(Enum):
    CONCEPT = "concept"
    COMPOSING = "composing"
    RECORDING = "recording"
    MIXING = "mixing"
    MASTERING = "mastering"
    DELIVERED = "delivered"
    RELEASED = "released"
    TOKENIZED = "tokenized"

class RevenueSource(Enum):
    BOX_OFFICE = "box_office"
    STREAMING = "streaming"
    SYNC_LICENSE = "sync_license"
    PUBLIC_PERFORMANCE = "public_performance"
    MECHANICAL = "mechanical"
    MERCHANDISE = "merchandise"

@dataclass
class SampleLicense:
    sample_id: str
    title: str
    original_artist: str
    original_composer: str
    ipfs_uri: str
    royalty_percentage: Decimal  # basis points
    license_type: str  # exclusive, non_exclusive, sync
    territory: str  # worldwide, specific regions
    duration: int  # license duration in days
    is_nft: bool
    nft_contract: Optional[str]
    nft_token_id: Optional[int]

@dataclass
class ScoreTrack:
    track_id: int
    title: str
    duration: int  # seconds
    composer: str
    lyricist: Optional[str]
    arranger: Optional[str]
    performer: Optional[str]
    samples: List[SampleLicense]
    bpm: str
    key: str
    genre: str
    ipfs_audio: str
    ipfs_metadata: str
    is_mastered: bool
    master_owner: Optional[str]

@dataclass
class Contributor:
    address: str
    name: str
    role: str  # composer, producer, performer, lyricist, arranger
    share: Decimal  # basis points (0-10000)
    total_earned: Decimal
    is_verified: bool

@dataclass
class RevenueDistribution:
    distribution_id: str
    score_id: int
    source: RevenueSource
    gross_amount: Decimal
    platform_fee: Decimal
    net_amount: Decimal
    timestamp: float
    recipients: List[Tuple[str, Decimal]]  # (address, amount)
    transaction_hash: Optional[str]

class FilmScoreNFTPlatform:
    """
    On-chain platform for film score rights management and royalty distribution
    """
    
    PLATFORM_FEE_BPS = 250  # 2.5%
    MIN_DISTRIBUTION_INTERVAL = 604800  # 7 days in seconds
    
    def __init__(self, platform_owner: str):
        self.platform_owner = platform_owner
        self.scores: Dict[int, Dict] = {}
        self.tracks: Dict[int, List[ScoreTrack]] = {}
        self.contributors: Dict[int, List[Contributor]] = {}
        self.distributions: List[RevenueDistribution] = []
        self.sample_library: Dict[str, SampleLicense] = {}
        self.unclaimed_balances: Dict[str, Dict[str, Decimal]] = {}  # score_id -> address -> balance
        self.score_counter = 0
        self.distribution_counter = 0
        
    def register_sample(self, sample: SampleLicense) -> bool:
        """Register a new sample in the on-chain library"""
        if sample.sample_id in self.sample_library:
            raise ValueError(f"Sample {sample.sample_id} already registered")
        
        self.sample_library[sample.sample_id] = sample
        return True
    
    def create_score(self, film_title: str, composer: str, 
                     director: str, release_year: int,
                     contributors: List[Contributor]) -> int:
        """Create a new film score with contributor shares"""
        total_shares = sum(c.share for c in contributors)
        if total_shares != Decimal('10000'):
            raise ValueError(f"Total shares must be 10000 bps, got {total_shares}")
        
        score_id = self.score_counter
        self.scores[score_id] = {
            'score_id': score_id,
            'film_title': film_title,
            'composer': composer,
            'director': director,
            'release_year': release_year,
            'track_count': 0,
            'total_duration': 0,
            'status': ScoreStatus.CONCEPT,
            'total_revenue': Decimal('0'),
            'last_distribution': 0,
            'created_at': time.time(),
            'created_by': composer
        }
        
        self.contributors[score_id] = contributors
        self.tracks[score_id] = []
        self.unclaimed_balances[score_id] = {}
        
        for contributor in contributors:
            self.unclaimed_balances[score_id][contributor.address] = Decimal('0')
        
        self.score_counter += 1
        return score_id
    
    def add_track(self, score_id: int, track: ScoreTrack) -> bool:
        """Add a track to a film score"""
        if score_id not in self.scores:
            raise ValueError(f"Score {score_id} not found")
        
        score = self.scores[score_id]
        track.track_id = score['track_count']
        self.tracks[score_id].append(track)
        
        score['track_count'] += 1
        score['total_duration'] += track.duration
        
        return True
    
    def _calculate_sample_royalties(self, track: ScoreTrack, 
                                     track_revenue: Decimal) -> Dict[str, Decimal]:
        """Calculate sample royalties for a track"""
        sample_royalties = {}
        total_sample_bps = sum(s.royalty_percentage for s in track.samples)
        
        if total_sample_bps > 0:
            for sample in track.samples:
                sample_share = track_revenue * sample.royalty_percentage / Decimal('10000')
                sample_royalties[sample.original_composer] = sample_share
        
        return sample_royalties
    
    def distribute_revenue(self, score_id: int, source: RevenueSource,
                           gross_amount: Decimal) -> RevenueDistribution:
        """Distribute revenue to all contributors"""
        if score_id not in self.scores:
            raise ValueError(f"Score {score_id} not found")
        
        score = self.scores[score_id]
        
        # Check distribution interval
        if time.time() - score['last_distribution'] < self.MIN_DISTRIBUTION_INTERVAL:
            if score['last_distribution'] > 0:
                raise ValueError("Distribution interval not met")
        
        # Calculate fees
        platform_fee = gross_amount * Decimal(self.PLATFORM_FEE_BPS) / Decimal('10000')
        net_amount = gross_amount - platform_fee
        
        # Calculate contributor shares
        recipients = []
        contributors = self.contributors[score_id]
        
        for contributor in contributors:
            share_amount = net_amount * contributor.share / Decimal('10000')
            recipients.append((contributor.address, share_amount))
            
            # Add to unclaimed balance
            self.unclaimed_balances[score_id][contributor.address] += share_amount
        
        # Handle sample royalties
        for track in self.tracks[score_id]:
            track_revenue = net_amount / Decimal(str(len(self.tracks[score_id])))
            sample_royalties = self._calculate_sample_royalties(track, track_revenue)
            
            for composer, amount in sample_royalties.items():
                if composer not in [c.address for c in contributors]:
                    recipients.append((composer, amount))
                    if score_id not in self.unclaimed_balances:
                        self.unclaimed_balances[score_id] = {}
                    self.unclaimed_balances[score_id][composer] = \
                        self.unclaimed_balances[score_id].get(composer, Decimal('0')) + amount
        
        # Update score
        score['total_revenue'] += gross_amount
        score['last_distribution'] = time.time()
        
        # Create distribution record
        distribution_id = f"DIST-{score_id}-{self.distribution_counter}"
        distribution = RevenueDistribution(
            distribution_id=distribution_id,
            score_id=score_id,
            source=source,
            gross_amount=gross_amount,
            platform_fee=platform_fee,
            net_amount=net_amount,
            timestamp=time.time(),
            recipients=recipients,
            transaction_hash=None
        )
        
        self.distributions.append(distribution)
        self.distribution_counter += 1
        
        return distribution
    
    def claim_royalties(self, score_id: int, address: str) -> Decimal:
        """Claim accumulated royalties for a contributor"""
        if score_id not in self.unclaimed_balances:
            raise ValueError(f"No balances for score {score_id}")
        
        balance = self.unclaimed_balances[score_id].get(address, Decimal('0'))
        if balance <= 0:
            raise ValueError("No unclaimed royalties")
        
        self.unclaimed_balances[score_id][address] = Decimal('0')
        return balance
    
    def get_contributor_stats(self, score_id: int, address: str) -> Optional[Dict]:
        """Get detailed stats for a contributor on a score"""
        if score_id not in self.scores:
            return None
        
        for contributor in self.contributors[score_id]:
            if contributor.address == address:
                unclaimed = self.unclaimed_balances[score_id].get(address, Decimal('0'))
                return {
                    'name': contributor.name,
                    'role': contributor.role,
                    'share_bps': float(contributor.share),
                    'share_percentage': float(contributor.share / Decimal('100')),
                    'total_earned': float(contributor.total_earned),
                    'unclaimed': float(unclaimed),
                    'is_verified': contributor.is_verified
                }
        return None
    
    def get_score_summary(self, score_id: int) -> Optional[Dict]:
        """Get a summary of the film score"""
        if score_id not in self.scores:
            return None
        
        score = self.scores[score_id]
        return {
            'film_title': score['film_title'],
            'composer': score['composer'],
            'director': score['director'],
            'release_year': score['release_year'],
            'track_count': score['track_count'],
            'total_duration': score['total_duration'],
            'status': score['status'].value,
            'total_revenue': float(score['total_revenue']),
            'contributor_count': len(self.contributors[score_id]),
            'last_distribution': score['last_distribution']
        }

# Example: Dune: Part Two score
platform = FilmScoreNFTPlatform("0xPLATFORM_OWNER")

# Register sample library
platform.register_sample(SampleLicense(
    sample_id="SAMP-001",
    title="Bali Gamelan",
    original_artist="Gamelan Gong Kebyar",
    original_composer="Traditional",
    ipfs_uri="ipfs://QmSample1",
    royalty_percentage=Decimal('50'),  # 0.5%
    license_type="non_exclusive",
    territory="worldwide",
    duration=3650,  # 10 years
    is_nft=True,
    nft_contract="0xSAMPLE_NFT",
    nft_token_id=1
))

# Create score
contributors = [
    Contributor("0xCOMPOSER", "Hans Zimmer", "composer", Decimal('5000')),
    Contributor("0xPRODUCER", "Greg Wells", "producer", Decimal('2000')),
    Contributor("0xPERFORMER", "Tina Guo", "performer", Decimal('1500')),
    Contributor("0xPUBLISHER", "Remote Control", "publisher", Decimal('1500'))
]

score_id = platform.create_score(
    film_title="Dune: Part Two",
    composer="Hans Zimmer",
    director="Denis Villeneuve",
    release_year=2026,
    contributors=contributors
)

# Distribute box office revenue
distribution = platform.distribute_revenue(
    score_id=score_id,
    source=RevenueSource.STREAMING,
    gross_amount=Decimal('500000')  # $500,000 streaming revenue
)

print(f"Distribution ID: {distribution.distribution_id}")
print(f"Net amount: ${float(distribution.net_amount):,.2f}")
for recipient, amount in distribution.recipients:
    print(f"  {recipient}: ${float(amount):,.2f}")

# Check composer stats
composer_stats = platform.get_contributor_stats(score_id, "0xCOMPOSER")
print(f"\nComposer stats: {json.dumps(composer_stats, indent=2)}")

# Claim royalties
claimed = platform.claim_royalties(score_id, "0xCOMPOSER")
print(f"Claimed: ${float(claimed):,.2f}")

/**
 * Film Score Rights Management API
 * On-chain royalty distribution with sample tracking
 */

class FilmScoreRightsManager {
    constructor() {
        this.scores = new Map();
        this.tracks = new Map();
        this.sampleLibrary = new Map();
        this.contributors = new Map();
        this.distributions = [];
        this.unclaimedBalances = new Map();
        this.scoreIdCounter = 0;

        this.PLATFORM_FEE = 0.025; // 2.5%
        this.MIN_DISTRIBUTION_INTERVAL = 7 * 24 * 60 * 60 * 1000; // 7 days
    }

    /**
     * Register a sample in the library
     */
    registerSample(sampleId, title, originalArtist, royaltyPercentage) {
        if (this.sampleLibrary.has(sampleId)) {
            throw new Error(`Sample ${sampleId} already exists`);
        }

        const sample = {
            sampleId,
            title,
            originalArtist,
            royaltyPercentage, // basis points
            usageCount: 0,
            totalRevenue: 0,
            registeredAt: Date.now(),
            isNFT: false
        };

        this.sampleLibrary.set(sampleId, sample);
        console.log(`[SAMPLE] Registered: ${title} by ${originalArtist}`);
        return sample;
    }

    /**
     * Create a new film score
     */
    createScore(filmTitle, composer, director, releaseYear, contributors) {
        const totalShares = contributors.reduce((sum, c) => sum + c.share, 0);
        if (totalShares !== 10000) {
            throw new Error(`Total shares must be 10000 bps, got ${totalShares}`);
        }

        const scoreId = this.scoreIdCounter++;
        const score = {
            scoreId,
            filmTitle,
            composer,
            director,
            releaseYear,
            trackCount: 0,
            totalDuration: 0,
            status: 'concept',
            contributors,
            totalRevenue: 0,
            lastDistribution: 0,
            createdAt: Date.now()
        };

        this.scores.set(scoreId, score);
        this.tracks.set(scoreId, []);
        this.unclaimedBalances.set(scoreId, new Map());

        // Initialize unclaimed balances for all contributors
        contributors.forEach(c => {
            this.unclaimedBalances.get(scoreId).set(c.address, 0);
        });

        console.log(`[SCORE] Created: ${filmTitle} (ID: ${scoreId})`);
        return scoreId;
    }

    /**
     * Add a track to a score
     */
    addTrack(scoreId, trackData) {
        const score = this.scores.get(scoreId);
        if (!score) throw new Error(`Score ${scoreId} not found`);

        const track = {
            trackId: score.trackCount,
            ...trackData,
            samples: [],
            totalRevenue: 0
        };

        this.tracks.get(scoreId).push(track);
        score.trackCount++;
        score.totalDuration += trackData.duration || 0;

        console.log(`[TRACK] Added: ${trackData.title} to ${score.filmTitle}`);
        return track;
    }

    /**
     * Add a sample to a track
     */
    addSampleToTrack(scoreId, trackId, sampleId) {
        const sample = this.sampleLibrary.get(sampleId);
        if (!sample) throw new Error(`Sample ${sampleId} not found`);

        const tracks = this.tracks.get(scoreId);
        if (!tracks || trackId >= tracks.length) {
            throw new Error(`Track ${trackId} not found in score ${scoreId}`);
        }

        tracks[trackId].samples.push(sampleId);
        sample.usageCount++;
        console.log(`[SAMPLE] Added ${sample.title} to track ${tracks[trackId].title}`);
    }

    /**
     * Distribute revenue from a source
     */
    distributeRevenue(scoreId, source, grossAmount) {
        const score = this.scores.get(scoreId);
        if (!score) throw new Error(`Score ${scoreId} not found`);

        // Check interval
        const now = Date.now();
        if (score.lastDistribution > 0 && 
            (now - score.lastDistribution) < this.MIN_DISTRIBUTION_INTERVAL) {
            throw new Error('Distribution interval not met');
        }

        // Calculate fees
        const platformFee = grossAmount * this.PLATFORM_FEE;
        const netAmount = grossAmount - platformFee;

        // Distribute to contributors
        const recipients = [];
        const balances = this.unclaimedBalances.get(scoreId);

        score.contributors.forEach(contributor => {
            const shareAmount = netAmount * (contributor.share / 10000);
            const currentBalance = balances.get(contributor.address) || 0;
            balances.set(contributor.address, currentBalance + shareAmount);
            recipients.push({
                address: contributor.address,
                name: contributor.name,
                share: contributor.share,
                amount: shareAmount
            });
        });

        // Handle sample royalties
        const tracks = this.tracks.get(scoreId);
        const trackRevenue = netAmount / tracks.length;

        tracks.forEach(track => {
            track.samples.forEach(sampleId => {
                const sample = this.sampleLibrary.get(sampleId);
                if (sample) {
                    const sampleRoyalty = trackRevenue * (sample.royaltyPercentage / 10000);
                    sample.totalRevenue += sampleRoyalty;
                    
                    // Add to sample creator's balance
                    const currentBalance = balances.get(sample.originalArtist) || 0;
                    balances.set(sample.originalArtist, currentBalance + sampleRoyalty);
                    
                    recipients.push({
                        address: sample.originalArtist,
                        name: sample.title,
                        share: sample.royaltyPercentage,
                        amount: sampleRoyalty,
                        isSample: true
                    });
                }
            });
        });

        // Update score
        score.totalRevenue += grossAmount;
        score.lastDistribution = now;

        const distribution = {
            distributionId: `DIST-${scoreId}-${this.distributions.length}`,
            scoreId,
            source,
            grossAmount,
            platformFee,
            netAmount,
            timestamp: now,
            recipients,
            recipientCount: recipients.length
        };

        this.distributions.push(distribution);
        console.log(`[DISTRIBUTE] ${source}: $${netAmount.toFixed(2)} to ${recipients.length} recipients`);

        return distribution;
    }

    /**
     * Claim unclaimed royalties
     */
    claimRoyalties(scoreId, address) {
        const balances = this.unclaimedBalances.get(scoreId);
        if (!balances) throw new Error(`No balances for score ${scoreId}`);

        const balance = balances.get(address) || 0;
        if (balance <= 0) throw new Error('No unclaimed royalties');

        balances.set(address, 0);
        console.log(`[CLAIM] ${address} claimed $${balance.toFixed(2)} from score ${scoreId}`);
        return balance;
    }

    /**
     * Get score summary
     */
    getScoreSummary(scoreId) {
        const score = this.scores.get(scoreId);
        if (!score) return null;

        const tracks = this.tracks.get(scoreId);
        let totalSampleUsage = 0;
        tracks.forEach(t => totalSampleUsage += t.samples.length);

        return {
            title: score.filmTitle,
            composer: score.composer,
            tracks: score.trackCount,
            duration: score.totalDuration,
            status: score.status,
            totalRevenue: score.totalRevenue,
            contributorCount: score.contributors.length,
            totalSampleUsage,
            unclaimedTotal: [...this.unclaimedBalances.get(scoreId).values()]
                .reduce((sum, v) => sum + v, 0)
        };
    }
}

// Example: Dune score rights management
const manager = new FilmScoreRightsManager();

// Register samples
manager.registerSample('SAMP-001', 'Bali Gamelan', 'Traditional', 50);
manager.registerSample('SAMP-002', 'Moroccan Percussion', 'Hassan Hakmoun', 75);
manager.registerSample('SAMP-003', 'Didgeridoo Drone', 'William Barton', 30);

// Create score
const scoreId = manager.createScore(
    'Dune: Part Two',
    'Hans Zimmer',
    'Denis Villeneuve',
    2026,
    [
        { address: '0xCOMPOSER', name: 'Hans Zimmer', role: 'composer', share: 5000 },
        { address: '0xPRODUCER', name: 'Greg Wells', role: 'producer', share: 2000 },
        { address: '0xPERFORMER', name: 'Tina Guo', role: 'performer', share: 1500 },
        { address: '0xPUBLISHER', name: 'Remote Control', role: 'publisher', share: 1500 }
    ]
);

// Add tracks
manager.addTrack(scoreId, {
    title: 'Paul\'s Dream',
    duration: 245,
    composer: 'Hans Zimmer',
    genre: 'Orchestral/Electronic'
});

manager.addTrack(scoreId, {
    title: 'Ride the Worm',
    duration: 312,
    composer: 'Hans Zimmer',
    genre: 'Epic/World'
});

// Add samples to tracks
manager.addSampleToTrack(scoreId, 0, 'SAMP-001');
manager.addSampleToTrack(scoreId, 1, 'SAMP-002');
manager.addSampleToTrack(scoreId, 1, 'SAMP-003');

// Distribute streaming revenue
manager.distributeRevenue(scoreId, 'streaming', 500000);

// Check summary
const summary = manager.getScoreSummary(scoreId);
console.log('Score summary:', JSON.stringify(summary, null, 2));

// Claim composer royalties
const claimed = manager.claimRoyalties(scoreId, '0xCOMPOSER');
console.log(`Composer claimed: $${claimed.toFixed(2)}`);