Como configurar um bot do Telegram para Solana

Etapas para configurar um bot do Telegram

1. Configure o canal e o bot do Telegram.
2. Crie um Worker da Cloudflare para atuar como conexão entre o webhook que envia as atualizações e o bot do Telegram.
3. Crie um webhook da Helius.
4. Edite os endereços monitorados pelo webhook por meio da Helius Webhook API. Esta etapa só é necessária para monitorar coleções inteiras de NFT.

Configure um bot do Telegram

Os bots do Telegram são uma ótima maneira de automatizar determinadas tarefas, especialmente atualizações. Veja como configurar um.

1. Inicie uma conversa com o BotFather

Pesquise por 'BotFather' na barra de pesquisa do Telegram e clique nele para iniciar uma conversa.

2. Crie um novo bot

Digite e envie '/newbot'. O BotFather orientará você na escolha do nome e do nome de usuário do seu bot.

3. Obtenha um token de acesso

Ao terminar, o BotFather fornecerá um token de acesso.

Anote-o em um local seguro, pois ele será usado mais adiante neste tutorial.

4. Crie seu canal

Acesse o menu (☰) e selecione 'Novo Canal'.

Depois de configurar o canal, clique no nome dele, selecione 'Administradores' e adicione seu bot como administrador.

5. Encontre o ID do chat

Para descobrir o ID do chat do seu canal, siga estas etapas:

Envie uma mensagem:

Primeiro, envie uma mensagem para o canal que você criou.

Use a API do Telegram

Acesse https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates no navegador, substituindo <YOUR_BOT_TOKEN> pelo token que você recebeu do BotFather.

Localize o ID do chat

Nos dados retornados, você encontrará um campo chamado chat e, dentro dele, um id, que é o ID do chat do seu canal.

Lembre-se de anotar esse ID do chat em um local seguro, pois você precisará dele para outras configurações.

Crie um Worker da Cloudflare

Os Workers da Cloudflare permitem implantar código hospedado on-line e executado de forma permanente, ficando sempre atentos às atualizações do seu webhook.

1. Acesse a Cloudflare

Primeiro, acesse sua conta da Cloudflare. Se ainda não tiver uma, você poderá criar uma gratuitamente.

2. Acesse a seção Workers

No painel da Cloudflare, acesse a aba "Workers".

3. Crie um novo Worker

Clique no botão “Create a Worker”. Isso levará você ao editor do Worker.

4. Edite o código do Worker

No editor, você verá um modelo de script. Substitua o código padrão pelo código da Cloudflare fornecido para seu bot do Telegram.

Localize no código as variáveis BOT_TOKEN e CHAT_ID. Elas são placeholders e serão usadas para enviar mensagens pelo seu bot ao chat correto.

5. Configure as variáveis de ambiente

No painel do Cloudflare Workers, acesse a aba "Settings" do seu Worker.

Nela, você pode adicionar o token do bot, o token do chat e sua chave de API da Helius como variáveis de ambiente. Isso mantém os dados confidenciais fora do código principal e em segurança.

Certifique-se de nomear corretamente essas variáveis de ambiente para corresponder ao que o código espera (por exemplo, BOT_TOKEN, CHAT_ID etc.).

6. Implante o Worker

Depois de verificar se o código e as variáveis de ambiente estão configurados corretamente, clique no botão “Save and Deploy”. Seu Worker será implantado e receberá uma URL pública exclusiva.

7. Anote a URL pública

Após a implantação, anote a URL pública atribuída ao seu Worker. Essa é a URL que você usará como endpoint do webhook do seu bot do Telegram.

Código do Worker da Cloudflare:

