A Web3 é uma nova infraestrutura da Internet que utiliza redes descentralizadas e distribuídas para possibilitar interações peer-to-peer sem a necessidade de intermediários. Ela é fundamentada na tecnologia blockchain, que é um livro-razão compartilhado que oferece altos níveis de segurança, transparência e imutabilidade.
A tecnologia blockchain proporciona muitos benefícios por meio de seu design altamente seguro, mas as blockchains têm uma notável limitação funcional comumente conhecida como "problema do oráculo blockchain". Essencialmente, as redes blockchain são sistemas fechados por natureza e não podem acessar nativamente dados ou cálculos do mundo real. O problema do oráculo tem limitado significativamente os tipos de aplicativos que os desenvolvedores de blockchain podem criar, já que a maioria dos casos de uso avançados requer algum tipo de dado ou cálculo do mundo real.
A Chainlink foi criada para resolver o problema do oráculo e conectar todos os dados e sistemas do mundo às blockchains. As capacidades altamente seguras de dados e cálculos da Chainlink impulsionaram o crescimento do "DeFi" ou finanças descentralizadas (possibilitando mais de US$ 7 trilhões em valor de transação desde o início de 2022), jogos, NFTs e muitas outras verticais da Web3.
Neste tutorial, mostraremos como usar as Funções da Chainlink, uma plataforma de computação serverless descentralizada que pode ajudá-lo a conectar as APIs do mundo às blockchains. Você aprenderá a construir uma aplicação descentralizada da Web3 (ou dApp, em resumo) que atua como um acordo digital entre uma gravadora e um artista musical.
Contratos Inteligentes para Artistas Musicais
A lógica para o acordo digital define quanto um artista deve ser pago por transmissão de música e é armazenada em um contrato inteligente implantado na blockchain.
Um "contrato inteligente" é um programa simples que contém lógica para determinar qual saída deve fornecer, incluindo transferência de valor, executada em centenas ou milhares de nós em uma blockchain, fornecendo níveis extremamente altos de segurança e execução garantida.
Quando esse programa for executado, ele usará as Funções da Chainlink para chamar uma API e obter o número de transmissões para o artista, além de interagir com a API de e-mail do Twilio SendGrid para enviar um e-mail ao artista sobre seu pagamento. Neste caso, as Funções da Chainlink atuam como uma camada intermediária entre o programa implantado na blockchain e a Web externa, realizando o "trabalho pesado" computacional de maneira econômica, sem perda das garantias criptográficas que a blockchain oferece.
Pré-requisitos
Antes de começar, será necessário configurar algumas contas gratuitas e instalar alguns softwares, caso ainda não o tenha feito:
- Cadastre-se no beta da Chainlink Functions.
- Uma conta gratuita no Twilio Sendgrid.
- Um endereço de e-mail do remetente que você controle, verificado pelo Twilio (observação: é melhor usar um provedor de serviço de e-mail público como o Gmail ou Hotmail, e este passo pode levar mais de um dia).
- Node.js v16+, NPM e Git.
- Uma carteira Web3 configurada em seu navegador, como o MetaMask.
- URLs RPC gratuitas para acesso à blockchain por meio do Infura ou Alchemy.
Às vezes, essas etapas podem levar um dia ou dois, então não se frustre - apenas marque este blog.
Quando estiver configurado, vamos começar!
Configurar Seu Ambiente de Desenvolvimento
Podemos começar clonando o Repositório de Exemplo da Chainlink Functions em sua máquina de desenvolvimento. Este é um repositório de código pré-empacotado que contém todo o código necessário para implantar e executar este exemplo. Reserve alguns minutos para ler o README também. Depois de clonado, use o terminal para navegar até o diretório do seu projeto e instale todas as dependências com:
npm install
Você também deseja configurar sua carteira Web3 (por exemplo, Metamask) e garantir que ela esteja financiada com os tokens corretos - neste caso, você precisará de algum ETH e LINK. Você precisa usar esta conta de carteira e os tokens nela para pagar a transmissão e a submissão de transações para a rede blockchain. Você pode pensar nisso como um passe de viagem que você precisa manter financiado para acessar o transporte público.
Você pode usar a rede de teste Sepolia do Ethereum, a rede de teste Polygon Mumbai ou a rede de teste Avalanche Fuji para implantar este código. Estas são cópias das redes de produção que os desenvolvedores usam para construir e testar aplicativos. Neste post, usaremos a rede Sepolia da Ethereum.
Você também precisará obter acesso à rede Sepolia adicionando-a à sua carteira Web3 do MetaMask. A maneira mais fácil de fazer isso é ir para o site Chainlist e pressionar o botão "Adicionar ao MetaMask":
Alternativamente, você pode se inscrever para obter sua própria chave de API gratuita por meio de um provedor externo de RPC, como Infura ou Alchemy, e depois adicionar manualmente a rede à sua carteira MetaMask. Você também precisará dessas chaves ao configurar as variáveis de ambiente em seu código.
O próximo passo, conforme mencionado acima, é garantir que você tenha financiado sua carteira com ETH e LINK da Sepolia. O ETH é necessário como "gas" para transmitir e enviar transações para a rede. LINK é necessário para pagar à rede oráculo da Chainlink pelos serviços prestados ao atender suas solicitações de acesso às APIs. Você pode adicionar o token LINK à lista de ativos de sua carteira MetaMask indo aqui e clicando em "Adicionar à Carteira".
Agora que você está pronto em termos de conexão com a rede e fundos para realizar ações nela, podemos prosseguir para o código!
Configurar Suas Variáveis de Ambiente
Você precisará usar variáveis de ambiente para armazenar segredos de API e outras informações sensíveis fora do código do seu repositório.
As variáveis de ambiente necessárias para este aplicativo de exemplo são:
MUMBAI_RPC_URL // Obtenha a partir do Alchemy ou Infura como parte das etapas de configuração
GITHUB_API_TOKEN= // veja as instruções seguintes para obter isso.
# E
PRIVATE_KEY // obtenha isso da Metamask conforme instruído na configuração
SECOND_PRIVATE_KEY // obtenha isso da Metamask conforme instruído na configuração
# E
# Chaves da API wrapper do Spotify [veja: https://doc.api.soundcharts.com/api/v2/doc]
SOUNDCHART_APP_ID="soundcharts"
SOUNDCHART_API_KEY="soundcharts"
# SERVIÇO DE E-MAIL
TWILIO_API_KEY // Da documentação da API Twilio/Sengrid
ARTIST_EMAIL // um endereço de e-mail que você pode verificar
VERIFIED_SENDER // seu endereço de e-mail verificado pelo Twilio. Use Gmail, Yahoo, etc., pois o ProtonMail frequentemente tem problemas de acesso.
Para práticas recomendadas de segurança, desaconselhamos o uso de arquivos .env. Em vez disso, usaremos o pacote env-enc que foi enviado com o repositório para criptografar todas as suas chaves em repouso, em sua máquina, com uma senha que você fornece.
A chave da API Twilio pode ser obtida nas configurações depois de fazer login na sua conta SendGrid. Suas chaves privadas da carteira (você precisa de duas para este exemplo!) podem ser extraídas da sua carteira MetaMask Web3. As variáveis do Soundchart podem ser obtidas na documentação da API Soundcharts. Observação: para este aplicativo de exemplo, usaremos dados de API isolados, que são uma captura e não estão vinculados a dados em tempo real.
Para criptografar suas variáveis de ambiente, você precisará fazer o seguinte:
- Configurar seu token de acesso privado do GitHub Gist.
- Configurar o pacote
env-enccom uma senha que ele pode usar para criptografar suas variáveis de ambiente. - Definir cada variável de ambiente na ferramenta para que as variáveis de ambiente criptografadas sejam armazenadas na raiz do seu projeto no arquivo
.env.enc, que não é legível por humanos.
Você pode realizar todos os passos acima seguindo as instruções no README, na seção Setup & Environment Variables.
Configurar o Aplicativo de Exemplo
O exemplo de aplicativo do contrato do artista gravado usa ferramentas de linha de comando (CLI) construídas sobre a CLI do Hardhat.
Se você está se perguntando como as ferramentas CLI do Hardhat sabem quais dados passar para nosso contrato inteligente, isso está no arquivo ./Functions-request-config.js.
O objeto requestConfig contém todos os dados necessários para executeRequest() no contrato inteligente RecordLabel.sol e também outros dados necessários para as ferramentas CLI processarem dados retornados da rede de oráculos descentralizada. Seu objeto de configuração de solicitação no arquivo de configuração tem as seguintes propriedades:
const requestConfig = {
// localização do código-fonte (somente Inline é suportado atualmente)
codeLocation: Location.Inline,
// localização dos segredos (Inline ou Remoto)
secretsLocation: Location.Remote,
// linguagem de código (apenas JavaScript é suportado atualmente)
codeLanguage: CodeLanguage.JavaScript,
// string contendo o código-fonte a ser executado. Caminho relativo usado.
source: fs.readFileSync("./Twilio-Spotify-Functions-Source-Example.js").toString(),
// os segredos podem ser acessados dentro do código-fonte com secrets.varName (ou seja, secrets.apiKey)
secrets: {},
// chave da carteira ETH usada para assinar segredos, impedindo o acesso por terceiros
walletPrivateKey: process.env["PRIVATE_KEY"],
// args (array de strings) podem ser acessados dentro do código-fonte com args[index] (ou seja, args[0])
// artistID é o Argumento fornecido externamente. Detalhes do artista são armazenados no contrato.
// args em sequência são: ArtistID, nome do artista, última contagem de ouvintes, e-mail do artista
args: ["ca22091a-3c00-11e9-974f-549f35141000", "Tones&I", "14000000", process.env.ARTIST_EMAIL, process.env.VERIFIED_SENDER], // TONES_AND_I, 14 milhões
// tipo esperado do valor retornado
expectedReturnType: ReturnType.int256,
// URLs redundantes que apontam para segredos off-chain criptografados.
// Você *deve* gerar os seus próprios seguindo as instruções no README para Segredos off-chain
secretsURLs: [
"https://gist.githubusercontent.com/zeuslawyer/b307549406ad4c72b741efc5b1547332/raw/b977d4a9493faa17e4469cfdb01e260fec9c5df5/ETH.txt",
// "https://gist.githubusercontent.com/zeuslawyer/b307549406ad4c72b741efc5b1547332/raw/b977d4a9493faa17e4469cfdb01e260fec9c5df5/POLY"
],
// Objeto de segredos off-chain padrão usado pelo comando functions-build-offchain-secrets
globalOffchainSecrets: {
// Chaves API de nível DON
soundchartAppId: process.env.SOUNDCHART_APP_ID,
soundchartApiKey: process.env.SOUNDCHART_API_KEY,
twilioApiKey: process.env.TWILIO_API_KEY,
},
// Objetos de segredos off-chain por nó usados pelo comando functions-build-offchain-secrets
perNodeOffchainSecrets: [
{
soundchartAppId: process.env.SOUNDCHART_APP_ID,
soundchartApiKey: process.env.SOUNDCHART_API_KEY,
twilioApiKey: process.env.TWILIO_API_KEY,
},
// Chaves API de nível de nó
{
soundchartAppId: process.env.SOUNDCHART_APP_ID,
soundchartApiKey: process.env.SOUNDCHART_API_KEY,
twilioApiKey: "",
},
{
soundchartAppId: process.env.SOUNDCHART_APP_ID,
soundchartApiKey: process.env.SOUNDCHART_API_KEY,
twilioApiKey: "",
},
{
soundchartAppId: process.env.SOUNDCHART_APP_ID,
soundchartApiKey: process.env.SOUNDCHART_API_KEY,
twilioApiKey: "",
},
],
}
Explicação do Código
O repositório inclui contratos inteligentes Solidity que rodam em cadeias baseadas em EVM e código JavaScript que fornece ferramentas usando o framework de desenvolvimento de contratos inteligentes Hardhat.
O contrato inteligente de exemplo que contém a lógica para pagar ao artista da música está no arquivo ./contracts/sample-apps/RecordLabel.sol. Este contrato inteligente representa o contrato financeiro entre um Artist(artista) e a gravadora e acompanha metadados do artista, como a contagem de ouvintes para um determinado artista.
Para fins desta demonstração, criaremos uma stablecoin simulada chamada STC, que é um token ERC20 e é usada para pagar ao artista da música. Usaremos sua segunda conta da carteira MetaMask como a carteira do artista da música para os fins deste aplicativo de exemplo.
Para o contrato RecordLabel.sol, a funcionalidade chave está contida no método executeRequest() e no retorno de chamada fulfillRequest(). Esses dois métodos são a API para usar as Functions da Chainlink.
O executeRequest() recebe os seguintes argumentos tipados:
source stringsecrets bytes-
secretsLocation int(padrão 0 = inline, 1 = URI remoto para segredos) args string[]subscriptionId uint64-
gasLimit uint32(100.000 a um máximo de 300.000)
function executeRequest(
string calldata source,
bytes calldata secrets,
Functions.Location secretsLocation,
string[] calldata args, // args em sequência são: ArtistID, nome do artista, última contagem de ouvintes, e-mail do artista
uint64 subscriptionId,
uint32 gasLimit
) public onlyOwner returns (bytes32) {
Functions.Request memory req;
req.initializeRequest(Functions.Location.Inline, Functions.CodeLanguage.JavaScript, source);
if (secrets.length > 0) {
if (secretsLocation == Functions.Location.Inline) {
req.addInlineSecrets(secrets);
} else {
req.addRemoteSecrets(secrets);
}
}
if (args.length > 0) req.addArgs(args);
// Atualizar variáveis de armazenamento.
bytes32 assignedReqID = sendRequest(req, subscriptionId, gasLimit);
latestRequestId = assignedReqID;
latestArtistRequestedId = args[0];
return assignedReqID;
}
O JavaScript personalizado será o argumento source. Se esse código-fonte receber dados, isso estará em args. Segredos como chaves de API serão passados em secrets, e eles são criptografados para que não possam ser mal utilizados quando estiverem na blockchain pública.
Finalmente, passaremos um subscriptionId — isso se refere a uma assinatura de Functions da Chainlink, pois a execução de código pela rede de oráculos descentralizada Chainlink requer uma assinatura ativa e financiada para compensar o custo de execução de trabalhos para você. Mais uma vez, é como um passe de viagem que você mantém carregado, e toda vez que viaja, uma quantia é retirada do seu saldo.
Voltaremos às assinaturas um pouco mais tarde, mas por enquanto, entenda que essas entradas são tudo o que você precisa fornecer ao método executeRequest() para fazê-lo executar seu código-fonte na rede de oráculos descentralizada.
Agora, vamos considerar o tipo de código arbitrário que pode ser fornecido como parte do argumento source. Para o beta, apenas o código JavaScript (especificamente, NodeJS) é suportado. Para nosso contrato inteligente Artista/Gravadora, passamos o código que está no arquivo ./Twilio-Spotify-Functions-Source-Example.js.
Este código retira os argumentos passados para o método executeRequest() no parâmetro args — é assim que passamos argumentos para o nosso código personalizado. Em seguida, ele faz uma solicitação HTTP Get à API de música que nos fornece os números de streaming mais recentes para esse artista.
Se o artista aumentou a contagem de streams, enviamos uma solicitação de postagem HTTP à API de e-mail do Twilio SendGrid e passamos todos os detalhes necessários para enviar ao artista um e-mail emocionante de pagamento como este:
O código também calcula o aumento ou diminuição nas transmissões musicais do artista e calcula a quantidade de STC a ser paga ao artista. O código personalizado depende da biblioteca Functions, que é injetada no escopo global dentro do ambiente de execução remota de código (VM isolado) onde nosso JavaScript personalizado está sendo executado. Devemos usar esta biblioteca Functions para fazer solicitações HTTP, porque um contrato inteligente em execução em uma blockchain não pode acessar nativamente APIs off-chain.
Independentemente de um pagamento ser devido ao artista, retornamos a contagem mensal mais recente de transmissões para os nós oráculos, onde eles chegam independentemente a um consenso sobre os dados retornados e, em seguida, publicam esse resultado de volta à blockchain.
Quando nosso código JavaScript personalizado retorna dados ao nosso contrato inteligente consumidor, ele deve retornar os dados como um tipo NodeJS Buffer, que é como qualquer dado representado por uma sequência de bytes é codificado como bytes no NodeJS. Esses bytes podem então ser decodificados on-chain no contrato inteligente. Enquanto estiver em beta, o código JavaScript personalizado deve retornar strings ou integers (a lista de tipos de dados de retorno suportados está no README do repositório no nível superior). Novamente, usamos a biblioteca Functions injetada para codificar dados de retorno em Buffers.
Aqui é onde o método de retorno de chamada fulfillRequest() no contrato inteligente RecordLabel.sol entra em ação. Ele recebe os dados com os quais os nós oráculos descentralizados da Chainlink chegaram a um consenso, e esses dados são usados para calcular o pagamento devido ao artista e fazer esse pagamento ao artista sem a necessidade de intervenção humana.
function fulfillRequest(bytes32 requestId, bytes memory response, bytes memory err) internal override {
latestError = err;
emit OCRResponse(requestId, response, err);
// Lógica de pagamento do contrato do artista aqui.
// O artista recebe uma taxa fixa para cada 1000 ouvintes mensais ativos adicionais.
bool nilErr = (err.length == 0);
if (nilErr) {
string memory artistId = latestArtistRequestedId;
(int256 latestListenerCount, int256 diffListenerCount) = abi.decode(response, (int256, int256));
if (diffListenerCount <= 0) {
// Nenhum pagamento devido.
return;
}
// Pague ao artista em 'artistData[latestArtistRequestedId].walletAddress'.
uint8 stcDecimals = IStableCoin(s_stc).decimals();
// O artista recebe 1 STC para cada 10000 transmissões adicionais.
uint256 amountDue = (uint256(diffListenerCount) * 1 * 10 ** stcDecimals) / 10000;
console.log("\nQuantidade Devida Ao Artista: ", amountDue);
pagarArtista(artistId, amountDue);
// Atualizar Mapeamento do Artista.
artistData[artistId].lastListenerCount = uint256(latestListenerCount);
artistData[artistId].lastPaidAmount = amountDue;
artistData[artistId].totalPaid += amountDue;
}
}
Este trecho de código executa a lógica de pagamento ao artista com base nos dados obtidos dos nós oráculos da Chainlink. Se nenhum erro for retornado e a contagem de ouvintes aumentar, o pagamento é calculado e efetuado ao artista, e as informações do artista são atualizadas no mapeamento de artistas no contrato inteligente.
Implantando a Aplicação
Agora que temos uma boa ideia de como o código está estruturado, vamos executá-lo! Os seguintes passos estão listados no arquivo /README do repositório.
Antes de implantarmos o contrato inteligente RecordLabel.sol na rede de teste Sepolia, vamos compilar o código e executá-lo no Functions Simulator que vem junto com o repositório. Isso simulará o que acontecerá sem realmente executar e criar transações. Mais documentação sobre os comandos da CLI pode ser encontrada no README, mas podemos percorrer os principais passos aqui juntos.
Primeiro, execute o simulador para compilar os contratos inteligentes e simular a execução do código JavaScript.
npx hardhat functions-simulate-twilio --gaslimit 300000
O simulador deve executar o código conforme o arquivo de configuração da sua solicitação, imprimir os números mensais mais recentes de transmissão para o artista Tones & I no console, calcular o pagamento e confirmar que um e-mail foi enviado ao artista.
Toda essa simulação é feita usando um fork da blockchain real que roda localmente em sua máquina - o que significa que você pode testar sua aplicação de ponta a ponta sem usar nenhum gás e sem ter que esperar por confirmações de bloco e conclusão de transações!
A seguir, vamos analisar os vários passos para configurar esta aplicação na rede de teste Sepolia. Você também pode ver esses passos no README, onde as informações mais atualizadas provavelmente estarão.
Primeiro, precisamos implantar o contrato do token STC (SimpleStableCoin.sol) para que tenhamos tokens para pagar ao artista. Observe que a maioria (mas nem todos) dessas tarefas está em ./tasks/Functions-client-twilio-spotify/<STEP #>_<<TASK NAME>>.js
Com esta configuração, tudo que você precisa fazer é executar a tarefa certa para implantar ou interagir com o contrato inteligente relevante na rede de teste Sepolia ou Mumbai.
Observe que o SimpleStableCoin.sol emite 1 milhão de STC imediatamente após a implantação e concede isso ao implementador do contrato STC. Isso significa que os tokens são mantidos pela conta implementadora (sua conta de carteira que foi autorizada quando você se cadastrou para usar as Functions da Chainlink!).
npx hardhat functions-deploy-stablecoin --network sepolia --verify true
Você deverá ver logs na sua tela semelhantes a estes:
Anote o endereço do seu contrato de stablecoin na blockchain. Vamos precisar dele nos comandos futuros.
Em seguida, vamos implantar nosso contrato inteligente RecordLabel.sol na rede de teste Sepolia. Execute:
npx hardhat functions-deploy-recordlabel --network sepolia --stc-contract <<endereço-do-contrato-0x>> --verify true
Depois de implantado, anote o endereço do seu contrato RecordLabel implantado na sua rede de teste. Você precisará usar este endereço para tarefas subsequentes, pois é o "contrato do cliente":
O próximo passo é algo específico de como os tokens ERC-20 funcionam, mas precisamos autorizar nosso contrato RecordLabel a gastar a stablecoin que pertence ao implementador da stablecoin (lembra como 1 milhão de STC foi emitido para o implementador quando implantamos o contrato STC?)
Portanto, precisamos autorizar o contrato RecordLabel a pagar os artistas usando esses STCs emitidos:
npx hardhat functions-approve-spender --network sepolia --client-contract <<endereço-do-contrato-0x>> --stc-contract <<endereço-do-contrato-0x>>
Uma vez bem-sucedido, você deverá ver o seguinte:
Também devemos inicializar alguns metadados relacionados ao nosso artista para que o contrato inteligente RecordLabel tenha algumas informações iniciais sobre o artista, como a carteira do artista (que será a sua segunda conta MetaMask, neste exemplo) e sua última contagem de ouvintes, etc. Para isso, executamos:
npx hardhat functions-initialize-artist --network sepolia --client-contract <<endereço-do-contrato-0x>>
No nosso exemplo, adicionamos alguns metadados para o artista "Tones & I", que obtivemos da documentação da Soundcharts, e atribuímos a eles o endereço de nossa segunda carteira.
Em seguida, precisamos criar e financiar uma assinatura da Chainlink Functions e registrar nosso contrato inteligente implantado como um contrato consumidor válido para essa assinatura.
npx hardhat functions-sub-create --network sepolia --amount 2.5 --contract <<endereço-do-contrato-0x>>
Este comando realizará três coisas:
- Criar uma assinatura da Chainlink Functions.
- Registrar nosso contrato
RecordLabelimplantado como consumidor. - Financiar nossa assinatura com 2.5 LINK da sua carteira Web3. Observe que recomendamos financiar com pelo menos 2.5 LINK para garantir que picos de preço de gás na rede não causem falhas nas transações. Como você sempre pode recuperar seu LINK de teste ao cancelar sua assinatura, você pode colocar mais LINK lá para eliminar o risco de suas transações ficarem sem LINK devido a picos de gás na testnet.
Depois que a assinatura é criada e financiada, um resumo da sua assinatura será impresso no terminal. Anote o ID da sua assinatura; você também precisará disso para os passos subsequentes.
Execute a Aplicação
Agora que o contrato inteligente está implantado na rede de teste Sepolia, nosso último passo é enviar o código em ./Twilio-Spotify-Functions-Source-Example.js para o Contrato RecordLabel para iniciar a execução das Chainlink Functions. Isso buscará os números de transmissão mais recentes do artista, calculará os pagamentos e enviará esses dados para a cadeia.
Ao executar o seguinte comando, certifique-se de substituir o valor do ID da assinatura gerado no passo anterior e o valor do endereço do contrato implantado pelo valor do endereço do contrato implantado na seção "Implantar a Aplicação" deste tutorial.
npx hardhat functions-request --network sepolia --contract <<endereço-do-contrato-0x>> --subid <__<__ID da assinatura do passo anterior__>> --gaslimit 300000
Como você pode ver, passamos a rede, o endereço do contrato RecordLabel, nosso ID de assinatura recém-criado e financiado, e também a quantidade máxima de gás que queremos que as Chainlink Functions usem ao chamar nossa função f fillRequest() como parâmetros para a ferramenta da CLI.
Este comando primeiro executa o simulador de ponta a ponta localmente (a menos que você passe --simulate false). Em seguida, se você aprovar a submissão das transações na cadeia, a ferramenta programa os dados no arquivo ./Functions-request-config.js, obtém as chaves de API criptografadas da URL que você forneceu, conecta-se à rede de teste Sepolia e envia esses dados para o contrato RecordLabel implantado.
A partir daí, executeRequest() desencadeia uma série de eventos na cadeia que é capturada pela rede de oráculos descentralizada Chainlink, e cada nó nessa rede executa independentemente o código JavaScript personalizado em ./Twilio-Spotify-Functions-Source-Example.js. O protocolo de consenso OCR da Chainlink entra em ação para garantir consenso nos dados retornados por cada nó, e essa resposta acordada, criptograficamente verificável, é enviada de volta à cadeia e é enviada para o RecordLabel no método fulfillRequest().
Tudo isso pode ser visto na saída do terminal quando você executa npx hardhat functions-request:
Para resumir este passo, quando executamos o comando da CLI, as seguintes coisas acontecerão:
- Haverá uma estimativa de custos de gás e LINK de ponta a ponta, e você deve confirmar se deseja prosseguir digitando "Y".
- O simulador executará uma simulação de ponta a ponta localmente (ou seja, internamente faz o mesmo que
npx hardhat functions-simulate-twilio --gaslimit 300000). - O pacote env-enc se conectará à sua conta do GitHub usando seu token de acesso e criará temporariamente um arquivo secreto privado do GitHub gist com suas chaves criptografadas (isso é excluído, por razões de segurança, após a conclusão do seu pedido!)
- O objeto de solicitação no arquivo de configuração da solicitação é enviado para o método
executeRequestdo contrato RecordLabel. - A rede de oráculos descentralizada Chainlink recebe a carga útil da solicitação, analisa suas partes, e cada nó executa separadamente seu código JavaScript personalizado.
- Os resultados passam pelo algoritmo de consenso OCR da Chainlink, e uma única resposta final acordada é postada na cadeia e enviada para o método
fulfillRequestno contrato RecordLabel. - A string hexadecimal do valor retornado e seu valor decodificado.
- Um resumo da faturação em LINK.
A ferramenta CLI é extremamente poderosa, e você pode executar muitos outros comandos relacionados a recarga, transferência ou cancelamento de sua assinatura, leitura de quaisquer erros de seu contrato cliente, ou obtenção da última resposta na cadeia retornada pelas Chainlink Functions, etc. Você pode conferir todos os comandos seguindo os links fornecidos.
Verificando os Resultados
Agora, há algumas maneiras de verificar seus resultados!
A maneira mais legal é verificar na MetaMask! Mude para o segundo endereço da carteira que você usou (este é o que também recebe os pagamentos do artista) e certifique-se de ter adicionado LINK como um ativo reconhecido para essa conta. Em seguida, pegue o endereço do seu contrato STC e importe-o como um token para sua carteira MetaMask. Você deve ver a mesma quantidade de STC em seu endereço de carteira que a quantidade que foi impressa no seu terminal como pagamento ao artista!
Ou você pode ir para https://sepolia.etherscan.io/ e digitar o endereço da sua segunda carteira e verificar os tokens que ela possui. Cada vez que você implanta um contrato STC, haverá uma entrada, porque cada endereço de contrato é tratado como um token separado.
Conclusão
Este exemplo demonstra como a Chainlink Functions pode ser usada para obter dados de absolutamente qualquer API e trazê-los para a cadeia, ou enviar dados na direção oposta. Você pode conectar seu contrato inteligente ao mundo externo usando a Chainlink Functions. Você também pode realizar simulações poderosas de ponta a ponta diretamente da sua máquina sem gastar ETH de teste ou gás. Você pode interagir com serviços de terceiros, como APIs do Spotify, serviços de e-mail da Twilio e muito mais para aprimorar seu dApp, o que desbloqueia novos recursos e funcionalidades que as aplicações nativas Web3 não podem acessar por conta própria.
O código deste exemplo está disponível neste repositório. E você também pode assistir a uma versão em vídeo disso, apresentada como uma Masterclass Deep Dive, caso queira nos ver codificar isso ao vivo!
Para aprender mais sobre Web3 e aplicativos descentralizados, confira este post no blog e este Recurso Educacional Web3 gratuito. Para aprender mais sobre a Chainlink Functions, vá para o site da Chainlink.
Autores:
Zubin Pratap – Engenheiro de Relações com Desenvolvedores, Chainlink Labs (Twitter)
Harry Papacharissiou – Gerente de Defesa de Desenvolvedores (Twitter)
Este artigo foi escrito por Zubin Pratap e Harry Papacharissiou , e traduzido por Adriano P. de Araujo. O original em inglês pode ser encontrado aqui.
Top comments (0)