Blockchain Smart Contract

Ein Smart Contract ist ein selbstausführender Vertrag, dessen Bedingungen in Code geschrieben sind und der auf einer Blockchain ausgeführt wird. Der nachfolgende Beispielvertrag ist in Solidity, der Programmiersprache für Ethereum Smart Contracts, formuliert. Der Vertrag umfasst grundlegende Funktionen wie Zahlungen, Eigentumsübertragung und Statusmanagement.

---

Beispiel: Smart Contract für eine digitale Kauftransaktion

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

contract DigitalAssetSale {
address public seller;
address public buyer;
uint public price;
string public assetDetails;
bool public isCompleted;

// Events
event ContractInitialized(address indexed seller, uint price, string assetDetails);
event PurchaseCompleted(address indexed buyer, uint price);
event ContractCancelled(address indexed seller);

// Modifier
modifier onlySeller() {
require(msg.sender == seller, “Only the seller can perform this action.”);
_;
}

modifier onlyBuyer() {
require(msg.sender == buyer, “Only the buyer can perform this action.”);
_;
}

modifier notCompleted() {
require(!isCompleted, “Transaction already completed.”);
_;
}

// Constructor: Initialize the contract
constructor(uint _price, string memory _assetDetails) {
seller = msg.sender;
price = _price;
assetDetails = _assetDetails;
isCompleted = false;

emit ContractInitialized(seller, price, assetDetails);
}

// Function: Buyer sends payment
function purchase() external payable notCompleted {
require(msg.value == price, “Incorrect payment amount.”);
require(buyer == address(0), “Asset already purchased.”);

buyer = msg.sender;
payable(seller).transfer(msg.value);
isCompleted = true;

emit PurchaseCompleted(buyer, price);
}

// Function: Seller cancels the contract
function cancelContract() external onlySeller notCompleted {
isCompleted = true;

emit ContractCancelled(seller);
}

// Function: Get contract details
function getContractDetails() external view returns (address, address, uint, string memory, bool) {
return (seller, buyer, price, assetDetails, isCompleted);
}
}

---

Erläuterung der Funktionen

1. Contract Initialization:
   • Der Vertrag wird mit einem Preis und einer Beschreibung des digitalen Assets initialisiert.
   • Der Verkäufer ist derjenige, der den Vertrag erstellt.
2. Kaufabwicklung:
   • Der Käufer zahlt den festgelegten Betrag in Ether an den Verkäufer.
   • Nach erfolgreicher Zahlung wird der Status des Vertrags auf „abgeschlossen“ gesetzt.
3. Stornierung:
   • Der Verkäufer kann den Vertrag vor Abschluss der Transaktion stornieren.
4. Sicherheit und Transparenz:
   • Der Code stellt sicher, dass Zahlungen nur in der festgelegten Höhe erfolgen.
   • Der Status des Vertrags wird durch isCompleted kontrolliert.

---

Optionale Klauseln für Erweiterungen

1. Escrow-Funktion:
   • Hinzufügen eines Treuhandkontos, um das Geld sicher zu verwahren, bis beide Parteien ihre Verpflichtungen erfüllt haben.
2. address public escrow;
   modifier onlyEscrow() {
   require(msg.sender == escrow, “Only the escrow can perform this action.”);
   _;
   }
   
   function releaseFundsToSeller() external onlyEscrow notCompleted {
   payable(seller).transfer(price);
   isCompleted = true;
   }
3. Rückerstattungsklausel:
   • Möglichkeit, dem Käufer eine Rückerstattung zu gewähren, falls das Asset nicht geliefert wird.
4. function refundBuyer() external onlySeller notCompleted {
   payable(buyer).transfer(price);
   isCompleted = true;
   }
5. Bewertungssystem:
   • Käufer und Verkäufer können sich nach der Transaktion bewerten, um Reputation aufzubauen.
6. Vertragszeitraum:
   • Der Vertrag wird nach einer bestimmten Zeit automatisch storniert, falls keine Transaktion erfolgt.
7. uint public expirationTime;
   
   constructor(uint _price, string memory _assetDetails, uint _expirationPeriod) {
   seller = msg.sender;
   price = _price;
   assetDetails = _assetDetails;
   expirationTime = block.timestamp + _expirationPeriod;
   }
   
   function cancelIfExpired() external notCompleted {
   require(block.timestamp >= expirationTime, “Contract has not expired yet.”);
   isCompleted = true;
   }

---

Alternative Modelle für Smart Contracts

1. Tokenisierte Verträge:
   • Statt eines Einzelkaufs können Smart Contracts auf tokenisierte Vermögenswerte angewendet werden, wie NFTs (Non-Fungible Tokens) oder ERC-20-Token.
2. DAO-Verträge:
   • Verträge, die von einer dezentralen autonomen Organisation (DAO) verwaltet werden, um Gemeinschaftsentscheidungen und kollektive Investitionen zu ermöglichen.
3. Subscription-Modelle:
   • Smart Contracts für wiederkehrende Zahlungen, z. B. Abonnements.
4. function subscribe() external payable {
   require(msg.value >= subscriptionFee, “Insufficient payment.”);
   subscriptionEnd[msg.sender] = block.timestamp + subscriptionDuration;
   }
5. Crowdfunding-Verträge:
   • Verträge, die Gelder von mehreren Teilnehmern sammeln und freigeben, sobald ein Ziel erreicht ist.
6. Versicherungsverträge:
   • Automatische Auszahlung von Entschädigungen auf Basis externer Daten (z. B. Wetterdaten für Ernteausfallversicherung).

---

Vorteile von Blockchain-Smart-Contracts

1. Automatisierung:
   • Erfüllt automatisch die Vertragsbedingungen, sobald diese erfüllt sind.
2. Transparenz:
   • Alle Transaktionen sind öffentlich auf der Blockchain einsehbar.
3. Manipulationssicherheit:
   • Der Code und die Transaktionsdaten sind unveränderlich.
4. Effizienz:
   • Reduziert Verwaltungs- und Abwicklungskosten.

---

Nachteile und Risiken

1. Unveränderlichkeit:
   • Fehler im Code können nicht ohne weiteres korrigiert werden.
2. Rechtliche Unsicherheit:
   • In einigen Ländern gibt es noch keine klaren rechtlichen Rahmenbedingungen für Smart Contracts.
3. Technische Abhängigkeit:
   • Abhängig von der Blockchain-Plattform und deren Verfügbarkeit.

---

Dieser Smart Contract kann individuell erweitert und angepasst werden, um spezifische Anforderungen zu erfüllen, z. B. für E-Commerce, Vermögensverwaltung oder Supply-Chain-Management.