Tokenized Real Estate ROI Calculator: Complete Property Investment Analysis Guide

class TokenizedRealEstateROI {
    constructor(initialInvestment, tokenPrice, propertyValue, annualRent) {
        this.initialInvestment = initialInvestment;
        this.tokenPrice = tokenPrice;
        this.propertyValue = propertyValue;
        this.annualRent = annualRent;
        this.tokensOwned = initialInvestment / tokenPrice;
        this.ownershipPercentage = (initialInvestment / propertyValue) * 100;
    }

    // Calculate annual rental yield
    calculateRentalYield() {
        const annualRentalIncome = (this.annualRent * this.ownershipPercentage) / 100;
        const rentalYield = (annualRentalIncome / this.initialInvestment) * 100;
        return {
            annualIncome: annualRentalIncome,
            yieldPercentage: rentalYield
        };
    }

    // Calculate capital appreciation over time
    calculateAppreciation(currentPropertyValue, currentTokenPrice) {
        const propertyAppreciation = ((currentPropertyValue - this.propertyValue) / this.propertyValue) * 100;
        const tokenAppreciation = ((currentTokenPrice - this.tokenPrice) / this.tokenPrice) * 100;
        const currentValue = this.tokensOwned * currentTokenPrice;
        const capitalGain = currentValue - this.initialInvestment;
        
        return {
            propertyAppreciation,
            tokenAppreciation,
            currentValue,
            capitalGain,
            appreciationPercentage: (capitalGain / this.initialInvestment) * 100
        };
    }

    // Calculate total return including fees
    calculateTotalROI(currentPropertyValue, currentTokenPrice, fees = {}) {
        const rental = this.calculateRentalYield();
        const appreciation = this.calculateAppreciation(currentPropertyValue, currentTokenPrice);
        
        // Default fee structure
        const totalFees = {
            tradingFees: fees.tradingFees || 0.005, // 0.5%
            managementFees: fees.managementFees || 0.02, // 2% annually
            platformFees: fees.platformFees || 0.01 // 1% annually
        };

        const annualFeesCost = this.initialInvestment * (totalFees.managementFees + totalFees.platformFees);
        const tradingCosts = this.initialInvestment * totalFees.tradingFees;
        const netRentalIncome = rental.annualIncome - annualFeesCost;
        const netCapitalGain = appreciation.capitalGain - tradingCosts;
        const totalReturn = netRentalIncome + netCapitalGain;
        const totalROI = (totalReturn / this.initialInvestment) * 100;

        return {
            grossRentalYield: rental.yieldPercentage,
            netRentalYield: (netRentalIncome / this.initialInvestment) * 100,
            capitalAppreciation: appreciation.appreciationPercentage,
            totalROI,
            netReturn: totalReturn,
            feesCost: annualFeesCost + tradingCosts
        };
    }

    // Risk-adjusted return calculation
    calculateSharpeRatio(returns, riskFreeRate = 0.02) {
        const avgReturn = returns.reduce((sum, r) => sum + r, 0) / returns.length;
        const variance = returns.reduce((sum, r) => sum + Math.pow(r - avgReturn, 2), 0) / returns.length;
        const standardDeviation = Math.sqrt(variance);
        const excessReturn = avgReturn - riskFreeRate;
        
        return standardDeviation !== 0 ? excessReturn / standardDeviation : 0;
    }

    // Liquidity impact assessment
    assessLiquidity(tradingVolume, marketCap) {
        const liquidityRatio = tradingVolume / marketCap;
        let liquidityScore;
        
        if (liquidityRatio > 0.1) liquidityScore = "High";
        else if (liquidityRatio > 0.05) liquidityScore = "Medium";
        else liquidityScore = "Low";
        
        return {
            liquidityRatio,
            liquidityScore,
            liquidityPremium: liquidityRatio > 0.05 ? 1.0 : 0.85 // Discount for low liquidity
        };
    }
}

// Portfolio diversification calculator
class TokenizedRealEstatePortfolio {
    constructor() {
        this.properties = [];
    }

