Accédez à Ethereum avec Python via web3.py

Si vous souhaitez accéder à Ethereum via Python, vous pouvez voir sur le Github officiel d'Ethereum qu'il existe deux modules qui peuvent le faire : web3.py et pyethereum. D'après ma compréhension actuelle, la différence entre les deux est que web3.py est principalement utilisé comme client pour un accès externe à Ethereum, ce qui signifie que la bibliothèque de fonctions web3.py elle-même ne deviendra pas un nœud blockchain, ni ne le fera. il effectue des blocs. La synchronisation en chaîne consiste à connecter un nœud sur la blockchain et à utiliser la blockchain comme base de données externe, tandis que pyethereum ressemble plus à geth, qui est utilisé pour se créer un nœud blockchain. La synchronisation sera effectuée normalement, et vous pourrez le faire. commencez également l’exploitation minière en tant que mineur.

Dans cet article, parce que je souhaite qu'un client léger interagisse avec la blockchain et que je ne veux pas préparer un énorme espace de stockage pour stocker les données de la blockchain, j'utiliserai web3.py comme principal.

• Configurer l'environnement d'exécution web3.py
• Connectez les nœuds Ethereum via web3.py
• Accédez aux contrats ERC20 sur la blockchain
• Signez et envoyez des transactions

Configurez l'environnement d'exécution web3.py

web3.py OK Installer directement via pépin.

pip install web3

Il est à noter que lorsque vous souhaitez installer sur Windows, vous devrez installer Visual C++ Builder à l'avance, sinon il échouera car il ne pourra pas être compilé lors de la phase finale de l'installation.

Connectez-vous aux nœuds Ethereum via web3.py

web3.py n'existera pas en tant que nœud blockchain, il a donc besoin d'un nœud pour accéder aux données sur la blockchain. De manière générale, le moyen le plus sûr consiste à utiliser geth ou parity pour créer vos propres nœuds. Cependant, si vous ne souhaitez pas créer vos propres nœuds, vous pouvez envisager de consulter le service de nœud HTTP fourni par infura.

Basé sur l'API actuelle d'infura, si vous souhaitez vous connecter à la chaîne de test Ropsten, l'URL du lien est https://ropsten.infura.io/v3/api_key, où l'api_key doit être enregistrée pour obtenir un compte. Le programme suivant imite la pratique du auto.infura intégré de web3.py, qui lit le paramètre INFURA_API_KEY de la variable d'environnement pour former l'adresse HTTP d'infura.io, qui est utilisée pour établir une connexion avec la chaîne de test Ropsten.

Dépôt et retrait de contrats ERC20 sur la blockchain

import os
from web3 import (
HTTPProvider,
Web3,
)
INFURA_ROPSTEN_BASE_URL = 'https://ropsten.infura.io/v3'
def load_infura_url():
key = os.environ.get('INFURA_API_KEY', '')
return "%s/%s" % (INFURA_ROPSTEN_BASE_URL, key)
w3 = Web3(HTTPProvider(load_infura_url()))

Avant de commencer à déposer et à retirer des contrats, vous devez parler de ce qu'est ABI. Dans Ethereum, comme les contrats existent tous sous forme de code binaire compilé, la bibliothèque de fonctions n'a aucun moyen de savoir directement quel est le contenu transmis par le contrat, car les valeurs de retour du contrat sont toutes binaires. Par conséquent, avant d'exploiter le contrat, un fichier ABI doit être fourni pour indiquer à la bibliothèque de fonctions comment utiliser le contrat.

# Assume the contract we're going to invoke is a standard ERC20 contract.
with open("erc20.abi.json") as f:
erc20_abi = json.load(f)
# Web3 accept only checksum address. So we should ensure the given address is a
# checksum address before accessing the corresponding contract.
contract_addr = w3.toChecksumAddress('0x4e470dc7321e84ca96fcaedd0c8abcebbaeb68c6');
erc20_contract = w3.eth.contract(address=contract_addr, abi=erc20_abi)
for func in erc20_contract.all_functions():
logger.debug('contract functions: %s', func)
logger.debug("Name of the token: %s", erc20_contract.functions.name().call())

Ici, nous supposons que nous voulons accéder au contrat intelligent avec l'adresse 0x4e470dc7321e84ca96fcaedd0c8abcebbaeb68c6 sur la chaîne de test Ropsten. Ce contrat est un contrat ERC20 trouvé aléatoirement via Etherscan, vous pouvez donc utiliser le standard ERC20 ABI pour y accéder. Lorsque nous créons l'instance de ce contrat, nous exécutons d'abord une boucle pour imprimer toutes les fonctions du contrat (cette étape répertorie en fait les informations sur l'ABI), puis essayons d'appeler name() dans le contrat pour obtenir le déclaration de contrat. Nom du jeton. Le résultat final est le suivant :

