Wie benutze ich Openzeppelin -Verträge?

Verständnis von Openzeppelin -Verträgen

Openzeppelin Contracts ist eine Bibliothek mit wiederverwendbaren und sicheren intelligenten Verträgen für Ethereum und andere Blockchain -Plattformen, die Solidität unterstützen. Diese Verträge werden bei der Entwicklung dezentraler Anwendungen (DAPPS) und Token -Systeme häufig verwendet. Die Bibliothek bietet Implementierungen von Standards wie ERC-20, ERC-721 und ERC-1155 sowie sicherheitsrelevante Versorgungsunternehmen wie Eigenkämpfer, Pentenable und Safemath . Entwickler verwenden Openzeppelin, um die Neuerfindung des Rades zu vermeiden und sicherzustellen, dass ihre intelligenten Verträge auf einem Fundament basieren, das ausgiebig geprüft und getestet wurde.

Bevor Sie in die Umsetzung eintauchen, ist es wichtig zu verstehen, wie die Verträge strukturiert sind und wie sie in Ihr Projekt importiert werden können. Die Verträge sind modular, dh Sie können nur das importieren, was Sie benötigen. Diese Modularität senkt die Gaskosten und verbessert die Wartbarkeit.

Einrichten Ihrer Entwicklungsumgebung

Um Openzeppelin -Verträge zu verwenden, müssen Sie zunächst eine Entwicklungsumgebung einrichten. Beginnen Sie mit der Installation von Node.js und NPM , die für die Verwaltung von JavaScript -Paketen unerlässlich sind. Einmal installiert, initialisieren Sie ein neues Projekt mit:

 npm init -y

Installieren Sie als nächstes TRUFFL , ein beliebtes Ethereum -Entwicklungsrahmen oder Hardhat , ein weiteres weit verbreitetes Tool:

 npm install -g truffle oder
 NPM Install-Save-dev Hardhat

Installieren Sie nach dem Einrichten des Frameworks Openzeppelin -Verträge über NPM:

 npm install @openzeppelin/contracts

Dieser Befehl installiert die OpenZeppelin -Bibliothek in das NODE_MODULES -Verzeichnis Ihres Projekts. Sie können jetzt einzelne Verträge oder Versorgungsfunktionen direkt in Ihre Soliditätsdateien importieren.

Importieren und Erweiterung von Openzeppelin -Verträgen

Nach der Installation können Sie mit dem Importieren von Openzeppelin -Verträgen in Ihre Soliditätsdateien beginnen. Wenn Sie beispielsweise einen ERC-20-Token bauen, können Sie den ERC20.Sol -Vertrag importieren:

 pragma solidity ^0.8.0; Importieren Sie '@openzeppelin/contracts/token/erc20/erc20.sol';
Vertrag myToken ist erc20 {
constructor(uint256 initialSupply) ERC20('MyToken', 'MTK') { _mint(msg.sender, initialSupply); }
 }

Dieser Code erstellt ein neues Token, das den ERC20 -Vertrag von Openzeppelin erweitert. Der Konstruktor übernimmt eine anfängliche Versorgung und weist ihn der Adresse des Bereitstellers über die Funktion _mint zu. Dies ist eine sichere und getestete Möglichkeit, Token zu erstellen, ohne den Code des Boilerplate zu schreiben.

Wenn Sie zusätzliche Funktionen benötigen, wie z. B. Pensabilität oder Eigentümerkontrollen , können Sie andere Verträge importieren und erweitern:

 import '@openzeppelin/contracts/access/Ownable.sol'; import '@openzeppelin/contracts/security/Pausable.sol'; Contract MyPauSablEToken ist ERC20, besitzbar, penstabel {
constructor(uint256 initialSupply) ERC20('MyToken', 'MTK') { _mint(msg.sender, initialSupply); } function pause() public onlyOwner { _pause(); } function unpause() public onlyOwner { _unpause(); }
 }

Dieser Ansatz ermöglicht es Ihnen, Ihre Verträge mit sicheren und kattgetesteten Komponenten zu komponieren.