    addProperty(propertyData) {
        const property = new TokenizedRealEstateROI(
            propertyData.investment,
            propertyData.tokenPrice,
            propertyData.propertyValue,
            propertyData.annualRent
        );
        
        this.properties.push({
            ...property,
            location: propertyData.location,
            propertyType: propertyData.propertyType,
            platform: propertyData.platform
        });
    }

    calculatePortfolioROI(marketData) {
        let totalInvestment = 0;
        let totalReturn = 0;
        let portfolioMetrics = [];

        this.properties.forEach((property, index) => {
            const marketInfo = marketData[index];
            const roi = property.calculateTotalROI(
                marketInfo.currentPropertyValue,
                marketInfo.currentTokenPrice,
                marketInfo.fees
            );
            
            totalInvestment += property.initialInvestment;
            totalReturn += roi.netReturn;
            portfolioMetrics.push(roi);
        });

        const portfolioROI = (totalReturn / totalInvestment) * 100;
        
        return {
            portfolioROI,
            totalInvestment,
            totalReturn,
            properties: portfolioMetrics,
            diversificationScore: this.calculateDiversification()
        };
    }

    calculateDiversification() {
        const locations = new Set(this.properties.map(p => p.location));
        const types = new Set(this.properties.map(p => p.propertyType));
        const platforms = new Set(this.properties.map(p => p.platform));
        
        return {
            locationDiversity: locations.size,
            typeDiversity: types.size,
            platformDiversity: platforms.size,
            totalProperties: this.properties.length
        };
    }
}

// Example: Investing in tokenized Miami apartment
const miamiApartment = new TokenizedRealEstateROI(
    5000,  // $5,000 initial investment
    10,    // $10 per token
    500000, // $500,000 property value
    30000   // $30,000 annual rental income
);

console.log(`Tokens owned: ${miamiApartment.tokensOwned}`);
console.log(`Ownership percentage: ${miamiApartment.ownershipPercentage.toFixed(3)}%`);

const rentalAnalysis = miamiApartment.calculateRentalYield();
console.log(`Annual rental income: $${rentalAnalysis.annualIncome.toFixed(2)}`);
console.log(`Rental yield: ${rentalAnalysis.yieldPercentage.toFixed(2)}%`);

// After 1 year: property appreciated, token price increased
const appreciationAnalysis = miamiApartment.calculateAppreciation(
    550000, // New property value: $550,000 (+10%)
    12      // New token price: $12 (+20%)
);

console.log(`Property appreciation: ${appreciationAnalysis.propertyAppreciation.toFixed(2)}%`);
console.log(`Token appreciation: ${appreciationAnalysis.tokenAppreciation.toFixed(2)}%`);
console.log(`Capital gain: $${appreciationAnalysis.capitalGain.toFixed(2)}`);

const totalROI = miamiApartment.calculateTotalROI(
    550000, // Current property value
    12,     // Current token price
    {
        tradingFees: 0.005,      // 0.5% trading fees
        managementFees: 0.015,   // 1.5% annual management
        platformFees: 0.01      // 1% platform fees
    }
);

console.log(`Net rental yield: ${totalROI.netRentalYield.toFixed(2)}%`);
console.log(`Capital appreciation: ${totalROI.capitalAppreciation.toFixed(2)}%`);
console.log(`Total ROI: ${totalROI.totalROI.toFixed(2)}%`);
console.log(`Net return: $${totalROI.netReturn.toFixed(2)}`);

// Historical returns for risk calculation (monthly returns over 12 months)
const monthlyReturns = [0.02, -0.01, 0.03, 0.01, -0.02, 0.04, 0.02, 0.01, -0.01, 0.03, 0.02, 0.01];

const sharpeRatio = miamiApartment.calculateSharpeRatio(monthlyReturns, 0.002); // 0.2% monthly risk-free rate
console.log(`Sharpe ratio: ${sharpeRatio.toFixed(3)}`);