2018-09-07 15:02:53,815 | __main__ | DEBUG | contract functions: <Function name()>
2018-09-07 15:02:53,816 | __main__ | DEBUG | contract functions: <Function approve(address,uint256)>
2018-09-07 15:02:53,824 | __main__ | DEBUG | contract functions: <Function totalSupply()>
2018-09-07 15:02:53,824 | __main__ | DEBUG | contract functions: <Function transferFrom(address,address,uint256)>
2018-09-07 15:02:53,824 | __main__ | DEBUG | contract functions: <Function decimals()>
2018-09-07 15:02:53,824 | __main__ | DEBUG | contract functions: <Function balanceOf(address)>
2018-09-07 15:02:53,824 | __main__ | DEBUG | contract functions: <Function symbol()>
2018-09-07 15:02:53,825 | __main__ | DEBUG | contract functions: <Function transfer(address,uint256)>
2018-09-07 15:02:53,825 | __main__ | DEBUG | contract functions: <Function allowance(address,address)>
2018-09-07 15:02:54,359 | __main__ | DEBUG | Name of the token: KyberNetwork

Signez et envoyez la transaction

Dans l'exemple ci-dessus, lorsque vous appelez le contrat intelligent, vous appelez directement la fonction dans le contrat, mais cela ne peut généralement être utilisé que pour lire des données sur le statut de la blockchain. Si vous souhaitez écrire des données sur la blockchain en appelant un contrat intelligent, vous devez appeler le contrat d'une autre manière, c'est-à-dire que vous devez d'abord signer la transaction, puis payer de l'essence pour exécuter la transaction.

Supposons que nous souhaitions également appeler un contrat ERC20 et exécuter la fonction transferFrom() sur le contrat. transferFrom() nécessite trois paramètres _from, _to et _value, ce qui signifie que le montant du transfert doit être transféré du compte _from au compte _to et que le montant du transfert est _value.

# Set the account which makes the transaction.
account = w3.toChecksumAddress(os.environ.get('ETHEREUM_ACCOUNT', ''))
w3.eth.defaultAccount = account
# Web3 accept only checksum address. So we should ensure the given address is a
# checksum address before accessing the corresponding contract.
contract_address = w3.toChecksumAddress('0x4e470dc7321e84ca96fcaedd0c8abcebbaeb68c6')
contract = w3.eth.contract(address=contract_address, abi=contract_abi)
# Prepare the necessary parameters for making a transaction on the blockchain.
estimate_gas = contract.functions.transferFrom(account, account, w3.toWei('1', 'eth')).estimateGas()
nonce = w3.eth.getTransactionCount(account)
# Build the transaction.
txn = contract.functions.transferFrom(account, account, w3.toWei('1', 'eth')).buildTransaction({
'chainId': 3,
'gas': estimate_gas,
'gasPrice': w3.toWei('1', 'gwei'),
'nonce': nonce
})
logger.debug('Transaction: %s', txn)
# Sign the transaction.
private_key = bytes.fromhex(os.environ.get('ETHEREUM_ACCOUNT_PKEY', ''))
signed_txn = w3.eth.account.signTransaction(txn, private_key=private_key)
tx_hash = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
logger.debug('Txhash: 0x%s', bytes.hex(tx_hash))

Dans le programme ci-dessus, les lignes 2 ~ 3 lisent d'abord le compte que nous voulons utiliser à partir de la variable d'environnement. Ce compte sera utilisé pour envoyer des transactions. Bien sûr, lors du paiement du gaz, il sera également déduit de ce compte. Les lignes 10 à 20 créent une transaction brute. Dans cette transaction, comme nous devons spécifier des paramètres tels que le gaz, le nonce, etc., nous devons confirmer le nombre de paramètres à définir dans les lignes 11 à 12 précédentes. Ensuite, les lignes les plus importantes 25 à 26 lisent la clé privée et utilisent la clé privée pour signer la transaction. On suppose ici que la clé privée sera composée de texte codé en Hex, donc bytes.fromhex est utilisé pour reconvertir le codage Hex au format octet. Après la signature, envoyez la transaction. Lors de l'envoi de la transaction, l'API renverra le hachage de la transaction au format octet. Vous pouvez l'encoder et l'imprimer. Vous pourrez ensuite rechercher la transaction sur etherscan.

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!