Bereitstellung von Verträgen mit Openzeppelin

Sobald Ihr Vertrag geschrieben ist, ist der nächste Schritt die Bereitstellung. Wenn Sie TRUFFL verwenden, erstellen Sie eine Migrationsdatei im Migrations/ Verzeichnis:

 const MyPausableToken = artifacts.require('MyPausableToken'); module.exports = function (Deployer) { deployer.deploy (MyPauSablEToken, 1000000); };

In diesem Skript wird der Vertrag mit einer anfänglichen Versorgung von 1.000.000 Token bereitgestellt. Führen Sie die Migration mit:

 truffle migrate --network

Wenn Sie HardHat verwenden, erstellen Sie ein Bereitstellungsskript im Skript/ Ordner:

 async function main() { const MyPausableToken = await ethers.getContractFactory('MyPausableToken'); const myToken = await MyPausableToken.deploy(1000000); await myToken.deployed(); console.log ('MyPauSablEToken bereitgestellt zu:', myToken.address); }
main (). catch ((Fehler) => { console.Error (Fehler); process.exitcode = 1; });

Dann verwenden Sie mit:

 npx hardhat run scripts/deploy.js --network

Stellen Sie sicher, dass Sie über ein finanziertes Ethereum-Konto und die korrekte Netzwerkkonfiguration in Ihrer Datei truffle-config.js oder hardhat.config.js verfügen.

Interaktion mit implementierten Verträgen

Nach der Bereitstellung können Sie mit Ihrem Vertrag mit Tools wie Remix IDE , Metamask oder Ethers.js interagieren. Wenn Sie Ethers.js verwenden, verbinden Sie sich wie folgt mit Ihrem Vertrag:

 const { ethers } = require('ethers'); const provider = new Ethers.providers.jsonRpcProvider ('https://mainnet.infura.io/v3/your_infura_project_id'); const signer = new Ethers.wallet ('your_private_key', Anbieter); const contractAddress = 'your_contract_address'; const abi = fordert ('./ MyPausablEToken.json'). Abi;
const Contract = neue Ether.Contract (ContractAddress, ABI, Signator);
asynchrische Funktion pauseContract () { const tx = wait Contract.pause (); warten tx.wait (); console.log ('Vertrag pausiert'); }

Stellen Sie sicher, dass der Unterzeichner über ausreichende Mittel verfügt, um Gas zu bezahlen. Sie können auch mit dem Vertrag mit web3.js oder über Blockchain -Entdecker wie Ethercan interagieren.

Häufig gestellte Fragen

F: Kann ich Openzeppelin -Verträge direkt ändern? A: Während Sie die Verträge technisch ändern können, wird dies nicht empfohlen . Stattdessen sollten Sie die Verträge erweitern und bei Bedarf Funktionen außer Kraft setzen. Das Ändern der ursprünglichen Verträge kann Sicherheitslücken einführen oder die Kompatibilität mit zukünftigen Updates brechen.

F: Wie upgrade ich einen mit Openzeppelin erstellten Vertrag auf? A: Openzeppelin bietet die Upgrades -Plugins für Trüffel und Hardhat zur Bereitstellung und Verwaltung von aufgerüstbaren Verträgen . Mit diesen Tools können Sie Proxy -Verträge und ihre Logik aktualisieren, ohne den Status zu verlieren.

F: Sind Openzeppelin -Verträge mit Soliditätsversionen über 0,8.x kompatibel? A: Ja, Openzeppelin -Verträge werden aktiv aufrechterhalten und unterstützen Solidität von 0,8.x und höher . Überprüfen Sie jedoch immer die Versionskompatibilität in der offiziellen Dokumentation oder auf NPM vor dem Import.

F: Ist es sicher, Openzeppelin -Verträge in der Produktion zu verwenden? A: Ja, Openzeppelin -Verträge werden in Produktionsumgebungen häufig verwendet und von mehreren Dritten geprüft. Führen Sie jedoch immer Ihre eigenen Audits und Tests durch, bevor Sie sie für das Mainnet bereitstellen.