WEB3DEV

Cover image for Construindo um Bot para Trade Sanduíche com Python para Uniswap e MetaMask: Um Tutorial Passo a Passo — Rami Jaloudi
Banana Labs
Banana Labs

Posted on

Construindo um Bot para Trade Sanduíche com Python para Uniswap e MetaMask: Um Tutorial Passo a Passo — Rami Jaloudi

capa

Os bots para trade tornaram-se cada vez mais populares no mundo das criptomoedas. Neste tutorial, vamos guiá-lo pelo processo de construção de um trade bot sanduíche usando o protocolo de troca descentralizada Uniswap e interagindo com ele usando a carteira MetaMask. Este bot tem como objetivo aproveitar as oscilações de preço entre dois ativos, colocando ordens de compra e venda em níveis de preço predefinidos. Ao seguir este guia passo a passo, você aprenderá como integrar o Uniswap, buscar preços de mercado em tempo real, executar negociações e garantir interações seguras usando o MetaMask.

Pré-requisitos:

1.Entendimento básico da linguagem de programação Python.
2.Familiaridade com o protocolo Uniswap e a carteira MetaMask.
3.Conhecimento básico sobre exchanges descentralizadas e estratégias de trade.

Passo 1: Configurando o Ambiente de Desenvolvimento

1.Instale o Python e as bibliotecas necessárias: Web3.py, requests, eth-account.
2.Crie um novo script em Python para o nosso trade bot sanduíche.

Passo 2: Inicialize o Provedor Web3 e Carregue a Carteira

  • Obtenha um ID de projeto da Infura e defina-o como o URL do provedor.
  • Inicialize Web3 com o URL do provedor e ative o middleware_geth_poa.
  • Carregue a carteira MetaMask fornecendo a chave privada e a frase secreta.

Passo 3: Configure os Endereços dos Contratos da Uniswap

  • Obtenha o endereço do contrato do roteador na documentação da Uniswap.
  • Defina os endereços dos tokens que você deseja negociar.

Passo 4: Busque os Preços em Tempo Real dos Tokens

  • Use a API CoinGecko para buscar os preços de mercado dos tokens.
  • Implemente uma função para recuperar os preços dos tokens usando a API.

Passo 5: Execute a Estratégia de Trade Sanduíche

  • Calcule os preços de compra e venda alvo com base nas diferenças de preço.
  • Simule a verificação dos preços de mercado ou implemente sua própria lógica.
  • Execute a negociação de compra se as condições forem atendidas.
  • Execute a negociação de venda se as condições forem atendidas.

Passo 6: Interaja com a Uniswap e Execute as Negociações

  • Autorize a transferência de tokens usando a função approve do contrato do roteador.
  • Construa a transação para trocar tokens usando a função swapExactTokensForTokens.
  • Assine e envie a transação para a rede Ethereum.
  • Aguarde o recibo da transação e lide com quaisquer erros.

Passo 7: Testando e Executando o Trade Bot Sanduíche

  • Configure um ambiente de teste ou use uma sandbox na rede Ethereum.
  • Modifique o código para se adequar aos seus requisitos específicos de negociação.
  • Execute o script do trade bot sanduíche e observe a execução das negociações.

Para fazer o trade bot sanduíche funcionar com a Uniswap e a MetaMask, você precisará integrar o protocolo Uniswap e interagir com ele usando a carteira MetaMask.

Aqui está uma versão do trade bot sanduíche que incorpora esses componentes:

