Aufbau des Marktplatzvertrags

Wir werden nun unseren einfachen Item in einen komplexeren Marketplace umwandeln. Der Marketplace Vertrag verwaltet eine Liste der zum Verkauf stehenden Artikel, bietet Benutzern die Möglichkeit, neue Artikel zum Verkauf anzubieten und bietet Benutzern die Möglichkeit, Artikel zu kaufen.

Zu diesem Zweck werden wir unseren Vertrag um einige neue Funktionen erweitern:

1. Jeder Artikel verfügt nun über eine seller , die den Eigentümer des Artikels darstellt.

2. Wir werden eine neue Funktion listItemForSale einführen, die es Benutzern ermöglicht, neue Artikel zum Verkauf anzubieten.

3. Wir werden eine neue Funktion buyItem einführen, die es Benutzern ermöglicht, einen Artikel zu kaufen.

So sieht der Marketplace Vertrag aus:

Solidity 
 // SPDX-License-Identifier: MIT 
 Pragma Solidity ^0.8.6; 

 Contract Marketplace { 
 // Definiere eine neue Struktur für Artikel 
 struct Item {
        string name;
        uint price;
        address payable seller;
        bool forSale;
    }

    // Array zur Aufnahme aller Artikel 
 Item[] public items; 

 // Ereignis, das ausgegeben wird, wenn ein neuer Artikel erstellt wird 
 event NewItem(uint itemId, string itemName, uint itemPrice, address seller); 

 // Ereignis, das ausgegeben wird, wenn ein Artikel zum Verkauf angeboten wird 
 event ItemListed(uint itemId, string itemName, uint itemPrice, address seller); 

 // Ereignis, das ausgegeben wird, wenn ein Artikel gekauft wird 
 event ItemBought(uint itemId, string itemName, uint itemPrice, adressverkäufer, adresskäufer); 

 // Funktion, um einen neuen Artikel zu erstellen, ihn aber nicht sofort zum Verkauf anzubieten 
 function createItem(string memory _name, uint _price) public {
    items.push(Item(_name, _price, payable(msg.sender), false)); // We need to explicitly convert msg.sender to 'address payable'
    emit NewItem(items.length - 1, _name, _price, msg.sender);
    }


    // Funktion, um einen Artikel zum Verkauf anzubieten 
 function listItemForSale(uint _itemId) public {
        Item storage item = items[_itemId];
        require(msg.sender == item.seller, "Only the owner can list the item for sale");
        item.forSale = true;
        emit ItemListed(_itemId, item.name, item.price, item.seller);
    }

    // Funktion zum Kauf eines Artikels 
 function buyItem(uint _itemId) public payable {
        Item storage item = items[_itemId];
        require(msg.sender != item.seller, "Seller cannot buy their own item");
        require(item.forSale, "Item is not for sale");
        require(msg.value == item.price, "Incorrect price sent");
        item.seller.transfer(msg.value);
        item.forSale = false;
        emit ItemBought(_itemId, item.name, item.price, item.seller, msg.sender);
    }
}

In diesem Vertrag haben wir:

1. Eine Item Struktur, die jetzt eine seller und einen booleschen Wert für forSale enthält. Der seller ist der Eigentümer des Artikels und forSale gibt an, ob der Artikel derzeit zum Verkauf angeboten wird.

2. Eine createItem Funktion, die einen neuen Artikel erstellt und den msg.sender als Verkäufer zuweist. Der msg.sender ist eine globale Variable in Solidity, die die Adresse der Person (oder des Smart Contracts) darstellt, die als aktuelle Funktion aufgerufen wird. Der Artikel wird jedoch nicht sofort zum Verkauf angeboten.

3. Eine listItemForSale -Funktion, die es dem Verkäufer eines Artikels ermöglicht, ihn zum Verkauf anzubieten. Wir verwenden die require , um sicherzustellen, dass nur der Verkäufer den Artikel zum Verkauf anbieten kann.

4. Eine buyItem Funktion, die es jemandem ermöglicht, einen Artikel zu kaufen. Die Funktion prüft, ob der Artikel zum Verkauf steht, der Käufer nicht der Verkäufer ist und der korrekte Preis übermittelt wurde. Wenn diese Bedingungen erfüllt sind, sendet die Funktion das Geld an den Verkäufer und markiert den Artikel als nicht zum Verkauf.

Bereitstellung und Interaktion mit dem Marktplatzvertrag

Nachdem Sie den Marketplace Vertrag geschrieben haben, besteht der nächste Schritt darin, ihn zu kompilieren und bereitzustellen. Sie können das Solidity Compiler-Plugin in Remix verwenden, um den Vertrag zu kompilieren, genau wie wir es in Lektion 1 getan haben.

Um den Vertrag bereitzustellen, gehen Sie im rechten Bereich zum Plugin „Transaktionen bereitstellen und ausführen“ (das mit dem Würfelsymbol). Wählen Sie die entsprechende Umgebung (JavaScript VM für die Simulation), wählen Sie den Marketplace Vertrag aus der Dropdown-Liste „Vertrag“ aus und klicken Sie auf die Schaltfläche „Bereitstellen“.

Sobald der Vertrag bereitgestellt wurde, wird er im Abschnitt „Bereitgestellte Verträge“ angezeigt. Sie können es erweitern, um seine öffentlichen Zustandsvariablen und Funktionen anzuzeigen. Sie können Artikel erstellen, auflisten und kaufen, indem Sie diese Funktionen aufrufen.

Um einen Artikel zu erstellen, geben Sie einen Namen und einen Preis ein und klicken Sie auf die Schaltfläche createItem . Um einen Artikel zum Verkauf anzubieten, geben Sie die Artikel-ID ein und klicken Sie auf die Schaltfläche listItemForSale . Um einen Artikel zu kaufen, geben Sie die Artikel-ID ein, senden Sie die richtige Menge Ether und klicken Sie auf die Schaltfläche buyItem .

Glückwunsch! Sie wissen jetzt, wie Sie einen einfachen dezentralen Marktplatz auf der Ethereum-Blockchain erstellen.

In der nächsten Lektion werden wir unseren Marktplatz verbessern, indem wir Funktionen zum Entfernen von Artikeln aus dem Verkauf und zum Aktualisieren des Preises eines Artikels hinzufügen. Bleiben Sie dran!