¿Cómo desarrollar en NEAR? Guía de inicio

Prerrequisitos

• Leer “¿Qué es NEAR?”
• Experiencia en desarrollo de JavaScript

Los desarrolladores son el elemento vital del ecosistema blockchain. Para que la tecnología blockchain obtenga la adopción generalizada, debe reducir las barreras de entrada para los desarrolladores y permitirles crear aplicaciones divertidas y sofisticadas para que disfruten las personas normales. Es por esta misma razón que los contratos inteligentes de NEAR se escriben usando AssemblyScript debido a su similitud con JavaScript.

Por lo tanto, si estás interesado en desarrollar en NEAR, puedes usar las siguientes herramientas

• JavaScript SDK. Conecta, firma, realiza transacciones y despliega en cualquier red NEAR desde cualquier contexto JS.
• Rust Contract SDK. Crea contratos seguros y protegidos que gestionen activos de alto valor.
• AssemblyScript Contract SDK. Aprende y crea prototipos sin dificultad utilizando la sintaxis JS.
• JSON RPC API. Todas las comunicaciones con la plataforma pasan por esta API incluida la nuestra.
• CLI o Interfaz de línea de comandos. Kit de herramientas de línea de comandos con todas las funciones para desarrolladores y validadores.
• Explorador NEAR. Una herramienta de búsqueda en la blockchain que permite a los desarrolladores ver detalles de transacciones, cuentas, detalles de bloques y más.
• NEAR Wallet. Cree cuentas, administre claves de acceso y más con nuestra interfaz de usuario fácil de usar.
• nearup. Despliega localmente y únete a cualquier red pública o privada.
• Bridge(Puente). Interoperabilidad rápida y segura.
• EVM. Máquina virtual compatible con Ethereum.

Muy bien, demos los primeros pasos.

Un breve repaso

Las aplicaciones en NEAR tienen dos partes distintas: un back-end y un front-end.

• Contratos Inteligentes (back-end): Almacenan y modifican datos en la cadena. Los contratos deben exponer métodos que permitan a los clientes “ver” y “cambiar” el estado.
• Interacciones con los Contratos Inteligentes (front-end): Puedes interactuar con tus contratos o contratos implementados por otras personas. Para ello, utiliza Inicio rápido near-api-js y fragmentos de código en tu aplicación.

Cómo crear y llamar a contratos inteligentes

NEAR actualmente admite:

• Rust – near-sdk-rs: Un contenedor que proporciona seguridad mejorada para el lenguaje de programación Rust para contratos de alto valor.
• AssemblyScript near-sdk-as: una colección de ayudas que hacen que sus Contratos Inteligentes se vean similares a TypeScript mientras se compilan en Wasm para su ejecución.

NOTA: Actualmente AssemblyScript no se recomienda para aplicaciones financieras  debido a la novedad del lenguaje y las herramientas de compilación disponibles.

Muy bien, pongámonos serios.

Configuración de Testnet

La forma más sencilla de crear una cuenta en NEAR es con NEAR Wallet.  NEAR tiene varias redes de desarrollo que operan de forma independiente entre sí con sus propios ID de cuenta.  Ve, sigue los pasos para crear una billetera.  Asegúrate de haber seguido los pasos requeridos para tu copia de seguridad.

NOTA: Crear una cuenta en mainnet es casi idéntico a testnet pero requerirá fondos iniciales para la cuenta.  Aquí hay una guía para la creación de cuentas de mainnet.

No importa si la aplicación está escrita en Rust o en AssemblyScript. Todo el código del contrato se compila en WebAssembly y se implementa en la red para ejecutarse dentro de una máquina virtual compatible con Wasm. Utilizarás un comando como “yarn dev” para la mayoría de las aplicaciones, pero puedes implementar una aplicación con la misma facilidad usando NEAR CLI con “near dev-deploy” para TestNet (o “near deploy” si ya has creado una cuenta).