import time
import json
import requests
from web3 import Web3
from web3.middleware import geth_poa_middleware
from web3.exceptions import InvalidAddress
from eth_account import Account
# URL do provedor de nó Ethereum
provider_url = 'https://mainnet.infura.io/v3/SEU_ID_DO_PROJETO_INFURA'
# Endereços de contrato Uniswap
router_address = '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D'
token_1_address = '0xTOKEN_1_ADDRESS' # Example token 1 address
token_2_address = '0xTOKEN_2_ADDRESS' # Example token 2 address
# Chave privada e senha da carteira MetaMask
wallet_private_key = 'SUA_CHAVE_PRIVADA_DA_CARTEIRA'
wallet_passphrase = 'SUA_FRASE_SECRETA_DA_CARTEIRA'
# Inicializar provedor Web3
web3 = Web3(Web3.HTTPProvider(provider_url))
web3.middleware_onion.inject(geth_poa_middleware, layer=0)
# Carregue a carteira
wallet = Account.from_key(wallet_private_key)
# Definir os endereços do contrato
router_contract = web3.eth.contract(address=Web3.toChecksumAddress(router_address), abi=json.loads(UNISWAP_ROUTER_ABI))
# Especifique o token e valor do trade
token_1_amount = web3.toWei(1, 'ether') # Amount of token 1 to trade
token_2_amount = web3.toWei(1, 'ether') # Amount of token 2 to trade
trade_slippage = 0.05 # Slippage tolerance (5%)
# Função para executar o trade
def execute_sandwich_trade():
 # Obtenha os preços de token mais recentes da Uniswap
 token_1_price = get_token_price(token_1_address)
 token_2_price = get_token_price(token_2_address)
# Calcular os preços-alvo
 buy_price = token_1_price - (token_2_price * (1 + trade_slippage))
 sell_price = token_1_price + (token_2_price * (1 - trade_slippage))
# Simule consultando os preços de mercado
 # Substitua isso por sua própria lógica para obter preços de mercado em tempo real
 token_1_market_price = get_token_price(token_1_address)
 token_2_market_price = get_token_price(token_2_address)
# Execute buy trade
 if token_1_market_price <= buy_price:
 print("Executing buy trade...")
 execute_uniswap_trade(token_2_address, token_2_amount, token_1_address, token_1_amount)
# Execute sell trade
 elif token_1_market_price >= sell_price:
 print("Executing sell trade...")
 execute_uniswap_trade(token_1_address, token_1_amount, token_2_address, token_2_amount)
# Função para obter o preço do token da Uniswap
def get_token_price(token_address):
 try:
 response = requests.get(f'https://api.coingecko.com/api/v3/simple/token_price/ethereum?contract_addresses={token_address}&vs_currencies=usd')
 data = response.json()
 token_price = data[token_address.lower()]['usd']
 return token_price
 except Exception as e:
 print(f"Error fetching token price: {e}")
 return None
# Função para executar o trade na Uniswap
def execute_uniswap_trade(from_token, from_amount, to_token, to_amount):
 try:
 # Aprovar a transferência de token
 approve_tx = router_contract.functions.approve(
 Web3.toChecksumAddress(router_address),
 from_amount
 ).buildTransaction({
 'from': wallet.address,
 'gas': 100000,
 'gasPrice': web3.toWei('5', 'gwei'),
 'nonce': web3.eth.getTransactionCount(wallet.address),
 })
 signed_approve_tx = web3.eth.account.sign_transaction(approve_tx, private_key=wallet.privateKey)
 approve_tx_hash = web3.eth.send_raw_transaction(signed_approve_tx.rawTransaction)
 web3.eth.wait_for_transaction_receipt(approve_tx_hash)
# Execute o swap
 swap_tx = router_contract.functions.swapExactTokensForTokens(
 from_amount,
 to_amount,
 [from_token, to_token],
 wallet.address,
 int(time.time()) + 10000
 ).buildTransaction({
 'from': wallet.address,
 'gas': 200000,
 'gasPrice': web3.toWei('5', 'gwei'),
 'nonce': web3.eth.getTransactionCount(wallet.address),
 })
 signed_swap_tx = web3.eth.account.sign_transaction(swap_tx, private_key=wallet.privateKey)
 swap_tx_hash = web3.eth.send_raw_transaction(signed_swap_tx.rawTransaction)
 web3.eth.wait_for_transaction_receipt(swap_tx_hash)
print("Trade executed successfully.")
 except InvalidAddress as e:
 print(f"Invalid contract address: {e}")
 except Exception as e:
 print(f"Error executing trade: {e}")
# Main loop
while True:
 execute_sandwich_trade()
 time.sleep(10) # Wait for 10 seconds before executing the next trade
Enter fullscreen mode Exit fullscreen mode

