Integração com o protocolo NEAR

4 min read
To Share and +4 nLEARNs

Uma descrição da nossa jornada de integração NEAR

Vamos começar com o que são os 3 pilares do Protocolo NEAR:

  • Prova de Participação (Proof-of-Stake)
  • Fragmentado (Shards)
  • Contratos inteligentes WASM

Como uma prova de participação, o consenso da blockchain é alcançado fazendo stake e não pela mineração, Near tem blocos rápidos de 1 segundo com finalização curta.

O blockchain é fragmentado, o que significa que as chamadas entre contratos são assíncronas (não confundir com síncronas como no Ethereum ou Solana). Codificando Contratos em NEAR você precisa ter a mentalidade de trabalhar com modelo de ator (ou microsserviços, mas eu odeio esse termo). O requisito de assincronia é necessário para que os fragmentos possam ser processados ​​em paralelo, levando a uma taxa de transferência de transações muito maior. Blockchains em que os contratos inteligentes não são fragmentados simplesmente atingirão um teto de escalabilidade, descarregando para GPU ou ASIC (enquanto ainda síncrono) só pode atrasar horizontalmente esse teto, mas não levará a uma escala exponencial.

Contratos em NEAR são código WASM, você pode então codificar em qualquer linguagem que possa compilar para WASM. Atualmente AssemblyScript (subconjunto de TypeScript) e RUST são mais suportados com cadeias de ferramentas adequadas.

ISENÇÃO DE RESPONSABILIDADE: Isso levará menos de 30 minutos se você puder programar em TypeScript.

Construir um WebApp no ​​protocolo NEAR (que é exatamente o que o Near proporciona) é muito fácil em comparação com outras blockchains.

Vamos clonar o exemplo do contador aqui https://github.com/near-examples/counter.

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

Nós só apenas nos importamos com essas 2 pastas e 1 arquivo assembly/ é onde está nosso contrato inteligente (que será compilado para WASM).

src/ é para onde vai nosso código frontend que interage com o contrato.

package.json é para onde vão nossas dependências JavaScript extras.

O núcleo do nosso contrato inclui armazenamento em cadeia, registro de controle para o recebimento gerado e funções públicas exportadas. As funções que definem o armazenamento devem ser chamadas, caso contrário podem ser visualizadas (mesmo sem uma conta NEAR).

Near suporta vários tipos de coleções (que se auto-descrevem) no near-sdk-as.

https://github.com/near/near-sdk-as/tree/master/sdk-core/assembly/collectionsOs principais que você vai precisar:

  • storage.getPrimitive — get/set
  • persistenteMap — definir/obter
  • persistenteUnorderedMap — set/get/query/length

Eu não incluo persistenteVector porque você deve evitar usá-lo, é muito fácil queimar toneladas de vetores de iteração de gás, tente usar conjuntos sempre que possível.

Os valores padrão para coleções de visibleMap precisam ser sufixados com !

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

logging.log imprimirá a saída do log em seu recibo ao chamar uma função, isso é útil para controlar o fluxo do que aconteceu, especialmente à medida que os contratos se tornam mais complexos. Exemplo de um contrato de cunhagem legível por humanos pode ter uma mensagem de log de “alice.near cunhou 5.0 ZOD de zod.near”.

Vamos implantar nosso contrato, para isso precisamos de near-cli.

npm install near-cli -g

E para implantar podemos criar uma conta testnet fictícia. Contas são contratos e você só pode ter 1 contrato por conta. Para criar vários contratos, você precisa usar subcontas, contract1.me.near, contract2.me.near.

Vamos implantar e chamar a função getCounter.

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

Saída é

View call: dev-1623290109414-64922580028342.getCounter({})
0
near call --accountId $ACC1 $ACC1 incrementCounter '{"value": 1}'

Vamos ver esta chamada no explorador de blocos https://explorer.testnet.near.org/accounts/dev-1623290109414-64922580028342

Maravilha.

Para visualizar uma função, podemos usar curl, mas precisamos analisar alguma saída de linha de comando, é mais simples escrever um script de nó rápido. Nós nem precisamos de uma conta próxima.

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-se ao 24, o yocto.

3_000_000_000_000__000_000_000_000

é 3,0

Isso termina a primeira série aqui, a próxima seria trabalhar com um frontend da Web e obter corretamente o equilíbrio, o estado e muito mais.

18
Scroll to Top