Ahora, haga lo siguiente para empezar:

1. Busca en NEAR Explorer.  Aquí puedes buscar todas las transacciones y bloques producidos en NEAR. Intenta buscar la cuenta que acabas de crear y ve las transacciones que has creado.
2. Ahora instale near-cli. Esta es una interfaz de línea de comandos que le permite interactuar sin problemas con NEAR. Este NEAR docs tiene todos los comandos near-cli con ejemplos.
3. Intente ejecutar su primer comando: near login.  Esto lo redireccionará a su NEAR Wallet y guardará las claves de su cuenta de testnet localmente.

Después de comprobar la red de prueba, puedes sentirte libre de ejecutar tu nodo local.  Sin embargo, si solo quieres jugar con los códigos, te sugerimos que te atengas a la red de prueba.

¿Cómo ejecutar un nodo?

Al igual que con cualquier ecosistema basado en blockchain, NEAR Protocol se ejecuta en una colección de computadoras (o “nodos”) mantenidos públicamente.

Puedes decidir ejecutar un nodo propio por algunas razones:

• Para desarrollar e implementar contratos en un nodo conectado a MainNet, TestNet o BetaNet
• Para desarrollar e implementar contratos en un nodo local (independiente y aislado) (a veces llamado “LocalNet”).
• Para unirte a una red como validador ejecutando un “nodo validador”.

Puedes iniciar NEAR nodos betanet y testnet instalando nearup. Puedes hacerlo siguiendo las instrucciones en https://github.com/near/nearup

Ejecutando un nodo oficial usando Docker

De forma predeterminada, NEAR usa Docker para ejecutar el cliente.  Entonces, lo primero que debes hacer es instalar Docker y nearup.  Ahora, ejecuta tu sistema con esto:

nearup betanet

(Si prefieres usar TestNet, simplemente reemplaza betanet con testnet en el comando anterior)

A continuación, se le pedirá una ID de cuenta. Puedes dejar esto vacío si solo deseas ejecutar un nodo. Los validadores deben usar el ID de la cuenta con la que deseas hacer staking. Después de eso, debes ingresar este código:

Ingresa tu ID de cuenta (déjelo en blanco si no va a ser un validador)

Ahora, su nodo comenzará en segundo plano con Docker.  Para verificar los registros dentro de Docker, “run docker logs –follow nearcore”.

Creando un código simple en NEAR

NEAR tiene una lista de programas útiles o códigos de ejemplo que puedes consultar con facilidad. Entonces, el código que estaremos revisando es el Guest Book (Libro de visitas). Usar el programa te permite iniciar sesión con NEAR y agregar un mensaje al libro de visitas. Una aplicación de inicio construida con un backend de AssemblyScript y un frontend de React.

Mirando en el código del libro de visitas

Para ejecutar este proyecto localmente, debes asegurarte de lo siguiente.

• Asegúrate de tener Node.js ≥ 12 instalado (https://nodejs.org), luego úsalo para instalar yarn: npm install –global yarn (o simplemente npm i -g yarn)
• Instalar dependencias: yarn install (o solo yarn)
• Ejecuta el servidor de desarrollo local: yarn dev (consulta package.json para obtener una lista completa de los scripts que puedes ejecutar con yarn)

¡Ahora tendrás un entorno de desarrollo local respaldado por NEAR TestNet!  Ejecutar yarn dev le dirá la URL que puede visitar en su navegador para ver la aplicación.

Ah, y asegúrate de tener abierta la página de GitHub.

Este video también puede resultarte útil.

Explorando el código

Como puedes ver, hay dos lados del código: backend y frontend:

• El código de backend vive en la carpeta /assembly.  Este código se implementa en la cadena de bloques NEAR cuando ejecuta yarn deploy:contract. Este es un contrato inteligente de NEAR.
• El código de la interfaz se encuentra en la carpeta /src. /src/index.html es un excelente lugar para comenzar a explorar. Ten en cuenta que se carga en /src/index.js, donde puedes aprender cómo la interfaz se conecta a la blockchain NEAR.

Código de backend

#1 Modelo de Datos del Contrato: assembly/model.ts

[code lang=”js”]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");[/code]

Análisis

@nearBindgen marca la clase como serializable. Serializable es una interfaz de marcador que se utiliza para “marcar” clases de modo que los objetos de estas clases puedan obtener cierta capacidad.

La clase “PostedMessage” tiene tres características:

• premium para marcar mensajes con tokens NEAR adjuntos
• sender para rastrear al firmante del mensaje del libro de visitas
• text para guardar el mensaje del libro de visitas

Finalmente, “messages” es una colección de mensajes del libro de visitas almacenados como “PersistentVector” con objetos de “PostedMessage”.

#2 Comportamiento del Contrato: assembly/main.ts

[code lang=”js”]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;
}[/code]

