Während wir mit diesem fortgeschrittenen Abschnitt unseres Kurses beginnen, nehmen wir uns einen Moment Zeit, um den synthetischen Vermögenswertvertrag, den wir im ersten Teil entwickelt haben, noch einmal zu betrachten. Dieser Vertrag dient als Grundlage, auf der wir unser Verständnis für die Verwaltung und Aktualisierung intelligenter Verträge aufbauen werden.

Zusammenfassung des Vertrags über synthetische Vermögenswerte

Nachfolgend finden Sie den synthetischen Vermögenswertvertrag, den wir zuvor implementiert haben. Dieser Vertrag erleichtert die Erstellung, Verwaltung und Interaktion mit synthetischen Vermögenswerten auf der Blockchain.

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

 Vertrag SyntheticAsset { 
 uint256 public basedAssetPrice; 
 uint256 öffentliche Sicherheiten; 
 Adresse öffentlicher Eigentümer; 
 Mapping(address => uint256) public SyntheticBalance; 
 uint256 public totalSyntheticSupply; 

 Konstruktor() {
        owner = msg.sender;
    }

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

    Funktion updatePrice(uint256 _price) öffentlich onlyOwner {
        underlyingAssetPrice = _price;
    }

    Funktion DepositCollateral(uint256 _amount) öffentlich {
        collateral += _amount;
    }

    Funktion unlockCollateral(uint256 _amount) öffentlich {
        require(collateral >= _amount, "Insufficient collateral");
        collateral -= _amount;
    }

    Funktion getSyntheticAssetPrice() öffentliche Ansicht gibt (uint256) {
        return underlyingAssetPrice;
    }

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

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

Lassen Sie uns nun mit einem aufgefrischten Verständnis unseres Grundvertrags näher auf die Aspekte der Verwaltung und Aktualisierung von Verträgen über synthetische Vermögenswerte eingehen.

Vertragseigentum

• Durch die Festlegung des Vertragseigentums wird sichergestellt, dass nur autorisierte Stellen den Vertrag ändern können.

• Die Implementierung eines Modifikators wie onlyOwner um den Zugriff auf bestimmte Funktionen einzuschränken, ist eine gängige Praxis.

Upgrade-Muster

• Verstehen verschiedener Upgrade-Muster wie Proxy, Eternal Storage und DelegateCall.

• Erkunden Sie die Vor- und Nachteile jedes Musters, um das für Ihren Vertrag am besten geeignete auszuwählen.

Proxy-Verträge

• Eintauchen in Proxy-Verträge, die es ermöglichen, die Logik eines Vertrags zu aktualisieren und gleichzeitig die Daten intakt zu halten.

• Implementierung eines einfachen Proxy-Vertrags zur Demonstration des Upgrade-Prozesses.

Solidität 
 Vertrag Proxy { 
 Adresse öffentliche Implementierung; 

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

    fallback() external payable { 
 Adresse impl = Implementierung; 
 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) }
        }
    }
}

Versionierung

• Implementierung einer Versionskontrolle, um Vertragsaktualisierungen im Auge zu behalten.

• Verwendung semantischer Versionierung, um die Art der Änderungen bei jedem Upgrade anzuzeigen.

Testen von Upgrades

• Sicherstellen, dass Upgrades keine Fehler verursachen oder die beabsichtigte Funktionalität verändern.

• Testen Sie Upgrades in einer kontrollierten Umgebung, bevor Sie sie im Mainnet bereitstellen.
  Nachfolgend sehen Sie, wie unser System nach der Einbindung eines Proxy-Vertrags für Upgrades aussehen würde:

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

 Vertrags-Proxy { 
 Adresse öffentliche Implementierung; 
 Adresse öffentlicher Eigentümer; 

 Konstruktor() {
        owner = msg.sender;
    }

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

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

    fallback() external payable { 
 Adresse impl = Implementierung; 
 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) }
        }
    }
}

SyntheticAsset { 
 uint256 public basedAssetPrice; 
 uint256 öffentliche Sicherheiten; 
 Adresse öffentlicher Eigentümer; 
 Mapping(address => uint256) public SyntheticBalance; 
 uint256 public totalSyntheticSupply; 

 Konstruktor() {
        owner = msg.sender;
    }

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

    Funktion updatePrice(uint256 _price) öffentlich onlyOwner {
        underlyingAssetPrice = _price;
    }

    Funktion DepositCollateral(uint256 _amount) öffentlich {
        collateral += _amount;
    }

    Funktion unlockCollateral(uint256 _amount) öffentlich {
        require(collateral >= _amount, "Insufficient collateral");
        collateral -= _amount;
    }

    Funktion getSyntheticAssetPrice() öffentliche Ansicht gibt (uint256) {
        return underlyingAssetPrice;
    }

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

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

In diesem Setup fungiert der Proxy Vertrag als Gateway für den SyntheticAsset Vertrag und ermöglicht so die Aktualisierung der Implementierung (d. h. der Logik) von SyntheticAsset , ohne dass der Status (d. h. die Daten) des Vertrags verloren geht. Dies wird durch die fallback Funktion in Proxy erreicht, die Aufrufe an die aktuelle Implementierung von SyntheticAsset delegiert, und die upgradeImplementation Funktion, die es dem Eigentümer ermöglicht, die Implementierungsadresse so zu ändern, dass sie auf eine neue Version von SyntheticAsset verweist.

In dieser Lektion erwerben Sie das Fachwissen, das Sie für die Verwaltung und Aktualisierung von Verträgen über synthetische Vermögenswerte benötigen, um sicherzustellen, dass sie an sich ändernde Anforderungen angepasst bleiben und gleichzeitig die Integrität und Sicherheit des Vertrags gewahrt bleiben. Dieses Grundwissen wird von entscheidender Bedeutung sein, wenn wir uns in den folgenden Lektionen eingehender mit fortgeschritteneren Aspekten des synthetischen Asset-Managements befassen. Bleiben Sie dran!