const liquidityAssessment = miamiApartment.assessLiquidity(
    100000,  // $100,000 daily trading volume
    2000000  // $2,000,000 total market cap
);

console.log(`Liquidity score: ${liquidityAssessment.liquidityScore}`);
console.log(`Liquidity premium: ${liquidityAssessment.liquidityPremium}`);

const portfolio = new TokenizedRealEstatePortfolio();

// Add properties from different locations
portfolio.addProperty({
    investment: 3000,
    tokenPrice: 15,
    propertyValue: 400000,
    annualRent: 24000,
    location: "New York",
    propertyType: "Residential",
    platform: "RealT"
});

portfolio.addProperty({
    investment: 2000,
    tokenPrice: 8,
    propertyValue: 300000,
    annualRent: 18000,
    location: "Berlin",
    propertyType: "Commercial",
    platform: "Fundrise"
});

// Current market data for portfolio analysis
const marketData = [
    {
        currentPropertyValue: 420000,
        currentTokenPrice: 16,
        fees: { tradingFees: 0.005, managementFees: 0.02, platformFees: 0.01 }
    },
    {
        currentPropertyValue: 315000,
        currentTokenPrice: 9,
        fees: { tradingFees: 0.007, managementFees: 0.018, platformFees: 0.012 }
    }
];

const portfolioAnalysis = portfolio.calculatePortfolioROI(marketData);
console.log(`Portfolio ROI: ${portfolioAnalysis.portfolioROI.toFixed(2)}%`);
console.log(`Total return: $${portfolioAnalysis.totalReturn.toFixed(2)}`);

function compareToTraditionalREITs(tokenizedROI, reitReturns) {
    const outperformance = tokenizedROI - reitReturns;
    const relativePerformance = (outperformance / reitReturns) * 100;
    
    return {
        outperformance,
        relativePerformance,
        recommendation: outperformance > 0 ? "Favorable" : "Unfavorable"
    };
}

// Example comparison
const comparison = compareToTraditionalREITs(23.5, 8.2);
console.log(`Outperformance: ${comparison.outperformance.toFixed(2)}%`);
console.log(`Relative performance: ${comparison.relativePerformance.toFixed(2)}%`);

function calculateRebalancing(currentAllocation, targetAllocation, portfolioValue) {
    const rebalancingActions = [];
    
    Object.keys(targetAllocation).forEach(asset => {
        const currentWeight = currentAllocation[asset] || 0;
        const targetWeight = targetAllocation[asset];
        const difference = targetWeight - currentWeight;
        const dollarAmount = (difference * portfolioValue) / 100;
        
        if (Math.abs(dollarAmount) > 100) { // Only rebalance if difference > $100
            rebalancingActions.push({
                asset,
                action: dollarAmount > 0 ? "Buy" : "Sell",
                amount: Math.abs(dollarAmount)
            });
        }
    });
    
    return rebalancingActions;
}

class TaxRecordKeeper {
    constructor() {
        this.transactions = [];
        this.rentalIncome = [];
    }
    
    addTransaction(type, amount, tokenPrice, date, fees) {
        this.transactions.push({
            type, // "buy" or "sell"
            amount,
            tokenPrice,
            date,
            fees,
            timestamp: Date.now()
        });
    }
    
    addRentalIncome(amount, date, property) {
        this.rentalIncome.push({
            amount,
            date,
            property,
            timestamp: Date.now()
        });
    }
    
    generateTaxReport(taxYear) {
        // Filter transactions by tax year
        const yearTransactions = this.transactions.filter(t => 
            new Date(t.date).getFullYear() === taxYear
        );
        
        const yearRental = this.rentalIncome.filter(r => 
            new Date(r.date).getFullYear() === taxYear
        );
        
        return {
            transactions: yearTransactions,
            rentalIncome: yearRental,
            totalRental: yearRental.reduce((sum, r) => sum + r.amount, 0),
            totalFees: yearTransactions.reduce((sum, t) => sum + t.fees, 0)
        };
    }
}