Blockchain Integration¶

// Beispiel: Ethereum-basierte DID
const did = `did:ethr:0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb`;

// Eigenschaften:
// - Selbst-verwaltet (du kontrollierst private keys)
// - Persistent (bleibt für immer gültig)
// - Verifizierbar (kryptographisch nachweisbar)
// - Interoperabel (funktioniert überall)

class DIDAuth {
    async createDID() {
        // Generiere Ethereum Wallet
        const wallet = ethers.Wallet.createRandom();

        // DID = did:ethr:<address>
        const did = `did:ethr:${wallet.address}`;

        // Speichere privaten Schlüssel verschlüsselt
        const encrypted = await this.encryptKey(wallet.privateKey);
        localStorage.setItem('did_key', encrypted);

        return did;
    }

    async signSettings(settings) {
        const key = await this.decryptKey();
        const wallet = new ethers.Wallet(key);

        // Signiere Settings mit privatem Schlüssel
        const message = JSON.stringify(settings);
        const signature = await wallet.signMessage(message);

        return {
            did: `did:ethr:${wallet.address}`,
            settings,
            signature,
            timestamp: Date.now()
        };
    }

    async verifySettings(signedData) {
        const { did, settings, signature } = signedData;
        const address = did.split(':')[2];

        // Verifiziere Signatur
        const recovered = ethers.utils.verifyMessage(
            JSON.stringify(settings),
            signature
        );

        return recovered.toLowerCase() === address.toLowerCase();
    }
}

// Beispiel: Verifizierte "Remote Team Lead" Settings
const credential = {
    "@context": [
        "https://www.w3.org/2018/credentials/v1",
        "https://communicationfinder.org/credentials/v1"
    ],
    "type": ["VerifiableCredential", "CommunicationExpertCredential"],
    "issuer": "did:ethr:0x123...", // Vertrauenswürdige Organisation
    "issuanceDate": "2025-11-01T00:00:00Z",
    "credentialSubject": {
        "id": "did:ethr:0xabc...", // Settings-Ersteller
        "expertise": "Remote Team Management",
        "yearsExperience": 8,
        "teamSize": "50+",
        "settingsQuality": "verified"
    },
    "proof": {
        "type": "EcdsaSecp256k1Signature2019",
        "created": "2025-11-01T00:00:00Z",
        "proofPurpose": "assertionMethod",
        "verificationMethod": "did:ethr:0x123...#keys-1",
        "jws": "eyJhbGciOiJFUzI1NiIsImI2NCI6ZmFsc2UsImNyaXQiOlsiYjY0Il19..."
    }
};

class AuditLogger {
    constructor() {
        // Verbinde mit Ethereum (oder L2 wie Polygon)
        this.provider = new ethers.providers.JsonRpcProvider();
        this.contract = new ethers.Contract(
            AUDIT_CONTRACT_ADDRESS,
            AUDIT_ABI,
            this.provider
        );
    }

    async logDecision(decision) {
        // Anonymisierte Log-Daten
        const logEntry = {
            timestamp: Date.now(),
            settingsHash: this.hash(decision.settings), // Kein Inhalt!
            action: 'decision_made',
            channel: decision.channel,
            // KEINE persönlichen Daten!
        };

        // On-Chain speichern (unveränderbar)
        const tx = await this.contract.log(
            ethers.utils.id(JSON.stringify(logEntry))
        );

        await tx.wait();
        return tx.hash; // Transaction Hash als Beweis
    }

    async verifyAuditTrail(txHash) {
        const tx = await this.provider.getTransaction(txHash);
        const receipt = await this.provider.getTransactionReceipt(txHash);

        return {
            verified: receipt.status === 1,
            blockNumber: receipt.blockNumber,
            timestamp: (await this.provider.getBlock(receipt.blockNumber)).timestamp,
            immutable: true // In Blockchain = unveränderbar
        };
    }
}

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

contract CommunicationFinderAudit {
    event DecisionLogged(
        bytes32 indexed logHash,
        uint256 timestamp,
        address indexed logger
    );

    mapping(bytes32 => bool) public logs;

    function log(bytes32 logHash) external {
        require(!logs[logHash], "Already logged");

        logs[logHash] = true;
        emit DecisionLogged(logHash, block.timestamp, msg.sender);
    }

    function verify(bytes32 logHash) external view returns (bool) {
        return logs[logHash];
    }
}

