Como construir na NEAR? Guia de iniciação

8 min read
To Share and +4 nLEARNs

Pré-requisitos

Os desenvolvedores são a força vital do ecossistema blockchain. Para que a tecnologia blockchain ganhe a adoção popular, ela precisa reduzir as barreiras de entrada para os desenvolvedores e permitir que eles criem aplicativos divertidos e sofisticados para as pessoas comuns aproveitarem. É exatamente por isso que os contratos inteligentes da NEAR são escritos usando AssemblyScript devido à sua semelhança com o JavaScript.

Então, se você está interessado em construir no NEAR, você pode usar as seguintes ferramentas

  • JavaScript SDK. Conecte, assine, transacione e implante em qualquer rede NEAR a partir de qualquer contexto JS
  • Contrato Rust SDK. Crie contratos seguros e protegidos que gerenciem ativos de alto valor
  • Contrato AssemblyScript SDK. Aprenda e faça protótipos com zero atrito usando a sintaxe JS
  • API JSON RPC. Todas as comunicações com a plataforma passam por esta API incluindo a nossa
  • Command Line Interface. Kit de ferramentas de linha de comando completo para desenvolvedores e validadores
  • NEAR Explorer. Uma ferramenta de pesquisa de blockchain que permite aos desenvolvedores visualizar detalhes de transações, contas, detalhes de blocos e muito mais
  • NEAR Wallet. Crie contas, gerencie chaves de acesso e muito mais com nossa interface de usuário amigável 
  • Nearup. Gerencie implantações localmente e junte-se a qualquer rede pública ou privada
  • Bridge. Interoperabilidade rápida e segura
  • EVM. Máquina virtual compatível com Ethereum.

Tudo bem, vamos dar os primeiros passos.

Uma breve visão geral

Os aplicativos no NEAR têm duas partes distintas – um back-end e um front-end.

  • Smart Contract (back-end): Armazenar e modificar dados na cadeia. Os contratos precisam expor métodos que permitam aos clientes “visualizar” e “alterar” o estado.
  • Interações com Smart Contract (front-end): Você pode interagir com seus contratos ou contratos implantados por outras pessoas. Você faz isso usando o início rápido e os trechos de código near-api-js em seu aplicativo.

Os aplicativos no NEAR têm duas partes distintas – um back-end e um front-end. O back-end é o…

Correct! Wrong!

Como construir e chamar contratos inteligentes

NEAR atualmente suporta: 

  • Rust – near-sdk-rs: Um wrapper (envelopador) que fornece segurança aprimorada para a linguagem de programação Rust para contratos de alto valor. 
  • AssemblyScript near-sdk-as: uma coleção de auxiliares que fazem seus contratos inteligentes parecerem semelhantes ao TypeScript durante a compilação para Wasm para execução. 

NOTA: Atualmente, o AssemblyScript não é recomendado para aplicativos financeiros de produção devido à novidade da linguagem e das ferramentas de compilação disponíveis. 

Tudo bem, vamos falar sério.

Configurando o Testnet

A maneira mais fácil de criar uma conta na NEAR é com a NEAR Wallet a carteira da rede Near. A NEAR tem várias redes de desenvolvimento operando independentemente umas das outras com seus próprios IDs de conta. Vá, siga os passos para criar uma carteira. Certifique-se de ter seguido as etapas necessárias para o backup de segurança. 

NOTA: Criar uma conta na mainnet é quase idêntico ao testnet, mas exigirá um financiamento inicial para a conta. Aqui está um guia para a criação de conta mainnet. 

Não importa, ao implantar, se o aplicativo é escrito em Rust ou AssemblyScript. Todo o código do contrato é compilado no WebAssembly e implantado na rede para ser executado dentro de uma máquina virtual compatível com Wasm. Você usará um comando como yarn dev para a maioria dos aplicativos, mas pode facilmente implantar um aplicativo usando NEAR CLI com near dev-deploy para TestNet (ou near deploy se já tiver criado uma conta).

Todo o código do contrato é compilado no WebAssembly e implantado na rede para ser executado dentro de um _______

Correct! Wrong!

