Développer un contrat intelligent simple

1. Construction de l'environnement

Créer un framework Truffle
Introduction: Il s'agit d'un framework de développement Ethereum populaire avec compilation, connexion, déploiement et autres fonctions intelligentes de contrat intégrées

Le framework Truffle repose sur Node et doit être installé à l'aide de npm. Tout d'abord, vous devez installer node. Npm l'installera en même temps. Téléchargez-le sur le site officiel: Nodejs saisit
la commande pour afficher la version actuelle

nœud -v

Ensuite, vous pouvez utiliser npm pour installer le framework Truffle, utiliser npm pour installer le framework Truffle, installer la commande:

np installer -g truffe

Vérifiez l'installation de Truffle:

truffe --version

ganache

Ici, nous devons également utiliser Ganache, car le déploiement et le test de contrats intelligents sur Ethereum coûtent de l'éther, qui est du gaz. Et Ganache peut créer un réseau blockchain localement pour tester notre programme sans consommer de vrai gaz.
Chemin de téléchargement de Gannache: Ganache
Comment fonctionne Ganache: Créez un réseau de blockchain virtuel Ganache pour nous, attribuez-nous 10 comptes externes (nœuds) et chaque compte a 100 faux éthers.
Introduction à l'interface Ganache:

COMPTES: Interface de compte, montrant tous les comptes et leurs soldes générés automatiquement.
BLOCKS: interface de bloc, qui montre chaque bloc extrait sur le réseau blockchain local, ainsi que son coût de gaz et les transactions incluses.
TRANSACTIONS: page de transaction, qui répertorie toutes les transactions qui ont eu lieu sur la
blockchain locale . CONTRATS: page de contrat
ÉVÉNEMENTS: page d'événement
JOURNAUX: page de journal

La barre de recherche dans le coin supérieur droit peut rechercher des blocs ou des transactions sur le réseau blockchain local.
Interface de configuration:

SERVER: page de configuration du serveur, gérant des informations détaillées sur la connexion réseau, telles que l'ID du réseau, le port, le nom d'hôte et l'état d'exploration automatique.
COMPTES ET CLÉS: Compte et page clé, configurés pour générer automatiquement les comptes et leurs soldes. Page de lien
CHAIN , vous pouvez définir la limite de gaz et le prix du gaz.
Paramètres avancés Paramètres des options de journal, tels que la possibilité d'enregistrer des fichiers journaux et de configurer une sortie détaillée.

Code de solidité Il est
recommandé d'utiliser vs code pour écrire et installer le plug-in de solidité.

2. Étapes de développement

Initialisez le projet:

Créez d'abord le répertoire du projet, puis entrez dans ce répertoire
Initialisez ce projet avec truffle init

Une fois l'initialisation réussie, nous pouvons cliquer sur le fichier mydapp, et nous pouvons voir les fichiers suivants:
Une fois mydapp initialisé
Répertoire des contrats: comme son nom l'indique, il s'agit d'un répertoire de contrats intelligents. Il contient maintenant un fichier Migrations.sol, dont la fonction est de migrer / déployer / mettre à niveau les contrats intelligents.
Répertoire des migrations : les fichiers de migration, les scripts js à l'intérieur sont tous pour nous aider à déployer le contrat dans la blockchain.
répertoire de test: répertoire de code de test.
Le fichier truffle-config.js peut configurer le réseau qu'il contient .
2. Ajoutez le fichier package.json, qui est le fichier de configuration utilisé par npm pour gérer le package. Le contenu:

{
  "name": "ethereum-demo",
  "version": "1.0.0",
  "description": "以太坊demo",
  "main": "truffle-config.js",
  "directories": {
    "test": "test"
  },
  "scripts": {
    "dev": "lite-server",
    "test": "echo \"Error: no test specified\" && sexit 1"
  },
  "author": "[email protected]",
  "license": "ISC",
  "devDependencies": {
    "@truffle/contract": "^4.0.33",
    "dotenv": "^8.1.0",
    "lite-server": "^2.5.4",
    "truffle-hdwallet-provider": "^1.0.17"
  }
}

