Antes de Começar

Fizemos uma parceria com a Bonfida para tornar o trabalho com dados do SNS (Solana Naming Service ou serviço de nomes da Solana) significativamente mais fácil. Confira a nova API Bonfida no QuickNode Marketplace! Essa API desenvolvida pela Bonfida aproveita os pontos de extremidade do QuickNode para consultar o Solana Name Service:

• resolução .sol perfeita;
• busca por transações de registro;
• listagem de nomes de subdomínios;
• recuperação de domínios de detidos por carteiras.

Gratuito para todos os usuários do QuickNode no QuickNode Marketplace.

Visão Geral

Em um guia recente, abordamos How to Create Solana Naming Service Domains. Solana Naming Service ("SNS") é um programa prático em Solana que permite aos usuários criar um nome de domínio legível que pode ser usado no lugar de uma chave pública.

O Que Você Vai Fazer

Neste guia, você aprenderá como consultar nomes de domínio Solana usando Typescript e SPL Name Service SDK da Bonfida. Isso permitirá que você:

• Procure a carteira de um usuário pelo nome de domínio e;
• Procure o(s) nome(s) de domínio de um usuário pela carteira.

O Que Você Vai Precisar

• Nodejs (versão 16.15 ou superior) instalado;
• Experiência Typescript e ts-node instalados;
• Solana Web3;
• SPL Name Servise da Bonfida.

Configure Seu Ambiente

Para executar nossas consultas on-chain (na cadeia), usaremos Nodejs. Abra o editor de código de sua preferência e crie um novo diretório de projeto em seu terminal com:

mkdir sns-example
cd sns-example

Crie name-search.ts. Usaremos isso como nossa aplicação principal para executar nossos scripts.

echo > name-search.ts

Inicialize seu projeto com o sinalizador “yes” para usar valores padrão para seu novo pacote:

yarn init --yes
#or
npm init --y

Instale as dependências da Solana Web3:

yarn add @solana/web3.js @bonfida/spl-name-service
#or
npm install @solana/web3.js @bonfida/spl-name-service

Seu ambiente deve ser parecido com isto:

Vamos configurar sua aplicação com todas as dependências necessárias. Abra name-search.ts e, nas linhas 1-2, importe as seguintes dependências:

import { Connection, PublicKey } from "@solana/web3.js";
import { getDomainKey, NameRegistryState, getAllDomains, performReverseLookup } from "@bonfida/spl-name-service";

As dependências @solana/web3.js nos permitirão criar uma conexão com a rede Solana e obter a chave pública de um endereço de carteira.

As importações @bonfida/spl-name-service nos ajudarão a consultar domínios .sol (explicaremos isso na seção subsequente).

Muito bem, você está pronto para começar.

Configure Seu Ponto de Extremidade do QuickNode

Para desenvolver em Solana, você precisará de um ponto de extremidade de API para se conectar à rede. Você pode usar nós públicos ou implantar e gerenciar sua própria infraestrutura. No entanto, se desejar tempos de resposta 8x mais rápidos, você pode deixar o trabalho pesado conosco. Veja por que mais de 50% dos projetos em Solana escolhem o QuickNode e inscreva-se para uma conta gratuita aqui. Você precisará usar um ponto de extremidade da rede principal para consultar os nomes de domínio Solana dos usuários. Copie o link do provedor HTTP:

Na linha 4 de name-search.ts, adicione o seguinte código, substituindo QUICKNODE _ RPC pelo link do seu provedor HTTP:

const QUICKNODE_RPC = 'https://example.solana-mainnet.quiknode.pro/000000/';//replace with your HTTP Provider from https://www.quicknode.com/endpoints
const SOLANA_CONNECTION = new Connection(QUICKNODE_RPC);

Pesquisar Proprietário do Domínio .SOL

Vamos começar criando uma nova função async, getPublicKeyFromSolDomain, que usaremos para encontrar o proprietário da carteira de um determinado domínio .sol. Na linha 7 de name-search.ts, adicione:

async function getPublicKeyFromSolDomain(domain: string):Promise<string>{
    const { pubkey } = await getDomainKey(domain);
    const owner = (await NameRegistryState.retrieve(SOLANA_CONNECTION, pubkey)).registry.owner.toBase58();
    console.log(`The owner of SNS Domain: ${domain} is: `,owner);
    return owner;
}

Nossa função aceita como parâmetro uma string, domain, que será o nome de domínio que queremos consultar (com ou sem a extensão ".sol"). Encontrar o proprietário do domínio é um processo de duas partes:

1. Identifique a chave pública associada ao domínio (é como se fosse o endereço de cunhagem de um NFT). Fazemos isso acima usando a função getDomainKey e passando nosso parâmetro domain. Estamos procurando especificamente a chave pubkey do objeto retornado.
2. Recupere o endereço do proprietário do registro de nomes. Fazemos isso invocando o método retrieve na classe NameRegistryState. O Registro de Nomes armazena informações sobre o nome de domínio na cadeia. O método retrieve retornará um objeto que inclui o registro, que contém a chave pública do proprietário (obtida chamando .registry.owner.toBase58()).

Depois de obter o endereço do proprietário, registramos e retornamos os resultados.

Pesquisa Reversa: Encontre Todos os Domínios Pertencentes a uma Carteira

Crie uma nova função abaixo de getPublicKeyFromSolDomain (linha 14 para nós) que aceite uma string de endereço de carteira e retorne um array de strings (para contabilizar usuários que possuem vários domínios Solana).

async function getSolDomainsFromPublicKey(wallet: string):Promise<string[]>{
    const ownerWallet = new PublicKey(wallet);
    const allDomainKeys = await getAllDomains(SOLANA_CONNECTION, ownerWallet);
    const allDomainNames = await Promise.all(allDomainKeys.map(key=>{return performReverseLookup(SOLANA_CONNECTION,key)}));
    console.log(`${wallet} owns the following SNS domains:`)
    allDomainNames.forEach((domain,i) => console.log(` ${i+1}.`,domain));
    return allDomainNames;
}

Primeiro, obtemos a PublicKey da carteira que passamos como nosso parâmetro e, em seguida, usamos a função getAllDomains da Bonfida para buscar a PublicKey (chave pública) de todos os domínios pertencentes a essa carteira e armazenar os valores em allDomainKeys. Em seguida, usamos Promise.all para executar performReverseLookup para cada key (chave) armazenada em allDomainKeys. A função performReverseLookup resolverá o domínio .sol para a chave pública associada que passamos para ela. Como usamos Promise.all, nossa fórmula retornará um array de cada nome de domínio pertencente à carteira.

Depois de obter os domínios da carteira, percorremos o array e registramos cada nome de domínio.

Quase pronto. Bom trabalho!

Execute seu Código

Vamos declarar nossas consultas de pesquisa e chamar nossas funções. Na linha 23 de name-search.ts, cole:

//Exemplos para nossa pesquisa. Você pode substituir estes pela sua própria carteira ou consultas do Solana Naming Service.
const DOMAIN_TO_SEARCH = 'bonfida';
const WALLET_TO_SEARCH = 'E645TckHQnDcavVv92Etc6xSWQaq8zzPtPRGBheviRAk'; 

getPublicKeyFromSolDomain(DOMAIN_TO_SEARCH);
getSolDomainsFromPublicKey(WALLET_TO_SEARCH);

Incluímos alguns exemplos de consultas nas variáveis ​​DOMAIN_TO_SEARCH e WALLET_TO_SEARCH, mas sinta-se à vontade para substituí-las por qualquer carteira ou domínio que você preferir pesquisar.

Finalmente, chamamos ambas as funções que criamos e passamos nossas variáveis ​​de pesquisa como parâmetros. Incluímos todo o nosso exemplo de código no Github aqui.

Agora, vamos executá-lo! Volte para o terminal e digite:

ts-node name-search.ts

Você vê algo assim?

Bom trabalho!

Aplique suas Habilidades

Agora você tem as ferramentas para executar consultas na cadeia para encontrar proprietários de domínios ou domínios mantidos por uma carteira. Você pode aplicar esses mesmos conceitos ao seu próprio dApp Solana para melhorar a experiência dos usuários. Ainda não construiu um dApp? Consulte nosso guia Guide: How to Connect Users to Your dApp with the Solana Wallet Adapter and Scaffold.

Se você ainda não tem um domínio .sol e deseja adquirir um, confira nosso guia Guide: How to Create Solana Naming Service Domains.

Quer ajuda com este guia? Encontre-nos no Discord ou entre em contato conosco através do Twitter.

Nós amamos <3 feedbacks! Se você tiver algum comentário ou dúvida sobre este guia, informe-nos. Adoraríamos ouvir de você!

Este artigo foi escrito por Aaron Milano, e traduzido por Isabela Curado Nehme. Seu original pode ser lido aqui.