Ir para o conteúdo

Biblioteca Python Web3.py

Introdução

Web3.py é um conjunto de bibliotecas que permite interagir com nós Ethereum via HTTP, IPC ou WebSocket em Python. As redes EVM da Tanssi expõem uma API compatível com Ethereum/JSON-RPC, então você pode usar Web3.py para falar com um nó EVM da Tanssi como se estivesse no Ethereum. Veja a documentação para mais detalhes.

Neste guia, você configurará o Web3.py para sua rede EVM da Tanssi e usará a biblioteca para enviar uma transação e implantar um contrato em uma appchain de demonstração executando no Dancelight. Para sua rede, basta trocar o endpoint.

Note

Os exemplos deste guia partem de um ambiente MacOS ou Ubuntu 20.04. Se estiver usando Windows, adapte os comandos conforme necessário.

Além disso, certifique-se de ter o Python 3 e um gerenciador de pacotes como o pip instalados.

Verificando pré-requisitos

Você precisará:

  • De uma conta com fundos na rede EVM Tanssi usada nos testes

Instalando Web3.py

Instale Web3.py e o compilador Solidity:

pip3 install web3 py-solc-x

Configurando o provedor Web3.py

Os scripts a seguir usam um provedor Web3.py para se conectar à rede.

  1. Importe web3.
  2. Crie o provedor HTTP com a URL RPC da rede.
# 1. Importe web3.py
from web3 import Web3

# 2. Crie o provedor web3.py
# Insira sua URL RPC aqui
web3 = Web3(Web3.HTTPProvider('https://services.tanssi-testnet.network/dancelight-2001/'))

Guarde este trecho; ele é reutilizado nos scripts seguintes.

Enviar uma transação

Dois scripts: um para saldos e outro para enviar.

Script de saldos

Crie o arquivo:

touch balances.py

Passos:

  1. Inclua o provedor Web3.
  2. Defina address_from e address_to.
  3. Use web3.eth.get_balance e web3.from_wei para exibir em TANGO.
# 1. Import web3.py
from web3 import Web3

# 2. Create web3.py provider
provider_rpc = {
    # Insert your RPC URL here
    "evm_network": "https://services.tanssi-testnet.network/dancelight-2001",
}
web3 = Web3(Web3.HTTPProvider(provider_rpc["evm_network"]))

# 2. Create address variables
address_from = "INSERT_ADDRESS_FROM"
address_to = "INSERT_ADDRESS_TO"

# 4. Fetch balance data
balance_from = web3.from_wei(
    web3.eth.get_balance(Web3.to_checksum_address(address_from)), "ether"
)
balance_to = web3.from_wei(
    web3.eth.get_balance(Web3.to_checksum_address(address_to)), "ether"
)

print(f"The balance of { address_from } is: { balance_from } TANGO")
print(f"The balance of { address_to } is: { balance_to } TANGO")

Execute:

python3 balances.py

Verificar saldo Web3.py

Script de envio

Crie o arquivo:

touch transaction.py

Passos:

  1. Importe Web3.py e rpc_gas_price_strategy.
  2. Inclua o provedor.
  3. Defina account_from (com private_key) e address_to. Não armazene chaves reais em arquivos Python.
  4. Defina a estratégia de gas price com rpc_gas_price_strategy.
  5. Monte e assine a transação com sign_transaction (nonce, gas, gasPrice, to, value). Use get_transaction_count para nonce, generate_gas_price para gasPrice e to_wei para valor.
  6. Envie com send_raw_transaction e aguarde recibo com wait_for_transaction_receipt.
# 1. Add imports
from web3 import Web3
from web3.gas_strategies.rpc import rpc_gas_price_strategy

# 2. Create web3.py provider
provider_rpc = {
    # Insert your RPC URL here
    "evm_network": "https://services.tanssi-testnet.network/dancelight-2001",
}
web3 = Web3(Web3.HTTPProvider(provider_rpc["evm_network"]))

# 3. Create address variables
account_from = {
    "private_key": "INSERT_ YOUR_PRIVATE_KEY",
    "address": "INSERT_ PUBLIC_ADDRESS_OF_PK",
}
address_to = "INSERT_ ADDRESS_TO"

print(
    f'Attempting to send transaction from { account_from["address"] } to { address_to }'
)

# 4. Set the gas price strategy
web3.eth.set_gas_price_strategy(rpc_gas_price_strategy)

# 5. Sign tx with PK
tx_create = web3.eth.account.sign_transaction(
    {
        "nonce": web3.eth.get_transaction_count(
            Web3.to_checksum_address(account_from["address"])
        ),
        "gasPrice": web3.eth.generate_gas_price(),
        "gas": 21000,
        "to": Web3.to_checksum_address(address_to),
        "value": web3.to_wei("1", "ether"),
    },
    account_from["private_key"],
)

# 6. Send tx and wait for receipt
tx_hash = web3.eth.send_raw_transaction(tx_create.rawTransaction)
tx_receipt = web3.eth.wait_for_transaction_receipt(tx_hash)

print(f"Transaction successful with hash: { tx_receipt.transactionHash.hex() }")

