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
approvedo 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
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)
Esse artigo é uma tradução feita por @bananlabs. Você pode encontrar o artigo original aqui
Top comments (0)