Como Começar com o Desenvolvimento de Aplicativos na Blockchain Solana

Qualquer desenvolvedor, com as ferramentas certas, pode começar com o desenvolvimento de aplicativos na blockchain Solana. Ao optar por uma das principais ferramentas de desenvolvimento da Solana, a API da Solana, pequenos trechos de código realizam todo o trabalho de backend relacionado à blockchain. Aqui está um exemplo da API em ação, buscando os saldos de uma carteira:

@app.post("/getWalletbalance")
def getWalletbalance():
       body = request.json
      params = {
          "address": body["address"],
          "network": body["network"]
          }
      result = sol_api.account.balance(
          api_key= moralis_api_key,
          params = params
      )
      return result

O método sol_api.account.balance é apenas um dos métodos poderosos no conjunto da API Solana-Moralis. Neste artigo, mostraremos como implementá-los facilmente, o que é a chave para um desenvolvimento fácil de aplicativos na blockchain Solana. Se isso lhe interessar, certifique-se de criar sua conta gratuita no Moralis e acompanhar o tutorial!

Visão Geral

No artigo de hoje, vamos nos concentrar primeiro em um tutorial de desenvolvimento de aplicativos na blockchain Solana que seja amigável para iniciantes. Este tutorial ensinará como trabalhar facilmente com a API da Solana. Usando nosso dapp existente na Solana, demonstraremos como fazer a transição do backend do NodeJS para o Python sem afetar o frontend do JavaScript. Além do ponto de extremidade (endpoint) usado acima, este tutorial implementa todo o conjunto de métodos da API da Solana.

A segunda metade deste guia irá ajudá-lo a entender melhor a Solana e o desenvolvimento de aplicativos na blockchain Solana. Também é aqui que veremos mais de perto os serviços e recursos de desenvolvimento da blockchain Solana. Dessa forma, você terá a chance de aprender mais sobre a API da Solana. Como resultado, você será capaz de determinar em quais pontos de extremidade você deve se concentrar para seus feitos de desenvolvimento de aplicativos na blockchain Solana.

Desenvolvimento de Aplicativos na Blockchain Solana com a API da Solana

Como mencionado e ilustrado acima, este tutorial de desenvolvimento de aplicativos na blockchain Solana se concentra em mudar o backend do NodeJS para o Python sem afetar o frontend, que é um aplicativo JavaScript simples que permite aos usuários utilizar o poder dos pontos de extremidade da API da Solana:

Observação: você pode clonar o script completo do frontend - index.html - no GitHub. Caso queira uma explicação rápida do código do nosso exemplo de dapp de frontend, confira o vídeo no topo deste artigo, a partir de 1:05.

Para usar o Python para implementar a API da Solana, você precisa concluir algumas configurações iniciais, e é exatamente isso que a próxima seção ajudará você a fazer.

Configurando o Python e os Serviços de Desenvolvimento da Blockchain Solana

Antes de prosseguir, certifique-se de ter seu projeto Solana API demo pronto. Este projeto deve conter uma pasta frontend, que inclui o script index.html mencionado acima, presumindo que você clonou nosso código. Se você também clonou o código do backend em NodeJS, então você deve ter uma pasta backend em seu projeto:

Seguindo em frente, comece criando uma pasta python-backend. Você pode fazer isso manualmente ou através do seguinte comando:

mkdir python-backend

Em seguida, dê cd nesta nova pasta executando o comando abaixo:

cd python-backend

Em seguida, você precisa criar um novo ambiente virtual que suporte a instalação e o uso de módulos Python. Como tal, insira isso em seu terminal:

python3 -m venv venv

Você também precisa ativar seu ambiente virtual:

Execute o seguinte comando activate:

source venv/bin/activate

Em seguida, você precisa instalar os módulos necessários. O comando abaixo irá instalar o Flask, o Flask CORS, o Moralis e o dotenv do Python:

pip install flask flask_cors moralis python-dotenv

Com seu ambiente virtual ativado e os módulos instalados, você pode prosseguir com a configuração das variáveis de ambiente. Portanto, certifique-se de obter sua chave de API Web3 do Moralis, pois ela é a porta de entrada para o desenvolvimento de aplicativos na blockchain Solana com a API Solana-Moralis. Então, se você ainda não criou sua conta no Moralis, faça isso agora. Com sua conta, você pode acessar sua área de administração. Lá, você pode obter sua chave de API Web3 nas duas etapas a seguir:

