So stellen Sie Solidity-Smart-Contracts mit ethers.js bereit

Wenn Sie DApps auf Ethereum entwickelt haben, haben Sie möglicherweise web3.js in Ihrem Front-End-JavaScript verwendet. Ethers.js ist eine leichtgewichtige Alternative zu web3.js.

Ethers.js hat viele Vorteile gegenüber Web3.js und eine meiner Lieblingsfunktionen ist die Status- und Schlüsselverwaltung, die Ethers.js bietet. Das Designszenario von Web3 sieht vor, dass DApp eine Verbindung zu einem lokalen Knoten herstellen soll, der für die Speicherung von Schlüsseln, das Signieren von Transaktionen und die Interaktion mit der Ethereum-Blockchain verantwortlich ist. Die Realität ist, dass dies nicht der Fall ist und die überwiegende Mehrheit der Benutzer keinen Geth-Knoten lokal ausführen wird. Metamask simuliert diese Knotenumgebung effektiv in Browseranwendungen, daher müssen die meisten Web3-Anwendungen Metamask verwenden, um Schlüssel zu speichern, Transaktionen zu signieren und Interaktionen mit Ethereum abzuschließen.

Ethers.js verfolgt einen anderen Designansatz, der Entwicklern mehr Flexibilität bietet. Ethers.js teilt einen „Knoten“ in zwei unterschiedliche Rollen auf:

Wallet: verantwortlich für die Schlüsselspeicherung und Transaktionssignatur. Anbieter: verantwortlich für die anonyme Verbindung, Statusprüfung und das Senden von Transaktionen im Ethereum-Netzwerk.

ethers.js ist eine sehr optimierte Ethereum-Betriebsbibliothek, die die folgenden vier Module enthält:
Ethers.Anbieter
Ethers.Vertrag
Ethers.utils
Ethers.wallets
Unter anderem ist Ethers.provider für die Verbindung mit Ethereum-Knoten, das Abfragen von Transaktionen, das Senden von Transaktionen, das Abrufen von Kontoständen usw. verantwortlich.
Ethers.contract ist für die Interaktion mit Smart Contracts verantwortlich, einschließlich der Bereitstellung von Verträgen, der Überwachung von Ereignissen in Verträgen, dem Abrufen von Informationen in Verträgen, dem Aufrufen von Funktionen in Verträgen usw.
Ethers.utils ist eine Tool-Bibliothek, die hauptsächlich zum Verarbeiten von Eingabe- und Ausgabedaten sowie zum Konvertieren von Datentypen und -formaten verwendet wird.
Ethers.wallets wird hauptsächlich zum Erstellen neuer Wallets, zum Verbinden oder Wechseln vorhandener Wallets und zum Signieren von Transaktionen verwendet.
Als Nächstes stellen wir vor, wie Smart Contracts mit Ethers.js bereitgestellt werden.

1. Erstellen Sie ein neues Projekt sendtokenone

mkdir sendtokenone
CD SendTokenOne
npm init -y
Trüffel-Init

2. Ändern Sie package.json und installieren Sie abhängige Pakete

a) Die geänderte Datei package.json sieht wie folgt aus:
//paket.json

{
  "Name": "sendtokenone",
  "version": "1.0.0",
  "Beschreibung": "ethers.js Bereitstellungsvertrag",
  "hauptsächlich": "",
  "Skripte": {
    "test": "echo \"Fehler: kein Test angegeben\" && exit 1"
  },
  "Schlüsselwörter": [],
  "Autor": "",
  "Lizenz": "ISC",
  "Abhängigkeiten": {
    "@openzeppelin/Verträge": "^3.4",
    "@truffle/hdwallet-provider": "^1.5.0",
    "große Zahl": "^1.1.0",
    "bignumber.js": "^8.1.1",
    "chai": "^4.2.0",
    "chai-wie-verspricht": "^7.1.1",
    "eslint": "^5.15.0",
    "ethereumjs-tx": "^1.3.7",
    "ethers": "^5.4.7",
    "Anfrage": "^2.88.2",
    "web3": "^1.3.0"
  },
  "devAbhängigkeiten": {
    "@babel/core": "^7.12.3",
    "@babel/preset-env": "^7.12.1"
  }
}

b) Abhängige Pakete installieren

npm installieren

3. Erstellen Sie einen neuen Smart Contract

3.1 Erstellen Sie einen EventValue.sol-Vertrag

Erstellen Sie im Verzeichnis sendtokenone/contacts einen EventValue.sol-Vertrag mit folgendem Inhalt:
// Ereigniswert.sol

// SPDX-Lizenz-Kennung: MIT
Pragma-Solidität ^0,6.0;

