Waffel & Mars auf Moonbeam verwenden
Einleitung
Waffle ist eine Bibliothek zum Kompilieren und Testen von Smart Contracts, und Mars ist ein Deployment Manager. Zusammen können Waffle und Mars verwendet werden, um Ethereum Smart Contracts zu schreiben, zu kompilieren, zu testen und bereitzustellen. Da Moonbeam Ethereum-kompatibel ist, können Waffle und Mars verwendet werden, um Smart Contracts auf einem Moonbeam-Entwicklungsknoten oder dem Moonbase Alpha TestNet bereitzustellen.
Waffle verwendet minimale Abhängigkeiten, hat eine einfach zu erlernende und erweiterbare Syntax und bietet schnelle Ausführungszeiten beim Kompilieren und Testen von Smart Contracts. Darüber hinaus ist es TypeScript-kompatibel und verwendet Chai-Matcher, um Tests einfach zu lesen und zu schreiben.
Mars bietet ein einfaches, TypeScript-kompatibles Framework zum Erstellen erweiterter Bereitstellungsskripts und zum Synchronisieren mit Statusänderungen. Mars konzentriert sich auf Infrastructure-as-Code, sodass Entwickler angeben können, wie ihre Smart Contracts bereitgestellt werden sollen, und diese Spezifikationen dann verwenden, um Statusänderungen und Bereitstellungen automatisch zu verarbeiten.
In dieser Anleitung erstellen Sie ein TypeScript-Projekt, um einen Smart Contract mit Waffle zu schreiben, zu kompilieren und zu testen und ihn dann mit Mars auf dem Moonbase Alpha TestNet bereitzustellen.
Voraussetzungen prüfen
Wir müssen Node.js (wir verwenden v15.x) und den npm-Paketmanager installieren. Sie können es direkt von Node.js oder in Ihrem Terminal herunterladen:
Ubuntu
curl -sL https://deb.nodesource.com/setup_15.x | sudo -E bash -
sudo apt install -y nodejs
MacOS
# You can use homebrew (https://docs.brew.sh/Installation)
brew install node
# Or you can use nvm (https://github.com/nvm-sh/nvm)
nvm install node
Wir können überprüfen, ob alles richtig installiert ist, indem wir die Version für jedes Paket abfragen:
node -v
npm -v
Zum Zeitpunkt der Erstellung dieser Anleitung wurden die Versionen 15.12.0 bzw. 7.6.3 verwendet.
Waffle und Mars können mit einem lokal ausgeführten Moonbeam-Entwicklungsknoten verwendet werden, aber für die Zwecke dieser Anleitung werden wir Sie auf Moonbase Alpha bereitstellen. Daher benötigen Sie einen Account mit Tokens für die Entwicklung. Sie können wählen, ob Sie ein Account mit MetaMask oder ein Account mit PolkadotJS Apps erstellen möchten.
Nachdem Sie ein Account erstellt haben, müssen Sie den privaten Schlüssel exportieren, der in dieser Anleitung verwendet werden soll. Bevor Sie fortfahren, stellen Sie sicher, dass Ihr Account über Guthaben verfügt, und erhalten Sie bei Bedarf DEV-Tokens aus dem Faucet.
Erstellen Sie ein TypeScript-Projekt mit Waffle & Mars
Um zu beginnen, erstellen Sie ein TypeScript-Projekt und installieren und konfigurieren Sie einige Abhängigkeiten.
- Erstellen Sie das Projektverzeichnis und wechseln Sie dorthin:
mkdir waffle-mars && cd waffle-mars
2. Initialisieren Sie das Projekt. Dadurch wird eine package.json im Verzeichnis erstellt:
npm init -y
3. Installieren Sie die folgenden Abhängigkeiten:
npm install ethereum-waffle ethereum-mars ethers \
@openzeppelin/contracts typescript ts-node chai \
@types/chai mocha @types/mocha
- Waffle — zum Schreiben, Kompilieren und Testen von Smart Contracts
- Mars — für die Bereitstellung von Smart Contracts für Moonbeam
- Ethers — für die Interaktion mit der Ethereum-API von Moonbeam
- OpenZeppelin Contracts — der Contract, den Sie erstellen, verwendet die ERC20-Basisimplementierung von OpenZeppelin
- TypeScript — das Projekt wird ein TypeScript-Projekt sein
- TS Node — zum Ausführen des Bereitstellungsskripts, das Sie später in dieser Anleitung erstellen werden
- Chai — eine Assertionsbibliothek, die zusammen mit Waffle zum Schreiben von Tests verwendet wird
- @types/chai — enthält die Typdefinitionen für chai
- Mocha — ein Test-Framework zum Schreiben von Tests neben Waffle
- @types/mocha — enthält die Typdefinitionen für Mocha
- Erstellen Sie einen TypeScript Configuration File:
touch tsconfig.json
2. Fügen Sie eine grundlegende TypeScript-Konfiguration hinzu:
{
“compilerOptions”: {
“strict”: true,
“target”: “ES2019”,
“moduleResolution”: “node”,
“resolveJsonModule”: true,
“esModuleInterop”: true,
“module”: “CommonJS”,
“composite”: true,
“sourceMap”: true,
“declaration”: true,
“noEmit”: true
}
}
Jetzt sollten Sie über ein grundlegendes TypeScript-Projekt mit den erforderlichen Abhängigkeiten verfügen, um mit dem Bauen mit Waffle und Mars zu beginnen.
Add a Contract
Für diese Anleitung erstellen Sie einen ERC-20-Contract, der dem Contractersteller eine bestimmte Anzahl von Token herausgibt. Es basiert auf dem Open Zeppelin ERC-20-Template.
- Erstellen Sie ein Verzeichnis zum Speichern Ihrer Verträge und eine Datei für den Smart Contract:
mkdir contracts && cd contracts && touch MyToken.sol
2. Fügen Sie den folgenden Vertrag zu MyToken.sol hinzu:
pragma solidity ^0.8.0;
import “@openzeppelin/contracts/token/ERC20/ERC20.sol”;
contract MyToken is ERC20 {
constructor() ERC20(“MyToken”, “MYTOK”) {}
function initialize(uint initialSupply) public {
_mint(msg.sender, initialSupply);
}
}
In diesem Contract erstellen Sie einen ERC20-Token namens MyToken mit dem Symbol MYTOK, der es Ihnen als Contractersteller ermöglicht, beliebig viele MYTOKs zu minten.
Verwenden Sie Waffle zum Kompilieren und Testen
Kompilieren mit Waffle
Nachdem Sie nun einen Smart Contract geschrieben haben, besteht der nächste Schritt darin, Waffle zu verwenden, um ihn zu erstellen. Bevor Sie mit der Zusammenstellung Ihres Contracts beginnen, müssen Sie Waffle konfigurieren.
- Gehen Sie zurück zum Stammprojektverzeichnis und erstellen Sie eine Datei waffel.json, um Waffle zu konfigurieren:
cd .. && touch waffle.json
2. Stellen Sie waffel.json ein, um Compilerkonfigurationen, das Verzeichnis mit Ihren Verträgen und mehr anzugeben. In diesem Beispiel verwenden wir solcjs und die Solidity-Version, die Sie für den Vertrag verwendet haben, also 0.8.0:
{
“compilerType”: “solcjs”, // Specifies compiler to use
“compilerVersion”: “0.8.0”, // Specifies version of the compiler
“compilerOptions”: {
“optimizer”: { // Optional optimizer settings
“enabled”: true, // Enable optimizer
“runs”: 20000 // Optimize how many times you want to run the code
}
},
“sourceDirectory”: “./contracts”, // Path to directory containing smart contracts
“outputDirectory”: “./build”, // Path to directory where Waffle saves compiler output
“typechainEnabled”: true // Enable typed artifact generation
}
3. Fügen Sie ein Skript zum Ausführen von Waffle in der package.json hinzu:
“scripts”: {
“build”: “waffle”
},
Das ist alles, was Sie tun müssen, um Waffle zu konfigurieren. Jetzt können Sie den MyToken Contract mit dem build Skript kompilieren:
npm run build
Nach dem Kompilieren Ihrer Verträge speichert Waffle die JSON-Ausgabe im build-Verzeichnis. Der Contract in dieser Anleitung basiert auf dem ERC-20-Template von Open Zeppelin, sodass relevante ERC-20-JSON-Dateien auch im build-Verzeichnis erscheinen.
Test with Waffle
Bevor Sie Ihren Vertrag bereitstellen und ihn in die Wildnis schicken, sollten Sie ihn zuerst testen. Waffle bietet ein erweitertes Test-Framework und viele Tools, die Ihnen beim Testen helfen können.
Sie werden Tests für das Moonbase Alpha TestNet durchführen und benötigen die entsprechende RPC-URL, um eine Verbindung herzustellen: https://rpc.testnet.moonbeam.network. Da Sie Tests für das TestNet ausführen, kann es einige Minuten dauern, bis alle Tests ausgeführt wurden. Wenn Sie ein effizienteres Testerlebnis wünschen, können Sie einen Moonbeam-Entwicklungsknoten mit Instant Seal einrichten. Das Ausführen eines lokalen Moonbeam-Entwicklungsknotens mit der Instant Seal-Funktion ähnelt der schnellen und iterativen Erfahrung, die Sie mit Ganache erhalten würden.
- Erstellen Sie ein Verzeichnis für Ihre Tests und eine Datei zum Testen Ihres MyToken-Contracts:
mkdir test && cd test && touch MyToken.test.ts
2. Öffnen Sie die Datei MyToken.test.ts und richten Sie Ihre Testdatei ein, um das Solidity-Plugin von Waffle zu verwenden, und verwenden Sie den benutzerdefinierten JSON-RPC-Anbieter von Ethers, um eine Verbindung zu Moonbase Alpha herzustellen:
import { use, expect } from ‘chai’;
import { Provider } from ‘@ethersproject/providers’;
import { solidity } from ‘ethereum-waffle’;
import { ethers, Wallet } from ‘ethers’;
import { MyToken, MyTokenFactory } from ‘../build/types’;
// Tell Chai to use Waffle’s Solidity plugin
use(solidity);
describe (‘MyToken’, () => {
// Use custom provider to connect to Moonbase Alpha
let provider: Provider = new ethers.providers.JsonRpcProvider(‘https://rpc.testnet.moonbeam.network');
let wallet: Wallet;
let walletTo: Wallet;
let token: MyToken;
beforeEach(async () => {
// Logic for setting up the wallet and deploying MyToken will go here
});
// Tests will go here
})
3. Bevor jeder Test ausgeführt wird, sollten Sie Wallets erstellen und mit dem Anbieter verbinden, die Wallets verwenden, um eine Instanz des MyToken-Vertrags bereitzustellen, und dann einmal die initialize Funktion mit ausführen um 10 Tokens zu erhalten.
beforeEach(async () => {
const PRIVATE_KEY = ‘<insert-your-private-key-here>’
// Create a wallet instance using your private key & connect it to the provider
wallet = new Wallet(PRIVATE_KEY).connect(provider);
// Create a random account to transfer tokens to & connect it to the provider
walletTo = Wallet.createRandom().connect(provider);
// Use your wallet to deploy the MyToken contract
token = await new MyTokenFactory(wallet).deploy();
// Mint 10 tokens to the contract owner, which is you
let contractTransaction = await token.initialize(10);
// Wait until the transaction is confirmed before running tests
await contractTransaction.wait();
});
4. Jetzt können Sie Ihren ersten Test erstellen. Der erste Test überprüft Ihren Anzahl an Tokens, um sicherzustellen, dass Sie die 10 Tokens erhalten haben. Um jedoch gute Testpraktiken zu befolgen, schreiben Sie zuerst einen fehlgeschlagenen Test:
it(‘Mints the correct initial balance’, async () => {
expect(await token.balanceOf(wallet.address)).to.equal(1); // This should fail
});
5.Bevor Sie Ihren ersten Test ausführen können, müssen Sie zur Root-Directory zurückkehren und eine .mocharc.json Mocha-Konfigurationsdatei hinzufügen:
cd .. && touch .mocharc.json
6. Now edit the .mocharc.json file to configure Mocha:
{
“require”: “ts-node/register/transpile-only”, // Use ts-node to transpile the code for tests
“timeout”: 600000, // Set timeout to 10 minutes
“extension”: “test.ts” // Specify extension for test files
}
7. Sie müssen auch ein Skript in der package.json hinzufügen, um Ihre Tests auszuführen:
“scripts”: {
“build”: “waffle”,
“test”: “mocha”,
},
8. Sie sind bereit, die Tests auszuführen. Verwenden Sie einfach das soeben erstellte Testskript und führen Sie es aus:
npm run test
Bitte beachten Sie, dass die Verarbeitung einige Minuten dauern kann, da die Tests für Moonbase Alpha ausgeführt werden. Wenn jedoch alles wie erwartet funktioniert hat, sollte ein Test fehlschlagen.
- Als Nächstes können Sie zurückgehen und den Test bearbeiten, um die 10 Tokens zu überprüfen:
it(‘Mints the correct initial balance’, async () => {
expect(await token.balanceOf(wallet.address)).to.equal(10); // This should pass
});
2. Wenn Sie die Tests erneut ausführen, sollten Sie jetzt einen erfolgreichen Test sehen:
npm run test
3. Sie haben die Fähigkeit getestet, Tokens zu minten, als nächstes testen Sie die Fähigkeit, die geminteten Tokens zu versenden. Wenn Sie zunächst noch einmal einen nicht bestandenen Test schreiben möchten, ist dies zulässig, der Abschlusstest sollte jedoch so aussehen:
it(‘Should transfer the correct amount of tokens to the destination account’, async () => {
// Send the destination wallet 7 tokens
await (await token.transfer(walletTo.address, 7)).wait();
// Expect the destination wallet to have received the 7 tokens
expect(await token.balanceOf(walletTo.address)).to.equal(7);
});
Glückwunsch, Sie sollten jetzt zwei erfolgreiche Tests haben! Insgesamt sollte Ihre Testdatei so aussehen:
import { use, expect } from ‘chai’;
import { Provider } from ‘@ethersproject/providers’;
import { solidity } from ‘ethereum-waffle’;
import { ethers, Wallet } from ‘ethers’;
import { MyToken, MyTokenFactory } from ‘../build/types’;
use(solidity);
describe (‘MyToken’, () => {
let provider: Provider = new ethers.providers.JsonRpcProvider(‘https://rpc.testnet.moonbeam.network');
let wallet: Wallet;
let walletTo: Wallet;
let token: MyToken;
beforeEach(async () => {
const PRIVATE_KEY = ‘<insert-your-private-key-here>’
wallet = new Wallet(PRIVATE_KEY).connect(provider);
walletTo = Wallet.createRandom().connect(provider);
token = await new MyTokenFactory(wallet).deploy();
let contractTransaction = await token.initialize(10);
await contractTransaction.wait();
});
it(‘Mints the correct initial balance’, async () => {
expect(await token.balanceOf(wallet.address)).to.equal(10);
});
it(‘Should transfer the correct amount of tokens to the destination account’, async () => {
await (await token.transfer(walletTo.address, 7)).wait();
expect(await token.balanceOf(walletTo.address)).to.equal(7);
});
})
Wenn Sie selbst weitere Tests ausführen möchten, können Sie Überweisungen von Accounts ohne Tokens oder Überweisungen von Accounts ohne ausreichende Tokens testen.
Mars verwenden, um mit Mondbasis Alpha zu arbeiten
Nachdem Sie Ihre Verträge zusammengestellt haben, müssen Sie vor der Bereitstellung die Vertragsartefakte für den Mars generieren. Mars verwendet die Vertragsartefakte für Typprüfungen in Bereitstellungen. Dann müssen Sie ein Bereitstellungsskript erstellen und den MyToken-SmartContract bereitstellen.
Denken Sie daran, dass Sie eine Bereitstellung auf Moonbase Alpha durchführen und die TestNet-RPC-URL verwenden müssen: https://rpc.testnet.moonbeam.network.
Die Bereitstellung wird in drei Abschnitte unterteilt: Artefakte generieren, Bereitstellungsskript Erstellung und die Bereitstellung mit Mars.
Artefakte generieren
Für Mars müssen Artefakte generiert werden, damit Typprüfungen in Bereitstellungsskripten aktiviert werden.
- Aktualisieren Sie das vorhandene Skript, um Waffle in der package.json auszuführen, um Mars einzuschließen:
“scripts”: {
“build”: “waffle && mars”,
“test”: “mocha”,
},
2. Generieren Sie die Artefakte und erstellen Sie die für Bereitstellungen erforderliche Datei artifacts.ts:
npm run build
Wenn Sie das build-Verzeichnis öffnen, sollten Sie nun eine artifacts.ts-Datei sehen, die die für Bereitstellungen benötigten Artefaktdaten enthält. Um mit dem Bereitstellungsprozess fortzufahren, müssen Sie ein Bereitstellungsskript schreiben. Das Bereitstellungsskript wird verwendet, um Mars mitzuteilen, welcher Vertrag bereitgestellt werden soll, in welchem Netzwerk und welches Account verwendet werden soll, um die Bereitstellung auszulösen.
Bereitstellungsskript Erstellung
Jetzt müssen Sie die Bereitstellung für den MyToken-Vertrag im Moonbase Alpha TestNet konfigurieren.
In diesem Schritt erstellen Sie das Bereitstellungsskript, das definiert, wie der Contract bereitgestellt werden soll. Mars bietet eine deploy Funktion, an die Sie Sachen wie den privaten Schlüssel des Kontos zum Bereitstellen des Vertrags, das Netzwerk für die Bereitstellung und mehr übertragen können. Innerhalb der deploy Funktion werden die bereitzustellenden Verträge definiert. Mars verfügt über eine contract Funktion, die den name, das artifact und constructorArgs akzeptiert. Diese Funktion wird verwendet, um den MyToken-Contract mit 10 MYTOKs bereitzustellen.
- Erstellen Sie ein src-Verzeichnis, das Ihre Bereitstellungsskripts enthält, und erstellen Sie das Skript zum Bereitstellen des MyToken-Contracts:
mkdir src && cd src && touch deploy.ts
2. Verwenden Sie in deploy.ts, die deploy Funktion von Mars, um ein Skript für die Bereitstellung auf Moonbase Alpha mit dem privaten Schlüssel Ihres Accounts zu erstellen:
import { deploy } from ‘ethereum-mars’;
const privateKey = “<insert-your-private-key-here>”;
deploy({network: ‘https://rpc.testnet.moonbeam.network', privateKey},(deployer) => {
// Deployment logic will go here
});
3. Richten Sie die deploy Funktion ein, um den in den vorherigen Schritten erstellten MyToken-Vertrag bereitzustellen:
import { deploy, contract } from ‘ethereum-mars’;
import { MyToken } from ‘../build/artifacts’;
const privateKey = “<insert-your-private-key-here>”;
deploy({network: ‘https://rpc.testnet.moonbeam.network', privateKey}, () => {
contract(‘myToken’, MyToken, [10]);
});
4. Fügen Sie dem scripts-Objekt in der package.json ein Bereitstellungsskript hinzu:
“scripts”: {
“build”: “waffle && mars”,
“test”: “mocha”,
“deploy”: “ts-node src/deploy.ts”
},
Bisher sollten Sie in deploy.ts ein Bereitstellungsskript erstellt haben, das den MyToken-Vertrag für Moonbase Alpha bereitstellt, und die Möglichkeit hinzugefügt haben, das Skript einfach aufzurufen und den Contract bereitzustellen.
Bereitstellen mit Mars
Sie haben die Bereitstellung konfiguriert, jetzt ist es an der Zeit, tatsächlich auf Moonbase Alpha bereitzustellen.
- Stellen Sie den Vertrag mit dem soeben erstellten Skript bereit:
npm run deploy
2. In Ihrem Terminal fordert Mars Sie auf, die ENTER zu drücken, um Ihre Transaktion zu senden:
Wenn dies erfolgreich ist, sollten Sie Details zu Ihrer Transaktion sehen, einschließlich des Hashs, des Blocks, in dem sie enthalten war, und ihrer Adresse.
Glückwünsche! Du hast mit Waffel und Mars einen Vertrag für Moonbase Alpha bereitgestellt!
Beispielprojekt
Wenn Sie ein fertiges Beispiel eines Waffle and Mars-Projekts auf Moonbeam sehen möchten, schauen Sie sich das Moonbeam-Waffle-Mars-Beispiel an, das vom Team von Waffle and Mars, EthWorks, erstellt wurde.
Original article: https://docs.moonbeam.network/integrations/waffle-mars/