const COMM_TOKEN = {
    name: "CommunicationFinder Token",
    symbol: "COMM",
    totalSupply: 100_000_000,

    distribution: {
        community: 40_000_000,      // 40% - Airdrops, Rewards
        development: 25_000_000,    // 25% - Core Team
        treasury: 20_000_000,       // 20% - DAO Treasury
        earlyBackers: 10_000_000,   // 10% - Angel Investors
        liquidity: 5_000_000        // 5% - DEX Liquidity
    },

    utilities: [
        "Governance Voting",        // 1 Token = 1 Vote
        "Premium Features",         // Unlock mit Token-Staking
        "IPFS Storage Credits",     // Bezahle Upload mit Token
        "Expert Verification",      // Verifiziere Settings (kostet Token)
    ]
};

class DAOGovernance {
    async createProposal(title, description, actions) {
        // Erstelle Proposal
        const proposal = {
            id: generateId(),
            title,
            description,
            actions, // Smart Contract Calls
            proposer: await this.getDID(),
            created: Date.now(),
            votingPeriod: 7 * 24 * 60 * 60 * 1000, // 7 Tage
            votes: { for: 0, against: 0, abstain: 0 }
        };

        // Kostenpflichtig (verhindert Spam)
        const cost = ethers.utils.parseEther("100"); // 100 COMM
        await this.token.transfer(DAO_ADDRESS, cost);

        // On-Chain speichern
        await this.governance.propose(proposal);

        return proposal.id;
    }

    async vote(proposalId, voteType) {
        // Voting Power = Token Balance
        const balance = await this.token.balanceOf(await this.getDID());

        // Vote on-chain
        await this.governance.vote(proposalId, voteType, balance);
    }

    async executeProposal(proposalId) {
        const proposal = await this.governance.getProposal(proposalId);

        // Quorum erreicht?
        const totalVotes = proposal.votes.for + proposal.votes.against;
        const quorum = (await this.token.totalSupply()) * 0.1; // 10%

        if (totalVotes < quorum) {
            throw new Error("Quorum not reached");
        }

        // Mehrheit für?
        if (proposal.votes.for > proposal.votes.against) {
            // Execute Actions (z.B. Feature-Flag aktivieren)
            for (const action of proposal.actions) {
                await this.execute(action);
            }
        }
    }
}

class SecureKeyStore {
    async storeKey(privateKey, password) {
        // PBKDF2 für Key Derivation
        const salt = crypto.getRandomValues(new Uint8Array(16));
        const iterations = 100000;

        const keyMaterial = await crypto.subtle.importKey(
            'raw',
            new TextEncoder().encode(password),
            'PBKDF2',
            false,
            ['deriveBits', 'deriveKey']
        );

        const derivedKey = await crypto.subtle.deriveKey(
            { name: 'PBKDF2', salt, iterations, hash: 'SHA-256' },
            keyMaterial,
            { name: 'AES-GCM', length: 256 },
            false,
            ['encrypt', 'decrypt']
        );

        // Verschlüssele Private Key
        const iv = crypto.getRandomValues(new Uint8Array(12));
        const encrypted = await crypto.subtle.encrypt(
            { name: 'AES-GCM', iv },
            derivedKey,
            new TextEncoder().encode(privateKey)
        );

        // Speichere lokal
        localStorage.setItem('encrypted_key', JSON.stringify({
            encrypted: Array.from(new Uint8Array(encrypted)),
            iv: Array.from(iv),
            salt: Array.from(salt)
        }));
    }
}

// Optimierter Audit Contract (Batch Logging)
contract OptimizedAudit {
    event BatchLogged(bytes32[] logHashes, uint256 timestamp);

    function batchLog(bytes32[] calldata logHashes) external {
        for (uint i = 0; i < logHashes.length; i++) {
            logs[logHashes[i]] = true;
        }
        emit BatchLogged(logHashes, block.timestamp);
    }
}

// Spart ~70% Gas bei 10+ Logs

// Einfache DID-Integration
const did = await createDID();
const signed = await signSettings(settings, did);

// Expert-Verifizierung
const credential = await requestVerification(settings);
const verified = await verifyCredential(credential);

// Enterprise Compliance
await auditLogger.log(decision);
const proof = await auditLogger.getProof(txHash);

// Community-Voting
await dao.createProposal("Add SMS Channel", ...);
await dao.vote(proposalId, "for");