27.01.2025

 

Das hier ist nur ein Spaß-Contract.

Spaß-Token deshalb, weil es nur ein Test ist. Wird der Test zu 100 % erfolgreich, nehme ich die letzten Veränderungen vor und setze zwei richtige Smart Contracts auf: einen für das Unternehmen selbst und einen für einzelne Projekte im Unternehmen "ERLE Innovation Systems". Das werden wahrscheinlich Utility-Token und keine Meme-Token. Donald Trump hatte einen Meme-Blockchain-Coin aufgesetzt. Meme-Coins sind eigentlich nur Spaß-Coins. Sie können zwar auch an Wert gewinnen, sind aber grundlegend sinnlos. Dogecoin ist auch so ein Coin. Ich weiß aber auch noch nicht genau, ob in beiden Smart Contracts Utility-Token genutzt werden. Ich werde noch für jeden einzelnen Contract entscheiden zwischen Utility-, Hybrid- oder Security-Token. Das werde ich später entscheiden, nachdem ich beide Geschäftsmodelle genaustens analysiert habe. Anschließend entwickle ich für beide Token eine durchdachte Token-Ökonomie.

Mich interessiert halt, wie man einen Smart-Contrakt aufbaut.
Zu einem echten Contract gehört noch vieles andere.
Doch ich mache das hier, wie vieles andere so, daß ich das auch sofort in die Praxis integrieren kann.
Der Contract hier ist also nur ein Spaßcontract.
Der kann aber ganz schnell real werden und deshalb werde ich das weiter ergänzen und verbessern und perfektionieren. Das wird hier noch ein großes Dokument.

 

Hier sind die vorläufigen Smart-Contract-Angaben:

Smart-Contract: „ERLE Innovation Systems“

1. Projektübersicht „ERLE Innovation Systems“

Kategorie	Details
Token-Name	ERLE
Token-Symbol	ERLE                     LOGO kommt noch!
Dezimalstellen	2
Maximale Supply	12.000.000 Tokens
Anfängliche Emission	5.000 Tokens (1:1 an USDC Stablecoins gebunden)
Token-Typ	Utility-Token (ab Token 5.001)
Preismodell	Fester Preis (5 €) für die ersten 5.000 Tokens, dynamisch ab Token 5.001
Utility-Funktionen	Rabatte, Gewinnverteilung, Governance (später)
Stablecoin	USDC (integriert)
Unternehmensbewertung	Manuelle Aktualisierung, später Oracle
Nächste Schritte	Testnet-Deployment, Testen, Sicherheitsaudit

---

2. Smart Contract-Details

Kernfunktionen

1. Stablecoin-Integration:

   • Kauf der ersten 5.000 Tokens: Investoren zahlen in USDC und erhalten Tokens im Wert von 5 €.

   • Rücktausch: Investoren können ihre Tokens zurück in USDC tauschen.

2. Dynamische Preisberechnung:

   • Ab Token 5.001 wird der Preis basierend auf dem Unternehmenswert berechnet.

3. Utility-Funktionen:

   • Rabatte: Token-Inhaber erhalten Rabatte auf Produkte oder Dienstleistungen.

   • Gewinnverteilung: Token-Inhaber werden an Unternehmensgewinnen beteiligt.

4. Token-Ausgabe:

   • Der Contract-Owner kann neue Tokens in Tranchen ausgeben.

---

3. Smart Contract-Code

Hier ist der komplette Smart Contract-Code:

solidity

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract ERLE is ERC20, Ownable {
    uint256 public constant MAX_SUPPLY = 12_000_000 * 10**2; // 12 Mio. Tokens mit 2 Dezimalstellen
    uint256 public constant INITIAL_TOKENS = 5_000 * 10**2; // 5.000 Tokens mit 2 Dezimalstellen
    uint256 public companyValuation; // Unternehmenswert in Euro (manuell aktualisierbar)
    IERC20 public stablecoin; // USDC Stablecoin

    // Events
    event ValuationUpdated(uint256 newValuation);
    event DiscountGranted(address user);
    event ProfitDistributed(uint256 amount);

    constructor(address _stablecoin) ERC20("ERLE", "ERLE") {
        stablecoin = IERC20(_stablecoin);
    }

    // Funktion zum Kauf der ersten 5.000 Tokens mit USDC
    function buyInitialTokens(uint256 _amount) external {
        require(totalSupply() + _amount <= INITIAL_TOKENS, "Initiale Tokens ausverkauft");
        uint256 cost = _amount * 5 * 10**stablecoin.decimals(); // 5 € pro Token
        stablecoin.transferFrom(msg.sender, address(this), cost);
        _mint(msg.sender, _amount * 10**decimals());
    }

    // Funktion zum Rücktausch der ersten 5.000 Tokens in USDC
    function redeemInitialTokens(uint256 _amount) external {
        require(balanceOf(msg.sender) >= _amount, "Nicht genug Tokens");
        uint256 refund = _amount * 5 * 10**stablecoin.decimals(); // 5 € pro Token
        _burn(msg.sender, _amount * 10**decimals());
        stablecoin.transfer(msg.sender, refund);
    }

    // Funktion zur manuellen Aktualisierung des Unternehmenswerts (nur Owner)
    function updateValuation(uint256 _newValuation) external onlyOwner {
        companyValuation = _newValuation;
        emit ValuationUpdated(_newValuation);
    }

    // Berechnung des Token-Preises ab Token 5.001
    function calculateTokenPrice() public view returns (uint256) {
        require(totalSupply() > INITIAL_TOKENS, "Preisberechnung erst ab Token 5.001");
        uint256 circulatingSupply = totalSupply() - INITIAL_TOKENS;
        require(circulatingSupply > 0 && companyValuation > 0, "Ungültige Berechnung");
        return companyValuation / circulatingSupply;
    }

    // Ausgabe neuer Tokens in Tranchen (nur Owner)
    function mintTokens(uint256 _amount) external onlyOwner {
        require(totalSupply() + _amount <= MAX_SUPPLY, "Maximale Supply überschritten");
        _mint(msg.sender, _amount);
    }

    // Utility-Funktionen
    mapping(address => bool) public hasDiscount;

    // Rabatt gewähren
    function grantDiscount(address _user) external onlyOwner {
        require(balanceOf(_user) >= 1, "Keine Tokens im Besitz");
        hasDiscount[_user] = true;
        emit DiscountGranted(_user);
    }

    // Gewinnverteilung
    function distributeProfits(uint256 _amount) external onlyOwner {
        uint256 totalTokens = totalSupply();
        for (uint256 i = 0; i < holders.length; i++) {
            uint256 share = (balanceOf(holders[i]) * _amount) / totalTokens;
            _mint(holders[i], share);
        }
        emit ProfitDistributed(_amount);
    }
}

---

4. Offene Fragen und nächste Schritte

Offene Fragen

1. Stablecoin-Adresse:

   • Welche USDC-Adresse soll verwendet werden (Testnet oder Mainnet)?

2. Unternehmensbewertung:

   • Wie soll der initiale Unternehmenswert festgelegt werden?

3. Utility-Funktionen:

   • Sollen weitere Utility-Funktionen (z. B. Governance) implementiert werden?

Nächste Schritte

1. Testnet-Deployment:

   • Ich werde den Contract auf einem Ethereum-Testnet (z. B. Sepolia) deployen.

2. Testen:

   • Wir testen gemeinsam die Funktionen (Kauf, Rücktausch, Preisberechnung, Utility-Funktionen).

3. Sicherheitsaudit:

   • Nach deiner Freigabe führe ich einen manuellen Code-Review durch.

4. Regulatorische Prüfung:

   • Prüfung der Anforderungen für Utility-Tokens in deinen Zielmärkten.