Address Best Practices & Wallet Hygiene

// Address Hygiene Audit and Management Tool
class AddressHygieneAuditor {
    constructor() {
        this.addressTypes = {
            legacy: {
                prefix: "1",
                privacyScore: 6,
                efficiency: "Low",
                recommendation: "Consider upgrading to SegWit"
            },
            segwit: {
                prefix: "3",
                privacyScore: 7,
                efficiency: "Medium",
                recommendation: "Good balance of privacy and compatibility"
            },
            bech32: {
                prefix: "bc1",
                privacyScore: 8,
                efficiency: "High",
                recommendation: "Optimal for privacy due to lower fees"
            },
            taproot: {
                prefix: "bc1p",
                privacyScore: 9,
                efficiency: "Highest",
                recommendation: "Best privacy and efficiency available"
            }
        };
    }
    
    auditAddressUsage(addressHistory) {
        const audit = {
            totalAddresses: addressHistory.length,
            reusedAddresses: [],
            privacyScore: 0,
            recommendations: [],
            addressTypeAnalysis: this.analyzeAddressTypes(addressHistory)
        };
        
        // Check for address reuse
        const addressCount = {};
        addressHistory.forEach(tx => {
            tx.addresses.forEach(address => {
                addressCount[address] = (addressCount[address] || 0) + 1;
                if (addressCount[address] > 1) {
                    audit.reusedAddresses.push(address);
                }
            });
        });
        
        // Calculate privacy score
        const uniqueAddresses = Object.keys(addressCount).length;
        const totalTransactions = addressHistory.length;
        audit.privacyScore = Math.round((uniqueAddresses / totalTransactions) * 100);
        
        // Generate recommendations
        audit.recommendations = this.generateRecommendations(audit, addressHistory);
        
        return audit;
    }
    
    analyzeAddressTypes(addressHistory) {
        const typeAnalysis = {};
        
        addressHistory.forEach(tx => {
            tx.addresses.forEach(address => {
                const type = this.getAddressType(address);
                typeAnalysis[type] = (typeAnalysis[type] || 0) + 1;
            });
        });
        
        return typeAnalysis;
    }
    
    getAddressType(address) {
        if (address.startsWith("bc1p")) return "taproot";
        if (address.startsWith("bc1")) return "bech32";
        if (address.startsWith("3")) return "segwit";
        if (address.startsWith("1")) return "legacy";
        return "unknown";
    }
    
    generateRecommendations(audit, addressHistory) {
        const recommendations = [];
        
        // Address reuse issues
        if (audit.reusedAddresses.length > 0) {
            recommendations.push({
                priority: "HIGH",
                issue: "Address Reuse Detected",
                description: `Found ${audit.reusedAddresses.length} reused addresses`,
                solution: "Stop using these addresses immediately and use fresh addresses for all future transactions"
            });
        }
        
        // Privacy score issues
        if (audit.privacyScore < 80) {
            recommendations.push({
                priority: "MEDIUM",
                issue: "Low Address Diversity",
                description: `Privacy score: ${audit.privacyScore}%`,
                solution: "Increase address generation frequency and avoid address reuse patterns"
            });
        }
        
        // Address type optimization
        const hasLegacy = audit.addressTypeAnalysis.legacy > 0;
        if (hasLegacy) {
            recommendations.push({
                priority: "LOW",
                issue: "Legacy Address Usage",
                description: "Using legacy P2PKH addresses",
                solution: "Consider upgrading to SegWit or Bech32 addresses for better privacy and lower fees"
            });
        }
        
        return recommendations;
    }
    
    generateAddressManagementPlan(currentUsage) {
        return {
            immediateActions: [
                "Audit all stored addresses in contacts and bookmarks",
                "Generate fresh addresses for any pending transactions",
                "Update any merchant or service addresses you frequently use",
                "Verify wallet is generating fresh addresses automatically"
            ],
            weeklyTasks: [
                "Check wallet for any address reuse warnings",
                "Review and update saved addresses",
                "Verify new address generation is working properly"
            ],
            monthlyTasks: [
                "Complete privacy audit of address usage",
                "Review wallet settings for optimal privacy",
                "Update any long-term address storage systems"
            ],
            tools: {
                recommended: ["Electrum", "Wasabi", "Blue Wallet", "Samourai"],
                features: ["HD wallet", "Fresh address generation", "Address gap monitoring", "Privacy scoring"]
            }
        };
    }
    
    checkWalletPrivacySettings() {
        return {
            checks: [
                {
                    setting: "Automatic address generation",
                    status: "Check",
                    importance: "HIGH",
                    description: "Wallet should automatically generate new addresses"
                },
                {
                    setting: "Address gap limit",
                    status: "Check",
                    importance: "MEDIUM",
                    description: "Should be set to 20 or higher for HD wallets"
                },
                {
                    setting: "Address type",
                    status: "Check",
                    importance: "MEDIUM",
                    description: "Use Bech32 or SegWit addresses for better privacy"
                },
                {
                    setting: "Transaction labeling",
                    status: "Check",
                    importance: "LOW",
                    description: "Avoid storing sensitive information in transaction labels"
                }
            ]
        };
    }
}

// Usage example
const auditor = new AddressHygieneAuditor();
const addressHistory = [
    { addresses: ["bc1qxyz123", "bc1qabc456"] },
    { addresses: ["bc1qxyz123", "bc1qdef789"] } // Address reuse example
];

const audit = auditor.auditAddressUsage(addressHistory);
const managementPlan = auditor.generateAddressManagementPlan();
console.log("Address Audit:", audit);
console.log("Management Plan:", managementPlan);