Vue d'ensemble de package.json: Sous le répertoire racine de chaque projet, se trouve généralement un fichier package.json qui définit les différents modules requis par le projet et les informations de configuration du projet (telles que le nom, la version, la licence, etc.) , La commande Npm install, selon ce fichier de configuration, télécharge automatiquement les modules requis, c'est-à-dire l'environnement d'exécution et de développement requis par le projet.
Pour une explication détaillée de package.json, veuillez vous référer aux champs détaillés de packeage.json

Ajouter des fichiers source de contrat intelligent

Créez un nouveau fichier MyContract.sol dans le répertoire des contrats et donnez le code:

// 声明solidity版本
pragma solidity ^0.5.0;

// 声明智能合约MyContract，合约的所有代码都包含在花括号中。
contract MyContract {

    // 声明一个名为value的状态变量
    string value;

    // 合约构造函数，每当将合约部署到网络时都会调用它。
    // 此函数具有public函数修饰符，以确保它对公共接口可用。
    // 在这个函数中，我们将公共变量value的值设置为“myValue”。
    constructor() public {
        value = "myValue";
    }

    // 本函数读取值状态变量的值。可见性设置为public，以便外部帐户可以访问它。
    // 它还包含view修饰符并指定一个字符串返回值。
    function get() public view returns(string memory ) {
        return value;
    }

    // 本函数设置值状态变量的值。可见性设置为public，以便外部帐户可以访问它。
    function set(string memory _value) public {
        value = _value;
    }
}

La fonction de ce contrat intelligent est d'obtenir des valeurs et de définir des valeurs. Ce code est écrit en solidité. Pour les tutoriels de base sur solidité, veuillez vous référer à mon article solidité. Il n'y a pas de lien ici, il y en a sur la page d'accueil.

Utilisez la commande truffle compile pour compiler le projet:

Une fois la compilation terminée, nous pouvons ouvrir à nouveau le répertoire racine du projet, et nous pouvons constater qu'il existe un répertoire de construction supplémentaire.

Ce fichier est le fichier ABI du contrat intelligent, qui signifie "interface binaire abstraite". Il a les deux fonctions suivantes:
En tant que fichier exécutable pouvant être exécuté sur la machine virtuelle Ethereum (EVM)
Contient des représentations JSON des fonctions de contrat intelligent afin que les clients externes puissent appeler ces fonctions

Mettre à jour le fichier de configuration
Modifier la configuration du réseau pour se connecter au réseau blockchain local (Ganache)

Ouvrez le fichier truffle-config.js situé dans le répertoire racine et modifiez le contenu comme suit:

module.exports = {
  networks: {
    development: {
      host: "127.0.0.1", // ip地址
      port: 8545, // 端口
      network_id: "*" // Match any network id
    }
  },
  solc: {
    optimizer: {
      enabled: true,
      runs: 200
    }
  }
}

l'adresse IP, le numéro de port, etc. doivent correspondre à Ganache
Insérez la description de l'image ici

Créer un script de migration

Créez le script 2_deploy_contracts dans le répertoire des migrations. Ce script indique à Truffle comment déployer des contrats intelligents. Il doit être numéroté. La fonction est d'indiquer à Truffle leur ordre d'exécution.

var MyContract = artifacts.require("./MyContract.sol");
// 用require将合约赋值给一个MyContract变量
module.exports = function(deployer) {
  deployer.deploy(MyContract); // 部署该合约
};

Exécuter la commande de migration truffle migrate pour se

déployer avec succès et consommer de l'Ether
Utilisez la console truffe (console) pour accéder au contrat intelligent. La

console démarre correctement

MyContract.deployed (). Then ((instance) => {app = instance})

courir
Entrez la commande et exécutez avec succès

Ensuite, essayez d'appeler la méthode get, entrez app.get () et l'
Appel réussi
appel est réussi, en effet la valeur de myValue est affichée.

Essayons à nouveau la méthode set pour voir si cette valeur peut être modifiée. Entrez d'abord app.set ('new Value'), puis entrez app.get (), le résultat montre: la
Modifié avec succès
modification est réussie.

Trois, résumé

Bien qu'il ne s'agisse que d'un simple contrat intelligent pour obtenir la valeur modifiée, il s'agit également d'une étape simple pour développer un contrat intelligent. Grâce à cette étape, en modifiant le code du contrat, nous pouvons également écrire des contrats intelligents plus complexes. Ce n'est qu'une étape.