Vertrag EventValue {
    Ereignis ValueChanged (Adresse indizierter Autor, uint alterWert, uint neuerWert);
    uint _Wert;

    Konstruktor(uint Wert) public {
        uint tmp = _Wert;
        _Wert = Wert;
        emittiere ValueChanged(msg.sender, tmp, value);
    }
    Funktion getValue() Ansicht öffentlich gibt zurück (uint) {
        gibt _Wert zurück;
    }
    Funktion setValue(uint Wert) public {
        uint tmp = _Wert;
        _Wert = Wert;
        emittiere ValueChanged(msg.sender, tmp, value);
    }
}

3.2 Bereitstellungsskripte schreiben

Erstellen Sie einen neuen Ordner mit dem Namen migDeploy und erstellen Sie dann in diesem Ordner ein Bereitstellungsskript 1_deploy_event.js

mkdir migDeploy
cd migDeploy
berühren Sie 1_deploy_event.js

Der Inhalt von 1_deploy_event.js ist wie folgt:
// sendtokenone/migDeploy/1_deploy_event.js

const {ethers} = erfordern("ethers")
const fs = erfordern('fs')

let-Anbieter = neuer Ether.Provider.JsonRpcProvider('http://localhost:8545')

Funktion getHexString(prikeyPath) {
    const privKeyFile = fs.readFileSync(prikeyPath).toString().trim();
    const privKey = neuer Buffer.from(privKeyFile, 'hex');    
    return privaterSchlüssel
}

// var privKey = getHexString(".secret")
var privKey = '0x403d...23d5'
let wallet = neue Ether.Wallet(privKey,Anbieter)

var jsonStr = fs.readFileSync('./build/contracts/EventValue.json')
var jsonInfo = JSON.parse(jsonStr)
var jsonAbi = jsonInfo.abi
var bytecode = jsonInfo.bytecode

asynchrone Funktion deployContract(abi,bytecode,wallet) {
    let factory = neue Ether.ContractFactory(abi, Bytecode, Wallet)
    lass contractObj = warte auf factory.deploy(100)
    console.log('Vertragsadresse=',Vertragsobjekt.Adresse)
    console.log('txHash bereitstellen=',contractObj.deployTransaction.hash)

    warte auf contractObj.deployed()   
}

Bereitstellungsvertrag (jsonAbi, Bytecode, Wallet)

3.3 Vertragserstellung

a) Setzen Sie die IP von Ganache auf 127.0.0.1 und den Port auf 8545
b) Aktivieren Sie in truffle-config.js das Entwicklungsnetzwerksegment und geben Sie die Solc-Version wie folgt als 0.6.6 an:
// truffle-config.js

modul.exporte = {
  Netzwerke:

    Entwicklung:
     Host: "127.0.0.1", // Localhost (Standard: keiner)
     Port: 8545, // Standard-Ethereum-Port (Standard: keiner)
     network_id: "*", // Beliebiges Netzwerk (Standard: keines)
    },

  },

  // Legen Sie hier die Standard-Mocha-Optionen fest, verwenden Sie spezielle Reporter usw.
  Mokka:
    // Zeitüberschreitung: 100000
  },

  // Konfigurieren Sie Ihre Compiler
  Compiler:
    Lösung: {
      Version: „0.6.6“, // Genaue Version aus Solc-Bin abrufen (Standard: Truffle-Version)
      // Docker: true, // Verwenden Sie „0.5.1“, das Sie lokal mit Docker installiert haben (Standard: false)
      // Einstellungen: { // Siehe die Solidity-Dokumente für Ratschläge zur Optimierung und evmVersion
      // Optimierer: {
      // aktiviert: false,
      // Läufe: 200
      // },
      // evmVersion: "byzanz"
      // }
    }
  },

};

Öffnen Sie eine Black-Frame-Konsole und verwenden Sie Truffle, um den Vertrag zu kompilieren

CD SendTokenOne
Trüffelkonsole
kompilieren

3.4 Vertragserfüllung

Geben Sie im Black-Frame-Terminal den folgenden Befehl ein, um den Vertrag bereitzustellen

CD SendTokenOne
Knoten migDeploy\1_deploy_event.js

Die Wirkung ist wie folgt:

Die Vertragsadresse und der txHash können ausgedruckt werden, um anzuzeigen, dass die Vertragsbereitstellung erfolgreich war.

Dies ist das Ende dieses Artikels über die Verwendung von ethers.js zum Bereitstellen von Solidity-Smart-Contracts. Weitere Informationen zum Bereitstellen von Solidity-Smart-Contracts mit ethers.js finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!