Neste código, adicionamos a capacidade de buscar preços de tokens usando a API CoinGecko e executar negociações na Uniswap usando a carteira MetaMask. Você precisará substituir 'SEU_ID_DO_PROJETO_INFURA', 'SUA_CHAVE_PRIVADA_DA_CARTEIRA', 'SUA_FRASE_SECRETA_DA_CARTEIRA', '0xTOKEN_1_ADDRESS', '0xTOKEN_2_ADDRESS' e 'UNISWAP_ROUTER_ABI' pelos seus próprios valores.

Certifique-se de ter as dependências necessárias instaladas, incluindo as bibliotecas Web3.py, requests e eth-account. Além disso, substitua a função get_token_price() pela sua própria lógica para buscar os preços de mercado em tempo real.

Lembre-se de que os bots de negociação envolvem riscos e é crucial testar e validar completamente sua estratégia antes de implantá-la com fundos reais. Certifique-se de compreender os riscos associados às estratégias de negociação, às interações com contratos inteligentes e às considerações de segurança ao usar uma carteira como a MetaMask.

Lembre-se de lidar adequadamente com as taxas de gás e conduza uma pesquisa completa ou consulte um consultor financeiro para tomar decisões de negociação informadas.

Conclusão: Neste tutorial, abordamos o processo passo a passo de construção de um trade bot sanduíche que funciona com o protocolo de troca descentralizada Uniswap e a carteira MetaMask. Exploramos conceitos-chave, como a inicialização do ambiente de desenvolvimento, a busca de preços de tokens em tempo real, a execução de negociações na Uniswap e a garantia de interações seguras usando a MetaMask. Ao seguir este guia, você pode obter experiência prática no desenvolvimento e implantação do seu próprio bot de negociação, permitindo que você explore e implemente várias estratégias de negociação no ecossistema de finanças descentralizadas.

Lembre-se de que os trade bots têm riscos inerentes, e é crucial testar e validar completamente sua estratégia antes de implantá-la com fundos reais. Além disso, mantenha-se informado sobre tendências de mercado, técnicas de gerenciamento de riscos e considerações de segurança para tomar decisões informadas de negociação. Feliz construção de bot e felizes negociações!

Abaixo está um bot de negociação de arbitragem suplementar que você pode usar na Uniswap e em outra DEX onde existam diferenças de preço nas quais você pode lucrar:

import requests
import time

class ArbitrageBot:
    def __init__(self, exchange1_api_url, exchange2_api_url):
        self.exchange1_api_url = exchange1_api_url
        self.exchange2_api_url = exchange2_api_url

    def fetch_price(self, exchange_api_url):
        response = requests.get(exchange_api_url)
        data = response.json()
        return float(data["price"])

    def execute_trade(self, exchange_api_url, trade_data):
        response = requests.post(exchange_api_url, json=trade_data)
        return response.json()

    def find_arbitrage_opportunity(self):
        price1 = self.fetch_price(self.exchange1_api_url)
        price2 = self.fetch_price(self.exchange2_api_url)

        # Calcular a porcentagem de lucro potencial
        profit_percentage = (price2 - price1) / price1 * 100

        if profit_percentage > 0:
            # Realizar negociação de arbitragem
            trade_data = {
                # Definir parâmetros de negociação para comprar na exchange 1 e vender na exchange 2
            }
            trade_result = self.execute_trade(self.exchange1_api_url, trade_data)
            print("Arbitrage opportunity found:")
            print(f"Buy on Exchange 1, Sell on Exchange 2")
            print(f"Profit Percentage: {profit_percentage}%")
            print(f"Trade Result: {trade_result}")
        else:
            print("No arbitrage opportunity found.")

    def run(self, interval_seconds):
        while True:
            self.find_arbitrage_opportunity()
            time.sleep(interval_seconds)

# Exemplo de uso
if __name__ == "__main__":
    exchange1_api_url = "https://exchange1.com/api"
    exchange2_api_url = "https://exchange2.com/api"

    bot = ArbitrageBot(exchange1_api_url, exchange2_api_url)
    bot.run(interval_seconds=10)

Enter fullscreen mode Exit fullscreen mode

Esse artigo é uma tradução feita por @bananlabs. Você pode encontrar o artigo original aqui

Latest comments (0)