Crie um novo arquivo .env ou copie-o da pasta backend do NodeJS e preencha a variável MORALIS_API_KEY com a chave de API obtida acima.

Como usar os Serviços de Desenvolvimento da Blockchain Solana com Python

Para implementar os pontos de extremidade da API Solana-Moralis com Python, crie um novo arquivo index.py dentro da pasta python-backend. Em seguida, importe os pacotes instalados acima na parte superior desse script:

from flask import Flask, request
from flask_cors import CORS
from moralis import sol_api
from dotenv import dotenv_values

Este script deve buscar sua chave de API Web3, que você armazena no arquivo .env:

config = dotenv_values(".env")
moralis_api_key = config.get("MORALIS_API_KEY")

Na próxima linha, use o Flask para definir uma variável app e inclua CORS:

app = Flask(__name__)
CORS(app)

Como você está substituindo nosso backend em NodeJS que roda na porta 9000, certifique-se de que o backend Python foque na mesma porta. Caso contrário, você precisará modificar o URL no seu frontend. Essas são as linhas de código que cuidarão disso:

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=9000)

Seguindo em frente com o seu script index.py, é hora de começar a implementar os pontos de extremidade da API Solana-Moralis: “Get native balance by wallet” (Obter saldo nativo por carteira), “Get token balance by wallet” (Obter saldo de tokens por carteira), “Get portfolio by wallet” (Obter portfólio por carteira), “Get token price” (Obter preço do token), “Get NFTs by wallet” (Obter NFTs por carteira) e “Get NFT metadata” (Obter metadados do NFT).

A maneira mais simples de usar esses serviços de desenvolvimento da blockchain Solana é copiar as linhas de código apropriadas das páginas de referência da API da Solana. Ao trabalhar com Python, você precisa selecionar essa linguagem de programação. Aqui está a página de referência do ponto de extremidade "Get native balance by wallet":

Implementando Pontos de Extremidade da API da Solana

Volte para o seu script index.py para definir rotas e funções para cada ponto de extremidade abaixo da linha CORS(app). No que diz respeito ao ponto de extremidade "get native balance by wallet", as linhas de código da introdução já realizam a tarefa:

@app.post("/getWalletbalance")
def getWalletbalance():
       body = request.json
       params = {
          "address": body["address"],
          "network": body["network"]
          }
       result = sol_api.account.balance(
          api_key= moralis_api_key,
          params = params
       )
       return result

A linha superior - @app.post("/getWalletbalance") - cria uma nova rota em Python. Com def getWalletbalance():, você define a função para o ponto de extremidade em questão. Usando body = request.json, você lê os dados JSON que o Moralis busca e analisa para você. Em seguida, você define os parâmetros do ponto de extremidade ("address" e "network"). Usando o método sol_api.account.balance com os parâmetros e sua chave de API Web3, você armazena os dados na variável result. Finalmente, você usa return result para retornar os resultados.

Trechos de Código Python para Todos os Pontos de Extremidade da API da Solana

Quando se trata de outros pontos de extremidade da API da Solana, os mesmos princípios se aplicam. Basicamente, você pode usar as mesmas linhas de código apresentadas anteriormente. No entanto, você precisa mudar as rotas, os nomes das funções e os métodos para corresponder ao ponto de extremidade. Para economizar tempo, você pode encontrar os trechos de código para os cinco pontos de extremidade restantes da API da Solana abaixo:

• Implementando o ponto de extremidade getTokenbalance:

@app.post("/getTokenbalance")
def getTokenbalance():
      body = request.json
      params = {
          "address": body["address"],
          "network": body["network"]
          }
      result = sol_api.account.get_spl(
          api_key= moralis_api_key,
          params = params
      )
      return result

• Implementando o ponto de extremidade getNfts:

@app.post("/getNfts")
def getNfts():
      body = request.json
      params = {
          "address": body["address"],
          "network": body["network"]
          }
      result = sol_api.account.get_nfts(
          api_key= moralis_api_key,
          params = params
      )
      return result

• Implementando o ponto de extremidade getPortfolio:

@app.post("/getPortfolio")
def getPortfolio():
      body = request.json
      params = {
          "address": body["address"],
          "network": body["network"]
          }
      result = sol_api.account.get_portfolio(
          api_key= moralis_api_key,
          params = params
      )
      return result

• Implementando o ponto de extremidade getNFTMetadata:

@app.post("/getNFTMetadata")
def getNFTMetadata(): 
      body = request.json
      params = {
          "address": body["address"],
          "network": body["network"]
          }
      result = sol_api.nft.get_nft_metadata(
          api_key= moralis_api_key,
          params = params
      )
      return result