Agora, faça o seguinte para se aquecer:

  1. Olhe ao redor no NEAR Explorer. Aqui você pode pesquisar todas as transações e blocos produzidos no NEAR. Tente pesquisar a conta que você acabou de criar e veja as transações que você criou.
  2. Agora instale near-cli. Esta é uma interface de linha de comando que permite que você interaja perfeitamente com o NEAR. Este documento NEAR tem todos os comandos near-cli com exemplos.
  3. Tente executar seu primeiro comando: near login. Isso irá redirecioná-lo para sua carteira NEAR e salvar suas chaves de conta testnet localmente.

Depois de verificar o testnet, você pode se sentir à vontade para executar seu nó local. No entanto, se você quiser apenas brincar com os códigos, sugerimos que você fique com o testnet.

Como executo um nó?

Como em qualquer ecossistema baseado em blockchain, o NEAR Protocol é executado em uma coleção de computadores mantidos publicamente (ou “nós”). 

Você pode decidir executar um nó próprio por alguns motivos: 

  • Para desenvolver e implantar contratos em um nó conectado a MainNet, TestNet ou BetaNet Para desenvolver e implantar contratos em um nó local (independente e isolado) (às vezes chamado de “LocalNet” ). 
  • Para ingressar em uma rede como um validador executando um “nó validador” 

Você pode iniciar NEAR betanet e nós testnet instalando nearup. Você pode fazer isso seguindo as instruções em https://github.com/near/nearup

Como em qualquer ecossistema baseado em blockchain, o NEAR Protocol é executado em uma coleção de computadores mantidos publicamente chamados ______

Correct! Wrong!

Executando um nó oficial usando o Docker

Por padrão, o NEAR usa o Docker para executar o cliente. Então, a primeira coisa que você faz é instalar o Docker e Nearup. Agora, execute seu sistema com isto:

nearup betanet

(Se você preferir usar TestNet, basta substituir betanet por testnet no comando acima) 

Você será solicitado a fornecer um ID de conta. Você pode deixar isso em branco se quiser apenas executar um nó. Os validadores devem usar o ID da conta com a qual você deseja apostar. Depois disso, você precisa digitar este código: 

Digite o ID da sua conta (deixe em branco se não for um validador) 

Agora, seu nó será iniciado em segundo plano com o Docker. Para verificar os logs dentro do Docker, execute docker logs –follow nearcore.

Criando um código simples em NEAR

NEAR tem uma lista de programas úteis ou códigos de exemplo que você pode verificar com facilidade. Portanto, o código que iremos verificar é o Livro de Visitas. O uso do programa permite que você faça login com NEAR e adicione uma mensagem ao livro de visitas! Um aplicativo inicial criado com um back-end AssemblyScript e um front-end React.

Examinando o código do livro de visitas 