Execute:

python3 transaction.py

Enviar Tx Web3.py

Implantar um contrato

O contrato que você irá compilar e implantar nas próximas seções é um simples incrementador, chamado Incrementer.sol. Comece criando o arquivo do contrato:

touch Incrementer.sol

Depois, adicione o código Solidity ao arquivo:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract Incrementer {
    uint256 public number;

    constructor(uint256 _initialNumber) {
        number = _initialNumber;
    }

    function increment(uint256 _value) public {
        number = number + _value;
    }

    function reset() public {
        number = 0;
    }
}

A função constructor, executada quando o contrato é implantado, define o valor inicial da variável number armazenada on-chain (padrão é 0). A função increment soma o _value informado ao número atual, mas exige uma transação, pois modifica o dado armazenado. Por fim, a função reset zera o valor armazenado.

Note

Este contrato é apenas um exemplo simples para fins ilustrativos.

Script de compilação

Crie compile.py:

touch compile.py

Passos:

  1. Importe solcx.
  2. (Opcional) Instale o solc com solcx.install_solc.
  3. Compile Incrementer.sol com solcx.compile_files.
  4. Exporte ABI e bytecode.
# 1. Import solcx
import solcx

# 2. If you haven't already installed the Solidity compiler, uncomment the following line
# solcx.install_solc()

# 3. Compile contract
temp_file = solcx.compile_files(
    "Incrementer.sol",
    output_values=["abi", "bin"],
    # solc_version='0.8.19'
)

# 4. Export contract data
abi = temp_file["Incrementer.sol:Incrementer"]["abi"]
bytecode = temp_file["Incrementer.sol:Incrementer"]["bin"]

Nota

Se aparecer erro de solc não instalado, descomente a etapa 2 no snippet.

Script de deploy

Compile primeiro; depois crie deploy.py:

touch deploy.py

Passos:

  1. Importe Web3.py, ABI e bytecode.
  2. Inclua o provedor.
  3. Defina account_from/private_key (não salve chaves reais em Python).
  4. Crie instância do contrato com ABI/bytecode.
  5. Construa a tx do construtor (valor inicial 5) com build_transaction, incluindo from e nonce.
  6. Assine com sign_transaction.
  7. Envie com send_raw_transaction e aguarde recibo com wait_for_transaction_receipt.
# 1. Add imports
from compile import abi, bytecode
from web3 import Web3

# 2. Create web3.py provider
provider_rpc = {
    # Insert your RPC URL here
    "evm_network": "https://services.tanssi-testnet.network/dancelight-2001",
}
web3 = Web3(Web3.HTTPProvider(provider_rpc["evm_network"]))

# 3. Create address variable
account_from = {
    "private_key": "INSERT_YOUR_PRIVATE_KEY",
    "address": "INSERT_PUBLIC_ADDRESS_OF_PK",
}

print(f'Attempting to deploy from account: { account_from["address"] }')

# 4. Create contract instance
Incrementer = web3.eth.contract(abi=abi, bytecode=bytecode)

# 5. Build constructor tx
construct_txn = Incrementer.constructor(5).build_transaction(
    {
        "from": Web3.to_checksum_address(account_from["address"]),
        "nonce": web3.eth.get_transaction_count(
            Web3.to_checksum_address(account_from["address"])
        ),
    }
)

# 6. Sign tx with PK
tx_create = web3.eth.account.sign_transaction(
    construct_txn, account_from["private_key"]
)

# 7. Send tx and wait for receipt
tx_hash = web3.eth.send_raw_transaction(tx_create.rawTransaction)
tx_receipt = web3.eth.wait_for_transaction_receipt(tx_hash)

print(f"Contract deployed at address: { tx_receipt.contractAddress }")

Execute:

python3 deploy.py

Implantar Contrato Web3py

Ler dados do contrato (calls)

Calls não mudam estado; não precisam de transação. Crie get.py:

touch get.py

Passos:

  1. Importe Web3.py e o ABI.
  2. Inclua o provedor.
  3. Defina contract_address.
  4. Instancie o contrato com ABI/endereço.
  5. Chame number() e exiba.
# 1. Import the ABI
from compile import abi
from web3 import Web3

# 2. Create web3.py provider
provider_rpc = {
    # Insert your RPC URL here
    "evm_network": "https://services.tanssi-testnet.network/dancelight-2001",
}
web3 = Web3(Web3.HTTPProvider(provider_rpc["evm_network"]))

# 3. Create address variable
contract_address = "INSERT_CONTRACT_ADDRESS"

print(f"Making a call to contract at address: { contract_address }")

# 4. Create contract instance
Incrementer = web3.eth.contract(address=contract_address, abi=abi)

# 5. Call Contract
number = Incrementer.functions.number().call()
print(f"The current number stored is: { number } ")

Execute:

python3 get.py

Ler do Contrato Web3py

Interagir com o contrato (sends)

Sends alteram estado; exigem transação. Crie increment.py e reset.py:

touch increment.py reset.py