• Implementando o ponto de extremidade getTokenPrice:

@app.post("/getTokenPrice")
def getTokenPrice():
      body = request.json
      params = {
          "address": body["address"],
          "network": body["network"]
          }
      result = sol_api.token.get_token_price(
          api_key= moralis_api_key,
          params = params
      )
      return result

Observação: o script “index.py” completo está esperando por você em nosso repositório do GitHub.

Explorando os Resultados do Desenvolvimento de Seu Aplicativo na Blockchain Solana

Verifique se você está dentro da pasta python-backend. Em seguida, use o seguinte comando para executar index.py:

python3 index.py

O comando acima inicia o seu backend na porta 9000. Para acessar o poder do seu backend, você também precisa iniciar o seu frontend. Você pode fazer isso com a extensão "Live Server" no Visual Studio Code (VS Code). Basta clicar com o botão direito do mouse em index.html e selecionar a opção "Abrir com (Open with) Live Server".

Por fim, você pode se divertir com o seu frontend dapp e testar todos os pontos de extremidade da API da Solana. Os seguintes são nossos exemplos para as opções "Get Native Balance by Wallet" e "Get Token Balance by Wallet":

• Demonstração de "Get Native Balance by Wallet":

• Demonstração de “Get Token Balance by Wallet”:

Explorando o Desenvolvimento de Aplicativos na Blockchain Solana

Se você gosta de colocar a mão na massa, provavelmente gostou do tutorial acima e criou sua própria instância do exemplo de aplicativo da blockchain Solana. No entanto, é importante que você entenda os conceitos teóricos por trás do desenvolvimento de aplicativos na blockchain Solana. Então, vamos primeiro responder a pergunta "O que é a Solana?"

O que é a Solana?

A Solana é uma blockchain programável e não compatível com a EVM (Ethereum Virtual Machine). É pública e de código aberto (open source). A Solana suporta o desenvolvimento de contratos inteligentes (programas implantados na cadeia), criação de tokens e todos os tipos de dapps (aplicativos descentralizados). Como todas as principais cadeias programáveis, a Solana utiliza sua moeda nativa, o "SOL", para fornecer segurança de rede por meio do consenso híbrido de staking em DeFi da Solana. O SOL também é usado para cobrir taxas de transação na Solana. Como a maioria das criptomoedas, o SOL pode ser usado para transferir valor na rede Solana.

Raj Gokal e Anatoly Yakovenko lançaram a Solana em 2017. Ambos os desenvolvedores ainda estão profundamente envolvidos com a Solana por meio da Solana Labs, que é uma empresa de tecnologia que constrói ferramentas, produtos e implementações de referência para expansão no ecossistema Solana.

Observação: para saber mais sobre a Solana, use o link "O que é a Solana?" acima.

O que é o Desenvolvimento na Blockchain Solana?

O desenvolvimento na blockchain Solana é qualquer tipo de atividade de desenvolvimento que gira em torno da blockchain Solana. Em sua essência, refere-se à criação e melhoria contínua (implementação de atualizações) da própria blockchain Solana. É nisso que a equipe principal e a comunidade da Solana focam.

Por outro lado, o desenvolvimento na blockchain Solana também pode se referir à construção de contratos inteligentes Solana e à criação de dapps que interagem com essa popular rede descentralizada. Para a maioria dos desenvolvedores, isso é muito mais emocionante e acessível, especialmente quando eles usam os serviços, recursos e ferramentas certas de desenvolvimento na blockchain Solana.

Qual Linguagem de Programação é Usada para o Desenvolvimento na Solana?

O Rust é a linguagem de programação que a Solana adota para escrever programas na cadeia. Portanto, se você quiser codificar seus contratos inteligentes exclusivos e avançados para a Solana, precisará ter habilidades em Rust. Como alternativas ao Rust, você também pode criar programas na cadeia da Solana com C ou C++. No entanto, se você quiser criar NFTs na Solana, pode fazer isso sem habilidades avançadas de programação, graças a algumas ferramentas de desenvolvimento da Solana (mais sobre isso abaixo).

Quando se trata de desenvolvimento de aplicativos na blockchain Solana, você já aprendeu que o NodeJS e o Python podem fazer o trabalho. Além disso, o Moralis também suporta cURL, Go e PHP. Como tal, você pode usar diferentes linguagens de programação legadas para construir aplicativos descentralizados incríveis na Solana.