Para executar este projeto localmente, você precisa garantir o seguinte.

  • Certifique-se de ter o Node.js ≥ 12 instalado (https://nodejs.org) e use-o para instalar o yarn: npm install –global yarn (ou apenas npm i -g yarn)
  • Instalar dependências: yarn install (ou apenas yarn)
  • Execute o servidor de desenvolvimento local: yarn dev (consulte package.json para obter uma lista completa de scripts que você pode executar com yarn)

Agora você terá um ambiente de desenvolvimento local apoiado pelo NEAR TestNet! A execução do yarn dev informará a URL que você pode visitar no seu navegador para ver o aplicativo.

Ah, e certifique-se de ter a página do GitHub aberta. 

Você pode achar este vídeo útil também.

Explorando o código

Como você pode ver, existem dois lados do código – backend e frontend:

  • O código de back-end fica na pasta /assembly. Esse código é implantado na blockchain NEAR quando você executa yarn deploy:contract. Este é um contrato inteligente NEAR.
  • O código frontend fica na pasta /src. /src/index.html é um ótimo lugar para começar a explorar. Observe que ele carrega em /src/index.js, onde você pode aprender como o frontend se conecta a blockchain NEAR.

Código de back-end

#1 Modelo de dados de contrato: assembly/model.ts

import { context, u128, PersistentVector } from "near-sdk-as";
/** 
 * Exporting a new class PostedMessage so it can be used outside of this file.
 */
@nearBindgen
export class PostedMessage {
  premium: boolean;
  sender: string;
  constructor(public text: string) {
    this.premium = context.attachedDeposit >= u128.from('10000000000000000000000');
    this.sender = context.sender;
  }
}
/**
 * collections.vector is a persistent collection. Any changes to it will
 * be automatically saved in the storage.
 * The parameter to the constructor needs to be unique across a single contract.
 * It will be used as a prefix to all keys required to store data in the storage.
 */
export const messages = new PersistentVector&lt<PostedMessage>("m");

Análise

A classe “PostedMessage” tem três recursos:

  • premium para sinalizar mensagens com tokens NEAR anexados
  • remetente para rastrear o signatário da mensagem do livro de visitas
  • texto para guardar a mensagem do livro de visitas

Finalmente, “messages” é uma coleção de mensagens do livro de visitas armazenadas como um PersistentVector de objetos PostedMessage

#2 Comportamento do contrato: assembly/main.ts

import { PostedMessage, messages } from './model';
// --- contract code goes below
// The maximum number of latest messages the contract returns.
const MESSAGE_LIMIT = 10;
/**
 * Adds a new message under the name of the sender's account id.
 * NOTE: This is a change method. Which means it will modify the state.
 * But right now we don't distinguish them with annotations yet.
 */
export function addMessage(text: string): void {
  // Creating a new message and populating fields with our data
  const message = new PostedMessage(text);
  // Adding the message to end of the the persistent collection
  messages.push(message);
}
/**
 * Returns an array of last N messages.
 * NOTE: This is a view method. Which means it should NOT modify the state.
 */
export function getMessages(): PostedMessage[] {
  const numMessages = min(MESSAGE_LIMIT, messages.length);
  const startIndex = messages.length - numMessages;
  const result = new Array&lt;PostedMessage&gt;(numMessages);
  for(let i = 0; i <  numMessages; i++) {
    result[i] = messages[i + startIndex];
  }
  return result;
}

Análise

MESSAGE_LIMIT é usado para evitar chamadas ilimitadas (ou seja, potencialmente caras) para recuperar mensagens do livro de visitas do armazenamento

Também estamos usando duas funções públicas diferentes neste contrato – addMessage() e getMessages()

Código Front-end

#1 Conexão de rede: src/config.js

const CONTRACT_NAME = process.env.CONTRACT_NAME || 'guest-book.testnet';
function getConfig(env) {
  switch(env) {
    case 'mainnet':
      return {
        networkId: 'mainnet',
        nodeUrl: 'https://rpc.mainnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.near.org',
        helperUrl: 'https://helper.mainnet.near.org'
      };
    // This is an example app so production is set to testnet.
    // You can move production to mainnet if that is applicable.
    case 'production':
    case 'development':
    case 'testnet':
      return {
        networkId: 'default',
        nodeUrl: 'https://rpc.testnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.testnet.near.org',
        helperUrl: 'https://helper.testnet.near.org'
      };
    case 'betanet':
      return {
        networkId: 'betanet',
        nodeUrl: 'https://rpc.betanet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.betanet.near.org',
        helperUrl: 'https://helper.betanet.near.org'
      };
    case 'local':
      return {
        networkId: 'local',
        nodeUrl: 'http://localhost:3030',
        keyPath: `${process.env.HOME}/.near/validator_key.json`,
        walletUrl: 'http://localhost:4000/wallet',
        contractName: CONTRACT_NAME
      };
    case 'test':
    case 'ci':
      return {
        networkId: 'shared-test',
        nodeUrl: 'https://rpc.ci-testnet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    case 'ci-betanet':
      return {
        networkId: 'shared-test-staging',
        nodeUrl: 'https://rpc.ci-betanet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    default:
      throw Error(`Unconfigured environment '${env}'. Can be configured in src/config.js.`);
  }
}
module.exports = getConfig;

Análise

O código acima define os dados e endpoints necessários para se conectar à rede NEAR. As informações de conexão definidas aqui estão incluídas para MainNet, TestNet e BetaNet, bem como a configuração padrão do LocalNet

#2 Configuração: src/index.js

import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import getConfig from './config.js';
import * as nearAPI from 'near-api-js';
// Initializing contract
async function initContract() {
  const nearConfig = getConfig(process.env.NODE_ENV || 'testnet');
  // Initializing connection to the NEAR TestNet
  const near = await nearAPI.connect({
    deps: {
      keyStore: new nearAPI.keyStores.BrowserLocalStorageKeyStore()
    },
    ...nearConfig
  });
  // Needed to access wallet
  const walletConnection = new nearAPI.WalletConnection(near);
  // Load in account data
  let currentUser;
  if(walletConnection.getAccountId()) {
    currentUser = {
      accountId: walletConnection.getAccountId(),
      balance: (await walletConnection.account().state()).amount
    };
  }
  // Initializing our contract APIs by contract name and configuration
  const contract = await new nearAPI.Contract(walletConnection.account(), nearConfig.contractName, {
    // View methods are read-only – they don't modify the state, but usually return some value
    viewMethods: ['getMessages'],
    // Change methods can modify the state, but you don't receive the returned value when called
    changeMethods: ['addMessage'],
    // Sender is the account ID to initialize transactions.
    // getAccountId() will return empty string if user is still unauthorized
    sender: walletConnection.getAccountId()
  });
  return { contract, currentUser, nearConfig, walletConnection };
}
window.nearInitPromise = initContract()
  .then(({ contract, currentUser, nearConfig, walletConnection }) =&gt; {
    ReactDOM.render(
      &lt;App
        contract={contract}
        currentUser={currentUser}
        nearConfig={nearConfig}
        wallet={walletConnection}
      /&gt;,
      document.getElementById('root')
    );
  });

Análise

Este é o filé da seção frontend, quando você configura a conexão com a rede NEAR. Você pode configurar a interface do contrato injetando a conexão da carteira e conectando os dois métodos de contrato.

Como implantar um contrato inteligente

Cada contrato inteligente na NEAR tem sua própria conta associada. Quando você executa o yarn dev, seus contratos inteligentes são implantados na NEAR TestNet ao vivo com uma conta temporária. Se agora você deseja torná-lo permanente, aqui está o que você precisa fazer.

Etapa 0: instalar near-cli

Veja como você instala globalmente near-cli

npm install --global near-cli

Isso lhe dará a ferramenta CLI próxima. Certifique-se de que está instalado com:

near --version

Etapa 1: criar uma conta para o contrato

Visite NEAR Wallet e crie uma nova conta. Você implantará esses contratos inteligentes nessa nova conta. 

Agora autorize o NEAR CLI para esta nova conta e siga as instruções fornecidas:

near login

Etapa 2: definir o nome do contrato no código

Modifique a linha em src/config.js que define o nome da conta do contrato. Defina-o para o ID da conta que você usou acima.

const CONTRACT_NAME = process.env.CONTRACT_NAME || 'your-account-here!'

Etapa 3: altere o URL remoto se você clonou este repositório

Se você bifurcar o repositório, precisará alterar a URL remota para um repositório ao qual você tenha acesso de “commit”. Isso permitirá a implantação automática no Github Pages a partir da linha de comando.

  1. Acesse o GitHub e crie um novo repositório para este projeto.
  2. Abra seu terminal e na raiz deste projeto digite o seguinte:
$ `git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git`

Etapa 4: implantar!

Você só precisa do seguinte comando para implantar seu contrato inteligente:

yarn deploy

Este comando faz duas coisas:

  • Cria e implanta contratos inteligentes no TestNet NEAR 
  • Cria e implanta código de contrato de front-end no GitHub usando gh-pages. Isso só funcionará se o projeto já tiver um repositório configurado no GitHub. Sinta-se à vontade para modificar o script de implantação em package.json para implantar em outro lugar.

Cada contrato inteligente no NEAR tem seu próprio ____ associado

Correct! Wrong!

O que vem agora?

Tudo bem, agora que você sabe como executar um código básico, talvez queira se aprofundar na NEAR. Para isso, confira os documentos do desenvolvedor da NEAR.

22
Scroll to Top