increment.py:

  1. Importe Web3.py e ABI.
  2. Inclua o provedor.
  3. Defina account_from/private_key, contract_address, value (não salve chaves reais em Python).
  4. Instancie o contrato.
  5. Construa a tx de incremento com build_transaction (from, nonce).
  6. Assine com sign_transaction.
  7. Envie com send_raw_transaction e aguarde recibo.
# 1. Add imports
from compile import abi
from web3 import Web3

# 2. Create web3.py provider
provider_rpc = {
    # Insert your RPC URL here
    "evm_network": "https://services.tanssi-testnet.network/dancelight-2001",
}
web3 = Web3(Web3.HTTPProvider(provider_rpc["evm_network"]))

# 3. Create variables
account_from = {
    "private_key": "INSERT_YOUR_PRIVATE_KEY",
    "address": "INSERT_PUBLIC_ADDRESS_OF_PK",
}
contract_address = "INSERT_CONTRACT_ADDRESS"
value = 3

print(
    f"Calling the increment by { value } function in contract at address: { contract_address }"
)

# 4. Create contract instance
Incrementer = web3.eth.contract(address=contract_address, abi=abi)

# 5. Build increment tx
increment_tx = Incrementer.functions.increment(value).build_transaction(
    {
        "from": Web3.to_checksum_address(account_from["address"]),
        "nonce": web3.eth.get_transaction_count(
            Web3.to_checksum_address(account_from["address"])
        ),
    }
)

# 6. Sign tx with PK
tx_create = web3.eth.account.sign_transaction(increment_tx, account_from["private_key"])

# 7. Send tx and wait for receipt
tx_hash = web3.eth.send_raw_transaction(tx_create.rawTransaction)
tx_receipt = web3.eth.wait_for_transaction_receipt(tx_hash)

print(f"Tx successful with hash: { tx_receipt.transactionHash.hex() }")

Execute:

python3 increment.py

Incrementar Contrato Web3py

reset.py segue o mesmo padrão chamando reset() sem argumentos:

# 1. Add imports
from compile import abi
from web3 import Web3

# 2. Create web3.py provider
provider_rpc = {
    # Insert your RPC URL here
    "evm_network": "https://services.tanssi-testnet.network/dancelight-2001",
}
web3 = Web3(Web3.HTTPProvider(provider_rpc["evm_network"]))

# 3. Create variables
account_from = {
    "private_key": "INSERT_YOUR_PRIVATE_KEY",
    "address": "INSERT_PUBLIC_ADDRESS_OF_PK",
}
contract_address = "INSERT_CONTRACT_ADDRESS"

print(f"Calling the reset function in contract at address: { contract_address }")

# 4. Create contract instance
Incrementer = web3.eth.contract(address=contract_address, abi=abi)

# 5. Build reset tx
reset_tx = Incrementer.functions.reset().build_transaction(
    {
        "from": Web3.to_checksum_address(account_from["address"]),
        "nonce": web3.eth.get_transaction_count(
            Web3.to_checksum_address(account_from["address"])
        ),
    }
)

# 6. Sign tx with PK
tx_create = web3.eth.account.sign_transaction(reset_tx, account_from["private_key"])

# 7. Send tx and wait for receipt
tx_hash = web3.eth.send_raw_transaction(tx_create.rawTransaction)
tx_receipt = web3.eth.wait_for_transaction_receipt(tx_hash)

print(f"Tx successful with hash: { tx_receipt.transactionHash.hex() }")

Execute:

python3 reset.py

Redefinir Contrato Web3py

As informações apresentadas aqui foram fornecidas por terceiros e estão disponíveis apenas para fins informativos gerais. A Tanssi não endossa nenhum projeto listado e descrito no Site de Documentação da Tanssi (https://docs.tanssi.network/). A Tanssi Foundation não garante a precisão, integridade ou utilidade dessas informações. Qualquer confiança depositada nelas é de sua exclusiva responsabilidade. A Tanssi Foundation se exime de toda responsabilidade decorrente de qualquer confiança que você ou qualquer outra pessoa possa ter em qualquer parte deste conteúdo. Todas as declarações e/ou opiniões expressas nesses materiais são de responsabilidade exclusiva da pessoa ou entidade que as fornece e não representam necessariamente a opinião da Tanssi Foundation. As informações aqui não devem ser interpretadas como aconselhamento profissional ou financeiro de qualquer tipo. Sempre busque orientação de um profissional devidamente qualificado em relação a qualquer assunto ou circunstância em particular. As informações aqui podem conter links ou integração com outros sites operados ou conteúdo fornecido por terceiros, e tais sites podem apontar para este site. A Tanssi Foundation não tem controle sobre esses sites ou seu conteúdo e não terá responsabilidade decorrente ou relacionada a eles. A existência de qualquer link não constitui endosso desses sites, de seu conteúdo ou de seus operadores. Esses links são fornecidos apenas para sua conveniência, e você isenta e exonera a Tanssi Foundation de qualquer responsabilidade decorrente do uso dessas informações ou das informações fornecidas por qualquer site ou serviço de terceiros.
Última atualização: 9 de dezembro de 2025
| Criada: 9 de dezembro de 2025