const TELEGRAM_BOT_TOKEN = BOT_TOKEN;
const TELEGRAM_CHAT_ID = CHAT_ID;
const HELIUS_API_KEY=API_KEY;
const HELIUS_RPC_URL = `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`;

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  if (request.method === 'POST') {
    const requestBody = await request.json();
    console.log('Received POST request with body:', requestBody);

    //THIS IS FOR NFT UPDATES (comment this section out if you are doing something else)
    // Extract transaction description, timestamp, signature, and mint address
      // const NFTdescription = requestBody[0].description;
      // const NFTtimestamp = new Date(requestBody[0].timestamp * 1000).toLocaleString(); // Convert Unix timestamp to readable date-time
      // const NFTsignature = `https://solscan.io/tx/${requestBody[0].signature}`
      // const NFTmintAddress = requestBody[0].events.nft.nfts[0].mint;
      // const NFTimageUrl = await getAssetImageUrl(NFTmintAddress);// Get NFT image URL
      // // Construct the message
      // const messageToSendNFT =
      // `----NEW UPDATE---\n`+
      // `Description:\n${NFTdescription}\n` +
      // `Mint Address:\n${NFTmintAddress}\n` +
      // `Signature:\n${NFTsignature}\n` +
      // `Timestamp:\n${NFTtimestamp}`;
      // await sendToTelegramNFT(messageToSendNFT, NFTimageUrl); // Send to Telegram

    //THIS IS FOR TRANSFER UPDATES (comment this section out if you are doing something else)
    // Extract transaction description, timestamp, signature
      const Transferdescription = requestBody[0].description;
      const Transfertimestamp = new Date(requestBody[0].timestamp * 1000).toLocaleString(); // Convert Unix timestamp to readable date-time
      const Transfersignature = `https://xray.helius.xyz/tx/${requestBody[0].signature}`
      // Construct the message
      const messageToSendTransfer =
      `----NEW UPDATE---\n`+
      `Description:\n${Transferdescription}\n` +
      `Signature:\n${Transfersignature}\n` +
      `Timestamp:\n${Transfertimestamp}`;
      await sendToTelegramTransfer(messageToSendTransfer); // Send to Telegram

    return new Response('Logged POST request body.', {status: 200});
  } else {
    return new Response('Method not allowed.', {status: 405});
  }
}

// This function is used to send NFT Updates to the bot
async function sendToTelegramNFT(message, imageUrl) {
  const telegramUrl = `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendPhoto`;
  const response = await fetch(telegramUrl, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      chat_id: TELEGRAM_CHAT_ID,
      photo: imageUrl,
      caption: message,
      parse_mode: "HTML"
    }),
  });
  const responseData = await response.json();

  if (!response.ok) {
    console.error('Failed to send photo to Telegram:', responseData);
  }
}

//This function is used to send Transfer Updates to the Bot
async function sendToTelegramTransfer(message) {
  const telegramUrl = `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage`;
  const response = await fetch(telegramUrl, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      chat_id: TELEGRAM_CHAT_ID,
      text: message,
      parse_mode: "HTML"
    }),
  });
  const responseData = await response.json();

  if (!response.ok) {
    console.error('Failed to send message to Telegram:', responseData);
  }
}

//This function gets images associated to NFTs that are features in updates.
async function getAssetImageUrl(mintAddress) {
  const response = await fetch(HELIUS_RPC_URL, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-id',
      method: 'getAsset',
      params: {
        id: mintAddress,
      },
    }),
  });
  const { result } = await response.json();
  return result.content.links.image;
}

Configure um webhook da Helius

Os webhooks da Helius conectam as mudanças na blockchain Solana ao seu canal do Telegram. Neste exemplo, configurarei um webhook para monitorar todas as transações realizadas por uma determinada carteira.

1. Cadastre-se

Acesse dashboard.helius.dev e crie uma conta gratuita.

2. Crie um webhook

No painel, escolha criar um novo webhook. Você poderá selecionar o tipo: Raw, Enhanced, Discord ou Account. Para atualizações específicas e categorizadas, recomendamos 'Enhanced'. Ao escolher essa opção, especifique as atualizações que deseja receber, por exemplo, NFT_SALES ou NFT_LISTING.

Uma lista completa está disponível aqui.

3. Informe o link do Worker e o endereço Solana

Forneça o link do Worker da Cloudflare implantado. Informe também o endereço específico da conta Solana que deseja monitorar, que pode ser a carteira de um usuário ou uma lista de mints de uma coleção.

Como monitorar coleções de NFT (configuração de bot de vendas)

Se quiser monitorar uma coleção específica para receber atualizações quando algo acontecer com um NFT dessa coleção, você precisará adicionar todos os endereços de mint dos NFTs como contas no seu webhook. Para isso, use o endpoint de webhook da Helius para editar o webhook criado inicialmente. Depois de configurar tudo, você poderá monitorar vendas, listagens, lances, queimas e qualquer outra transação que envolva um NFT.

Primeiro, você precisará de uma lista de hashes/mints da coleção que deseja monitorar. Use o código abaixo para obter uma lista de mints com o DAS. Basta adicionar sua chave de API da Helius e substituir creatorAddress pelo endereço do primeiro criador verificado de um NFT. Para encontrar o primeiro criador verificado, acesse seu explorador de blocos da Solana favorito, procure os metadados e localize o endereço na seção de criadores:

Código do snapshot:

const fs = require('fs');
const url = `https://mainnet.helius-rpc.com/?api-key=`;

const getAssetsByCreator = async () => {
  let page = 1;
  let allMintAddresses = [];

  while (true) {
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: `my-id-page-${page}`,
        method: 'getAssetsByCreator',
        params: {
          creatorAddress: 'GFQBHxuNcAwYwHtEpggMwbH5kwV6Ne4JowHbLVfsMC6C',
          onlyVerified: true,
          page: page,
          limit: 1000
        },
      }),
    });

    const { result } = await response.json();

    // If there are no more items, break the loop
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }else{
      if (!result.items || result.items.length === 0) {
        break;
      }
    }

    // Extract mint addresses and add them to the list
    const mintAddresses = result.items.map(item => item.id);
    allMintAddresses.push(...mintAddresses);

    // Check if there are less than 1000 results to stop further requests
    if (result.items.length < 1000) {
      break;
    }

    page++;
  }

  // Join the addresses by comma
  const addressesString = allMintAddresses.join(',');
  console.log("All Mint Addresses: ", addressesString);
  fs.writeFileSync('addresses.json', JSON.stringify(allMintAddresses, null, 2));
};

getAssetsByCreator();

Depois disso, execute o script abrindo o terminal, acessando o diretório que contém o script e executando node snapshot.js. Isso criará nesse diretório um arquivo JSON chamado addresses.json. Outra opção é usar uma ferramenta como a ferramenta de snapshot da Magic Eden para obter uma lista de hashes.

Quando tiver uma lista de hashes, você poderá atualizar a lista de contas monitoradas pelo webhook. Para isso, use o endpoint de webhooks da Helius. O código abaixo facilita esse processo. Basta criar um novo arquivo JavaScript chamado webhookUpdate.js no mesmo diretório da sua lista de hashes e adicionar o código abaixo. Depois, edite o código para incluir sua chave de API da Helius e o ID do webhook, que pode ser encontrado no portal do desenvolvedor. Em seguida, edite o corpo da solicitação para que corresponda aos dados usados na criação do webhook. Portanto, se você optou por monitorar listagens e vendas de NFT, inclua essas opções. Não edite o campo accountAddresses, pois ele está configurado para usar a lista de hashes criada anteriormente.

Depois de fazer essas alterações, execute o script pelo terminal com node webhookUpdate.js. Após executar o código, você deverá receber uma confirmação no terminal.

webhookUpdate.js:

const fs = require('fs');

const editWebhook = async () => {
    try {
      // Read the JSON file
      const addresses = JSON.parse(fs.readFileSync('addresses.json', 'utf8'));
  
      const response = await fetch(
        "https://api.helius.xyz/v0/webhooks/?api-key=",
        {
          method: 'PUT',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            webhookURL: "",
            transactionTypes: ["NFT_LISTING","NFT_SALE"],
            accountAddresses: addresses,  // Use the addresses from the file
            webhookType: "enhanced"
          }),
        }
      );
      const data = await response.json();
      console.log({ data });
    } catch (e) {
      console.error("error", e);
    }
  };
  
  editWebhook();

Depois de atualizar o webhook, volte ao Worker da Cloudflare e edite o código para retornar detalhes específicos de NFTs. O código necessário já está incluído. Basta comentar a seção que envia atualizações de TRANSFER e remover o comentário da seção que envia atualizações de NFT.

Quando um evento monitorado acontecer on-chain, o webhook enviará uma atualização ao Worker da Cloudflare. Essa atualização estará no formato JSON e normalmente conterá muitas informações, como todas as contas envolvidas, as alterações em cada conta e dados relacionados ao tipo de evento. No código fornecido, extraímos as partes que consideramos importantes.

Se quiser personalizar a mensagem enviada ou alterar os dados extraídos da atualização do webhook, modifique a variável messageToSend. Você também pode monitorar outros eventos além de transferências e eventos de NFT. É possível alterar o código da Cloudflare para enviar todo o requestBody[0]. Isso encaminhará a resposta JSON completa do webhook para seu bot do Telegram, permitindo que você veja a estrutura da resposta. Depois, você poderá analisar e decidir quais seções deseja incluir na mensagem.

Com essa configuração, seu canal do Telegram se torna uma central de atualizações em tempo real da blockchain Solana, tudo graças aos webhooks da Helius. Esperamos que este guia tenha sido útil. Se você tiver dúvidas ou problemas, fale com a equipe no Discord ou no X.