Serviços e Recursos de Desenvolvimento na Blockchain Solana

A API Solana-Moralis fornece os melhores serviços de desenvolvimento na blockchain Solana. Eles estão disponíveis nos seguintes pontos de extremidade de dados Web3, que podem ser usados com todas as principais linguagens/frameworks de programação:

• Pontos de extremidade de API - Saldos:
  • Get native balance by wallet
  • Get token balance by wallet
  • Get portfolio by wallet
• Pontos de extremidade de API - Tokens:
  • Get token price
• Pontos de extremidade de API - NFTs:
  • Get NFTs by wallet
  • Get NFT metadata

Com as APIs acima que suportam a rede principal e a rede de desenvolvimento da Solana, é possível buscar metadados de NFTs, portfólios de carteiras, saldos de tokens e preços de tokens SPL. Assim, é possível usar a API Solana-Moralis de inúmeras maneiras. Por exemplo, é possível construir mercados de NFTs, feeds de preços de tokens, dapps de portfólio e muito mais.

Além dos dados Web3, todos os dapps também precisam de autenticação Web3 de fácil utilização. É aqui que a API de autenticação do Moralis entra em cena. Ela suporta a Ethereum e todas as principais cadeias compatíveis com a EVM, juntamente com a Solana. Com os pontos de extremidade “Request challenge” (Solicitar desafio) e “Verify challenge” (Verificar desafio), é possível incorporar logins Web3 perfeitamente integrados para todas as principais carteiras da Solana em seus dapps. Se você não sabe como responder à pergunta "O que é uma carteira da Solana?", explore nosso artigo sobre esse assunto.

Quando se trata de criar programas na cadeia da Solana, exemplos de contratos inteligentes da Solana podem economizar muito tempo. Além disso, se você quiser criar NFTs nesta rede, as ferramentas de criação de NFTs da Solana simplificam muito as coisas, como a Candy Machine do Metaplex. Se você decidir se aprofundar no desenvolvimento da Solana, também é importante se familiarizar com os programas nativos da Solana Labs e a Biblioteca de Programas da Solana (SPL).

No entanto, uma torneira (faucet) confiável da rede de testes da Solana fornecerá SOL de teste para que você possa testar seus dapps e contratos inteligentes na rede de desenvolvimento da Solana.

Como começar com o Desenvolvimento de Aplicativos na Blockchain Solana – Resumo

Nós percorremos um longo caminho no artigo de hoje. Na primeira metade deste guia de desenvolvimento de aplicativos na blockchain Solana, você teve a oportunidade de seguir nosso tutorial e usar o Python para criar um exemplo de backend para um aplicativo Solana. Quanto à segunda parte do artigo de hoje, garantimos que você saiba o que é a Solana e o que envolve o desenvolvimento na blockchain Solana. Você também aprendeu que Rust é a linguagem de programação principal para criar contratos inteligentes na Solana. Por fim, abordamos os melhores serviços, recursos e ferramentas para o desenvolvimento na blockchain Solana. Assim, você está pronto para começar a construir aplicativos incríveis na Solana!

Se você tiver suas próprias ideias e as habilidades necessárias, use as informações obtidas aqui e junte-se à revolução Web3. No entanto, se precisar de mais prática ou outras ideias, certifique-se de explorar nossos tutoriais sobre a Solana, que o aguardam na documentação do Moralis, em nossos vídeos de desenvolvimento de blockchain e em nosso blog sobre criptomoedas. Esses também são meios para se explorar o desenvolvimento Web3 em outras blockchains líderes e aprender sobre outras ferramentas práticas. Ótimos exemplos são nossa calculadora de gwei para ETH, torneira Goerli, torneira da rede de testes Sepolia e lista de bibliotecas Web3. Se você não está fixado na Solana, pode até mesmo usar alternativas de APIs de Notificações, para ouvir endereços de carteira e de contratos inteligentes na blockchain. Ou então, certifique-se de conferir nosso guia sobre como criar seu próprio token ERC-20. Essas são apenas algumas das inúmeras opções que o Moralis oferece.

Também vale a pena mencionar que o mundo blockchain oferece ótimas oportunidades de emprego, e se tornar certificado em blockchain pode ajudá-lo a conseguir sua posição dos sonhos no mundo cripto. Se isso lhe interessa, considere se matricular na Moralis Academy! Recomendamos começar com os fundamentos de blockchain e do Bitcoin.

Artigo original publicado por Moralis. Traduzido por Paulinho Giovannini.