pragma solidity ^0.8.

0;

// Contrat d'échange décentralisé

contract DecentralizedExchange {

// Structure pour stocker les informations sur les ordres d'achat et de vente

struct Order {

address payable trader;

uint tokenAmount;

uint etherAmount;

bytes32 pair;

bytes32 orderType;

bool active;

// Mapping pour stocker tous les ordres selon les paires et type de l'ordre (achat ou vente)

mapping(bytes32 => mapping(bytes32 => Order[])) public orders;

// Mapping pour stocker la réputation et notation des utilisateurs

mapping(address => uint) public reputation;

// Maps pour stocker les cours et les derniers trades effectués

mapping(bytes32 => uint) public priceFeed; // Pour chaque paire

mapping(bytes32 => Order) public lastTrade; // dernier trade réalisé pour une paire

// Variable pour stocker le réseau token utilisé pour les échanges

IERC20 public token;

 // Evénements

event NewOrder(bytes32 pair, bytes32 orderType, uint tokenAmount, uint etherAmount, address
trader);

event UpdateReputation(address user, uint reputation);

event OrderExecution(bytes32 pair, uint tokenAmount, uint etherAmount, address seller, address
buyer);

// Constructeur

constructor(address tokenAddress) {

// Initialisation du contrat ERC20

token = IERC20(tokenAddress);

// Fonction pour créer un ordre d'achat ou de vente

function createOrder(bytes32 pair, bytes32 orderType, uint tokenAmount, uint etherAmount) public {

require(tokenAmount > 0 && etherAmount > 0, "Invalid order");

require(token.balanceOf(msg.sender) >= tokenAmount, "Insufficient funds");

// Stocker l'ordre

Order memory order = Order(payable(msg.sender), tokenAmount, etherAmount, pair, orderType,

true);

orders[pair][orderType].push(order);

// Informer les clients du marché

emit NewOrder(pair, orderType, tokenAmount, etherAmount, msg.sender);

}
 // Fonction pour exécuter les ordres d'achat ou de vente en rapport avec les paires

function executeOrder(bytes32 pair, uint tokenAmount, uint etherAmount, bytes32 orderType,

address seller, address buyer) private {

// Exécution de l'ordre

uint totalEther = tokenAmount * priceFeed[pair];

require(totalEther == etherAmount, "Invalid trade");

require(token.transferFrom(seller, buyer, tokenAmount), "Transfer failed");

// Mise à jour du dernier trade

lastTrade[pair] = Order(payable(buyer), tokenAmount, etherAmount, pair, orderType, false);

// Mise à jour des prix

priceFeed[pair] = etherAmount / tokenAmount;

// Mise à jour de la réputation des utilisateurs

reputation[seller] += 1;

reputation[buyer] += 1;

// Informer les clients du marché

emit OrderExecution(pair, tokenAmount, etherAmount, seller, buyer);

emit UpdateReputation(seller, reputation[seller]);

emit UpdateReputation(buyer, reputation[buyer]);

// Fonction pour boucler les ordres similaires et exécuter les ordres disponibles

function closeOrders(bytes32 pair, bytes32 orderType) public {

 // Boucler à travers toutes les commandes et les exécuter s'il y a une correspondance avec les
ordres précédents

Order[] storage ordersToUpdate = orders[pair][orderType];

for (uint i = 0; i < ordersToUpdate.length; i++) {

// Vérification de la correspondance des ordres

if (ordersToUpdate[i].active) {

// Si c'est un ordre d'achat, il faut trouver une correspondance avec les ordres de vente
pertinents

if (orderType == "buy") {

Order[] storage sellOrders = orders[pair]["sell"];

for (uint j = 0; j < sellOrders.length; j++) {

if (sellOrders[j].active && sellOrders[j].etherAmount <= ordersToUpdate[i].etherAmount) {

executeOrder(pair, sellOrders[j].tokenAmount, sellOrders[j