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. Der Smart Contracts hier ist also erst einmal nur um zu lernen wie man Contracte aufsetzt. Der wird dann im laufe der Entwicklung immer wieder getestet und optimiert. Zum Schluß kann der Contract dann aber echt werden. Wenn das so kommt werde ich zum Contract aber natürlich noch ein Whitebook schreiben.

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 vorerst 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	20.000 Tokens (1:1 an USDC Stablecoins gebunden)
Token-Typ	Utility-Token (ab Token 20.001)
Preismodell	Fester Preis (5 €) für die ersten 20.000 Tokens, dynamisch ab Token 20.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 20.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 20.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. hier der vorläufige Smart Contract-Code:

// 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";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

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

    // Events
    event ValuationUpdated(uint256 newValuation);
    event TokensPurchased(address indexed buyer, uint256 amount);
    event TokensRedeemed(address indexed seller, uint256 amount);
    event StablecoinAddressUpdated(address newStablecoin);

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

    // Pausemechanismus
    modifier whenNotPaused() {
        require(!isPaused, "Contract pausiert");
        _;
    }

    function pauseContract() external onlyOwner {
        isPaused = true;
    }

    function unpauseContract() external onlyOwner {
        isPaused = false;
    }

    // Funktion zum Kauf der ersten 20.000 Tokens mit USDC
    function buyInitialTokens(uint256 _amount) external whenNotPaused nonReentrant {
        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());
        emit TokensPurchased(msg.sender, _amount);
    }

    // Funktion zum Rücktausch der ersten 20.000 Tokens in USDC
    function redeemInitialTokens(uint256 _amount) external whenNotPaused nonReentrant {
        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);
        emit TokensRedeemed(msg.sender, _amount);
    }

    // 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 20.001
    function calculateTokenPrice() public view returns (uint256) {
        require(totalSupply() > INITIAL_TOKENS, "Preisberechnung erst ab Token 20.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);
    }

    // Konfigurierbare Parameter
    function setStablecoinAddress(address _stablecoin) external onlyOwner {
        stablecoin = IERC20(_stablecoin);
        emit StablecoinAddressUpdated(_stablecoin);
    }
}

---

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.