Analysis

MESSAGE_LIMIT se usa para evitar llamadas ilimitadas (es decir, potencialmente costosas) para recuperar los mensajes del libro de visitas del almacenamiento

También estamos usando dos funciones públicas diferentes en este contrato: addMessage() y getMessages()

Código frontend

#1 Conexión de Red: src/config.js

[code lang=”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;[/code]

Análisis

El código anterior define los datos y los puntos finales necesarios para conectarse a la red NEAR. La información de conexión definida aquí se incluye para MainNet, TestNet y BetaNet, así como la configuración predeterminada de LocalNet.

#2 Configuración: src/index.js

[code lang=”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')
   );
 });[/code]

Análisis

Esto es lo más básico y esencial de la sección de frontend, cuando configuras la conexión a la red NEAR. Puedes configurar la interfaz del contrato inyectando la conexión de la billetera y conectando ambos métodos de contrato.

Implementar un contrato inteligente

Cada contrato inteligente en NEAR tiene su propia cuenta asociada. Cuando ejecutas “yarn dev”, tus contratos inteligentes se implementan en NEAR TestNet con una cuenta temporal. Si ahora deseas que sea permanente, esto es lo que debes hacer.

Paso 0: Instalar near-cli

Así es como se instala near-cli a nivel global

npm install --global near-cli

Esto te dará la herramienta NEAR CLI. Asegúrate de que esté instalada con:

near --version

Paso 1: Crea una cuenta para el contrato

Visita NEAR Wallet y crea una nueva cuenta. Implementarás estos contratos inteligentes en esta nueva cuenta.

Ahora autoriza a NEAR CLI para esta nueva cuenta y sigue las instrucciones que te da:

near login

Paso 2: Establece el nombre del contrato en el código

Modifica la línea en src/config.js que establece el nombre de cuenta del contrato.  Configúralo con la identificación de la cuenta que utilizaste anteriormente.

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

Paso 3: Cambie la URL remota si clonaste este repositorio

Si forkeas/copias el repositorio, deberás cambiar la URL remota a un repositorio al que tengas acceso para hacer “commit”.  Esto permitirá la implementación automática en Github Pages desde la línea de comandos.

1. Ve a GitHub y crea un nuevo repositorio para este proyecto.
2.  Abre tu terminal y en la raíz de este proyecto ingresa lo siguiente:

$ `git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git`

Paso 4: ¡Desplegar!

Solo necesita el siguiente comando para implementar su contrato inteligente:

yarn deploy

Este comando hace dos cosas:

• Crea e implementa contratos inteligentes en NEAR TestNet
•  Construye e implementa código de contrato frontend en GitHub usando gh-pages.  Esto sólo funcionará si el proyecto ya tiene un repositorio configurado en GitHub.  Siéntase libre de modificar el script de implementación en package.json para implementarlo en otro lugar.

¿Qué sigue?

Muy bien, ahora que sabes cómo ejecutar un código básico, es posible que desees profundizar en NEAR. Para eso, consulte los documentos para desarrolladores de NEAR.