Comment implémenter EVM à l'aide de Golang

Avec le développement continu de la technologie blockchain, Ethereum, en tant que plateforme de contrats intelligents la plus représentative, dispose déjà d'un bon support et d'un vaste écosystème pour les développeurs. Cependant, comme l'architecture logicielle de la machine virtuelle Ethereum (EVM) est basée sur le développement du langage Solidity, de plus, afin d'améliorer les performances, l'EVM implémente un compilateur JIT (Just In Time) pour l'optimisation du code, tous qui se font d’une certaine manière, cela limite l’efficacité du développement de l’écosystème Ethereum.

Sur la base de ces problèmes, de nombreux développeurs tentent d'utiliser d'autres langages de programmation​​pour développer EVM dans l'espoir d'obtenir une exécution plus efficace du code des contrats intelligents. Golang est un langage de programmation développé par Google qui offre un moyen très pratique de réaliser de la programmation de bas niveau. Ci-dessous, nous explorerons comment utiliser Golang pour implémenter EVM.

Présentation de l'EVM

La machine virtuelle Ethereum (EVM) est une machine virtuelle basée sur une pile qui exécute les contrats intelligents Ethereum. EVM fournit un environnement d'exécution unifié sur l'ensemble du réseau Ethereum, garantissant que les contrats intelligents peuvent s'exécuter comme prévu sur différents nœuds. L'EVM définit un ensemble d'instructions qui changent d'état lors d'opérations spécifiques. Ces états incluent la mémoire, le stockage et la pile.

Implémentation d'EVM avec Golang

Pour utiliser Golang pour implémenter EVM, nous devons d'abord installer go-ethereum. go-ethereum est une implémentation Golang officielle d'Ethereum qui fournit des bibliothèques et des fonctionnalités très utiles. Il peut être utilisé comme nœud Ethereum pour créer des dApps Ethereum (applications décentralisées).

En supposant que nous avons installé les compilateurs go-ethereum et solidity, nous pouvons commencer à implémenter EVM en suivant les étapes suivantes :

Étape 1 : Définir le jeu d'instructions d'EVM

Dans Golang, nous pouvons utiliser des types d'énumération pour définir les EVM Ensemble d'instructions, par exemple :

type OpCode byte

const (
  STOP OpCode = iota
  ADD
  MUL
  SUB
  DIV
  SDIV
  MOD
  SMOD
  ADDMOD
  MULMOD
  EXP
  SIGNEXTEND
  ...
)

Ces instructions peuvent être trouvées dans le livre jaune d'Ethereum ou obtenues à partir du code source du package go-ethereum. Nous devons définir une méthode pour chaque instruction qui exécute la logique de l'instruction. Par exemple, pour l'instruction ADD, nous pouvons définir la méthode suivante :

func (evm *EVM) add() {
  x, y := evm.stack.Pop(), evm.stack.Pop()
  result := x.Add(y)
  evm.stack.Push(result)
}

Étape 2 : Analyser le bytecode Solidity

Lorsque nous écrivons un contrat intelligent en utilisant Solidity, le compilateur le compile sous forme de bytecode puis le déploie sur Ethereum. réseau. Dans notre Golang EVM, nous devons d'abord analyser le bytecode Solidity, puis le convertir en instructions EVM. Nous pouvons le faire en utilisant l'analyseur du package go-ethereum. Par exemple :

import (
  "github.com/ethereum/go-ethereum/common"
  "github.com/ethereum/go-ethereum/core/vm"
)

func (evm *EVM) execute(code []byte) {
  vm := vm.NewEVM(evm.context, evm.stateDB, evm.vmConfig)
  contract := vm.NewContract(&vm.ContractConfig{
    Code:      common.CopyBytes(code),
    GasLimit:  1000000,
    Value:     big.NewInt(0),
  })
  contract.SetCallCodeFn(evm.callCode)
  contract.SetStaticCallFn(evm.staticCall)
  contract.SetDelegateCallFn(evm.delegateCall)
  vm.Execute(evm.context, contract)
}

Le code ci-dessus analysera le bytecode Solidity dans un objet Contract, puis appellera la méthode Execute() de l'EVM pour exécuter le code.

Étape 3 : Implémenter la mémoire, le stockage et la pile

EVM a trois états : mémoire, stockage et pile. Dans Golang EVM, nous devons implémenter ces états. Nous pouvons utiliser la tranche de Golang comme mémoire, la carte comme stockage et la pile de Golang comme pile.

type EVM struct {
  context  *core.ExecutionContext
  stateDB  *state.StateDB
  vmConfig vm.Config

  memory []byte
  storage map[common.Hash] common.Hash
  stack *stack
}

Étape 4 : Implémenter la logique du jeu d'instructions

Après avoir défini le jeu d'instructions, nous devons implémenter la logique de chaque instruction. Chaque instruction change l'état de la pile. Par exemple, dans le cas de l'instruction ADD, elle extrait deux valeurs de la pile, les ajoute et enfin repousse le résultat sur la pile. Nous pouvons définir la méthode suivante pour implémenter la logique de l'instruction ADD :

func (evm *EVM) add() {
  x, y := evm.stack.Pop(), evm.stack.Pop()
  result := x.Add(y)
  evm.stack.Push(result)
}

Étape 5 : Implémenter diverses gestions d'exceptions

Lors de l'implémentation de la logique de l'instruction, nous devons gérer diverses exceptions, telles que le débordement de pile, la profondeur d'appel excessive. , Débordement de mémoire, etc. En supposant que notre Golang EVM soit une implémentation complète d'Ethereum, nous devons gérer une série d'autres exceptions, telles que le compte n'existe pas, le compte est verrouillé, l'extraction n'est pas terminée, etc.

Conclusion

L'utilisation de Golang pour implémenter EVM peut améliorer les performances et l'efficacité du développement des contrats intelligents. Il offre aux développeurs une plus grande flexibilité et liberté pour mieux s'adapter à divers scénarios d'application. Bien que la mise en œuvre de Golang EVM soit plus compliquée que la mise en œuvre de Solidity EVM, elle offre une voie nouvelle et efficace pour le développement d'EVM.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!