Alors que nous entamons ce segment avancé de notre cours, prenons le temps de revoir le contrat d'actif synthétique que nous avons élaboré dans la première partie. Ce contrat sert de base à notre compréhension de la gestion et de la mise à niveau des contrats intelligents.

Récapitulation du contrat sur les actifs synthétiques

Vous trouverez ci-dessous le contrat d'actif synthétique que nous avons mis en œuvre précédemment. Ce contrat facilite la création, la gestion et l'interaction avec des actifs synthétiques sur la blockchain.

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

contract SyntheticAsset {
 uint256 public underlyingAssetPrice ;
 uint256 public collateral ;
 address public owner ;
 mapping(address => uint256) public syntheticBalance ;
 uint256 public totalSyntheticSupply ;

   constructor() {
        owner = msg.sender;
    }

    modificateur onlyOwner() {
        require(msg.sender == owner, "Not the contract owner");
        _;
    }

    function updatePrice(uint256 _price) public onlyOwner {
        underlyingAssetPrice = _price;
    }

    function depositCollateral(uint256 _amount) public {
        collateral += _amount;
    }

    function withdrawCollateral(uint256 _amount) public {
        require(collateral >= _amount, "Insufficient collateral");
        collateral -= _amount;
    }

    function getSyntheticAssetPrice() public view returns (uint256) {
        return underlyingAssetPrice;
    }

    function mintSyntheticAsset(uint256 _amount) public {
        require(collateral >= _amount, "Insufficient collateral");
        syntheticBalance[msg.sender] += _amount;
        totalSyntheticSupply += _amount;
        collateral -= _amount;
    }

    function redeemSyntheticAsset(uint256 _amount) public {
        require(syntheticBalance[msg.sender] >= _amount, "Insufficient synthetic balance");
        syntheticBalance[msg.sender] -= _amount;
        totalSyntheticSupply -= _amount;
        collateral += _amount;
    }
}

Maintenant que nous avons une meilleure compréhension de notre contrat de base, examinons les aspects de la gestion et de la mise à jour des contrats d'actifs synthétiques.

Propriété du contrat

• L'établissement de la propriété du contrat garantit que seules les entités autorisées peuvent modifier le contrat.

• La mise en œuvre d'un modificateur tel que onlyOwner pour restreindre l'accès à certaines fonctions est une pratique courante.

Modèles de mise à niveau

• Comprendre les différents modèles de mise à niveau tels que Proxy, Eternal Storage et DelegateCall.

• Explorer les avantages et les inconvénients de chaque modèle afin de choisir celui qui convient le mieux à votre contrat.

Contrats de procuration

• L'étude des contrats Proxy qui permettent de mettre à jour la logique d'un contrat tout en conservant les données intactes.

• Mise en œuvre d'un contrat proxy simple pour démontrer le processus de mise à niveau.

Solidity
contrat Proxy {
 adresse implémentation publique ;

 fonction upgradeImplementation(adresse _newImplementation) public onlyOwner {
        implementation = _newImplementation;
    }

    fallback() external payable {
 adresse impl = implémentation ;
 assembly {
 let ptr := mload(0x40)
 calldatacopy(ptr, 0, calldatasize())
 let result := delegatecall(gas(), impl, ptr, calldatasize(), 0, 0)
 let size := returndatasize()
 returndatacopy(ptr, 0, size)
 switch result
 case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }
    }
}

Versioning

• Mise en place d'un contrôle des versions pour assurer le suivi des mises à jour des contrats.

• Utiliser le versionnement sémantique pour indiquer le type de changements dans chaque mise à jour.

Mise à jour des tests

• Veiller à ce que les mises à jour n'introduisent pas de bogues ou n'altèrent pas les fonctionnalités prévues.

• Tester les mises à jour dans un environnement contrôlé avant de les déployer sur le réseau principal.
  Voici à quoi ressemblerait notre système après l'intégration d'un contrat de procuration pour les mises à niveau :

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

contract Proxy {
 address public implementation ;
 address public owner ;

 constructor() {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not the contract owner");
        _;
    }

    function upgradeImplementation(address _newImplementation) public onlyOwner {
        implementation = _newImplementation;
    }

    fallback() external payable {
 address impl = implementation ;
 assembly {
 let ptr := mload(0x40)
 calldatacopy(ptr, 0, calldatasize())
 let result := delegatecall(gas(), impl, ptr, calldatasize(), 0, 0)
 let size := returndatasize()
 returndatacopy(ptr, 0, size)
 switch result
 case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }
    }
}

contrat SyntheticAsset {
 uint256 public  underlyingAssetPrice ;
 uint256 public collateral ;
 address public owner ;
 mapping(address => uint256) public syntheticBalance ;
 uint256 public totalSyntheticSupply ;

   constructor() {
        owner = msg.sender;
    }

    modificateur onlyOwner() {
        require(msg.sender == owner, "Not the contract owner");
        _;
    }

    function updatePrice(uint256 _price) public onlyOwner {
        underlyingAssetPrice = _price;
    }

    function depositCollateral(uint256 _amount) public {
        collateral += _amount;
    }

    function withdrawCollateral(uint256 _amount) public {
        require(collateral >= _amount, "Insufficient collateral");
        collateral -= _amount;
    }

    function getSyntheticAssetPrice() public view returns (uint256) {
        return underlyingAssetPrice;
    }

    function mintSyntheticAsset(uint256 _amount) public {
        require(collateral >= _amount, "Insufficient collateral");
        syntheticBalance[msg.sender] += _amount;
        totalSyntheticSupply += _amount;
        collateral -= _amount;
    }

    function redeemSyntheticAsset(uint256 _amount) public {
        require(syntheticBalance[msg.sender] >= _amount, "Insufficient synthetic balance");
        syntheticBalance[msg.sender] -= _amount;
        totalSyntheticSupply -= _amount;
        collateral += _amount;
    }
}

Dans cette configuration, le contrat Proxy sert de passerelle pour le contrat SyntheticAsset, ce qui permet de mettre à jour l'implémentation (c'est-à-dire la logique) de SyntheticAsset sans perdre l'état (c'est-à-dire les données) du contrat. Cela est possible grâce à la fonction fallback de Proxy, qui délègue les appels à l'implémentation actuelle de SyntheticAsset, et à la fonction upgradeImplementation, qui permet au propriétaire de modifier l'adresse de l'implémentation pour qu'elle pointe vers une nouvelle version de SyntheticAsset.

Cette leçon vous permettra d'acquérir l'expertise nécessaire pour gérer et mettre à jour les contrats d'actifs synthétiques, en veillant à ce qu'ils restent adaptables à l'évolution des besoins tout en préservant l'intégrité et la sécurité du contrat. Ces connaissances fondamentales seront déterminantes pour approfondir les aspects plus avancés de la gestion des actifs synthétiques dans les leçons suivantes. Restez à l'écoute !