Integración con el Protocolo NEAR

4 min read
To Share and +4 nLEARNs

Una versión escrita de nuestro viaje por la integración NEAR

Empecemos por cuales serian los 3 pilares del Protocolo NEAR:

  • Proof of Stake (Prueba de Participación)
  • Sharded (Fragmentado, Fragmentación)
  • WASM Smart Contracts (Contratos Inteligentes de WebAssembly)

Debido a que el consenso en una blockchain (cadena de bloques) de Proof of Stake se logra mediante el staking y no mediante el minado, Near tiene bloques rápidos de hasta 1 segundo de corta finalidad.

La blockchain al ser fragmentada significa que las llamadas entre contratos son asincrónicas (no debe ser confundido con sincrónicas como en Ethereum o Solana). Cuando se programan contratos en Near se necesita tener la mentalidad de trabajar con actores modelos (o microservicios, pero odio ese término). El requerimiento de asincronicidad es necesario para que los shards sean procesados en paralelo llevando a un mayor rendimiento de transacción. Las Blockchains dónde los contratos inteligentes no son fragmentados simplemente van a chocar contra un techo de escalabilidad, descargando al GPU o ASIC, (Aplicación Específica de Circuito Integrado, mientras sean sincrónicas) lo cual solamente demora horizontalmente la llegada de este techo y no permite llegar a escalabilidad exponencial.

Los contratos en NEAR tienen código WASM, por esto puedes desarrollar en cualquier lenguaje que pueda compilar en WASM. Actualmente AssemblyScript (subconjunto de TypeScript) y RUST son los más respaldados con herramientas de cadena decentes. 

DESCARGO DE RESPONSABILIDAD: Esto te va a tomar MENOS de 30 minutos si puedes programar en TypeScript.

Construir una WebApp (Aplicación Web) en el Protocolo NEAR (la cual es exactamente donde accede Near) es muy fácil comparado con otras blockchains

Clonemos el ejemplo del contador aquí: https://github.com/near-examples/counter.

git clone https://github.com/near-examples/counter
yarn

Solamente nos importan estas 2 carpetas y 1 archivo. assembly/ es donde se encuentra nuestro contrato inteligente (el cual se va a compilar hacia WASM)/src es donde nuestro código frontend se encuentra el cual interactúa con el contrato.package.json es donde nuestras dependencias extras de JavaScript se encuentran.

La parte principal de nuestro contrato incluye almacenamiento en cadena, control de inicio de sesión para el recibo generado, y funciones públicas exportadas. Las funciones que determinen almacenamiento deben ser llamadas de otra manera para que sean vistas (incluso sin cuenta NEAR).

Near soporta múltiples tipos de colecciones (que se describen a sí mismas) por medio del near-sdk-as.

https://github.com/near/near-sdk-as/tree/master/sdk-core/assembly/collections

Las principales que vas a necesitar:

  • storage.getPrimitive — get/set
  • persistentMap — set/get
  • persistentUnorderedMap — set/get/query/length

No incluyo persistentVector ya que deberías intentar evitar usarlo, es muy sencillo quemar toneladas de gas iterando vectores, intenta usar conjuntos cuando sea posible.

let balance = myPersistentMap.get("myacc.near", u128.Zero)!

Lancemos nuestro contrato, para esto vamos a necesitar near-cli.

npm install near-cli -g

Y para lanzarlo vamos a crear una cuenta testnet de prueba. Las cuentas son contratos y solamente puedes tener 1 contrato por cuenta. Para crear multiples contratos necesitas utilizar sub cuentas, contract1.me.near, contract2.me.near

yarn build
ACC1=$(near dev-deploy out/main.wasm | sed 's/.*id: (.*), node.*/1/' | head -n 1)
near view --accountId $ACC1 $ACC1 getCounter '{}'
View call: dev-1623290109414-64922580028342.getCounter({})
0
near call --accountId $ACC1 $ACC1 incrementCounter '{"value": 1}'

Increíble.

Para visualizar una función podemos usar un curl pero necesitamos analizar gramaticalmente la salida de la línea de comando, en vez de ello es más simple utilizar un script de nodo rápido. No necesitamos siquiera una cuenta en Near.

node << EOF
const fetch = require('node-fetch');
async function go() {
  const args_base64 = Buffer.from('{}').toString('base64')
  const params = {account_id: "zodtv.near", method_name: "mint_status", 
    request_type: "call_function", finality: "final", "args_base64": args_base64}
  const json_args = {jsonrpc: "2.0", id: "1", method: "query", params: params}

  const fetch_args = {
    method: "POST",
    body: JSON.stringify(json_args),
    headers: {
      "Content-Type": "application/json"
    }
  }
  const response = await fetch("https://rpc.mainnet.near.org", fetch_args);
  const {result} = await response.json();

  const mint_status = JSON.parse((new TextDecoder()).decode(new Uint8Array(result.result)))
  console.log(mint_status)
}
go()
EOF
{
  "total_minted": "3120000000000000000000000000",
  "level": "0",
  "near_price": "3000000000000000000000000",
  "zod_price": "10000000000000000000000"
}

Near denomina hasta el 24, el yocto.

3_000_000_000_000__000_000_000_000

es 3.0

Con eso concluye la primera serie aquí, la próxima vamos a trabajar con una web frontend y correctamente obtener balance, estado y más.

20
Ir arriba
🕺New partnerships = cool giveaways! 5 lucky winners will get (L)Earners NFTs!🏆
This is default text for notification bar