Intégration avec le protocole NEAR

4 min read
To Share and +4 nLEARNs

Une rédaction de notre parcours d’intégration NEAR

Commençons par les 3 piliers du protocole NEAR :

  • Proof-of-Stake (Preuve de participation)
  • Sharded (Fragmentée)
  • Contrats intelligents WASM

En tant que Proof of Stake, le consensus sur la blockchain est atteint par le staking et non par mining. Near a des blocs rapides de 1 seconde avec une finalité courte.

La blockchain est sharded ou fragmentée, ce qui signifie que les appels entre contrats sont asynchrones (à ne pas confondre avec synchrones comme sur Ethereum ou Solana). Codage des contrats NEAR, vous devez adopter l’état d’esprit de travailler avec un modèle d’acteur (ou des microservices, mais je déteste ce terme). L’exigence d’asynchronicité est nécessaire pour que les fragments puissent être traités en parallèle, ce qui entraîne un débit de transaction beaucoup plus important. Les blockchains où les contrats intelligents ne sont pas fragmentés atteindront simplement un plafond d’évolutivité, le déchargement vers le GPU ou l’ASIC (tout en restant synchrone) ne peut que retarder horizontalement ce plafond, mais cela ne conduira pas à une mise à l’échelle exponentielle.

Les contrats de NEAR sont du code WASM, vous pouvez donc coder dans n’importe quel langage pouvant être compilé jusqu’à WASM. Actuellement, AssemblyScript (sous-ensemble de TypeScript) et RUST sont les plus pris en charge avec les chaînes d’outils appropriées.

AVIS DE NON-RESPONSABILITÉ : Cela vous prendra MOINS de 30 minutes si vous pouvez programmer en TypeScript.

Construire une WebApp sur le protocole NEAR (qui est exactement ce à quoi Near accède) est très facile par rapport aux autres blockchains.

Clonons le contre-exemple ici https://github.com/near-examples/counter

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

Nous ne nous soucions que de ces 2 dossiers et 1 fichierassembly/ est l’endroit où se trouve notre contrat intelligent (qui se compilera jusqu’à WASM).

src/ est l’endroit où va notre frontend code qui interagit avec le contrat.

package.json est l’endroit où vont nos dépendances JavaScript supplémentaires.

Le cœur de notre contrat comprend le stockage en chaîne, le contrôle de logging pour le reçu généré et les fonctions publiques exportées. Les fonctions qui définissent le stockage doivent être appelées sinon elles peuvent être visualisées (même sans compte NEAR).

Near prend en charge plusieurs types de collections (qui se décrivent elles-mêmes) sous le near-sdk-as.

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

Les principaux dont vous aurez besoin :

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

Je n’inclus pas persistentVector car vous devriez éviter de l’utiliser, il est très facile de brûler des tonnes de gaz à d’itération de vectors, essayez d’utiliser des ensembles chaque fois que possible.

Les valeurs par défaut des collections persistentMap doivent être suffixées avec !

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

logging.log imprimera le log output sur votre reçu lors de l’appel d’une fonction, ce qui est utile pour contrôler le flux de ce qui s’est passé, en particulier lorsque les contrats deviennent plus complexes. Un exemple de  minting contract lisible par l’homme peut avoir un message de log de « alice.near has minted 5,0 ZOD de zod.near ».

Déployons notre contrat, pour cela nous avons besoin de near-cli.

npm install near-cli -g

Et pour déployer, nous pouvons créer un compte dummy testnet. Les comptes sont des contrats et vous ne pouvez avoir qu’un seul contrat par compte. Pour créer plusieurs contrats, vous devez utiliser des sous-comptes, contract1.me.near, contract2.me.near.

Déployons et appelons la fonction getCounter.

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}'

Impressionnant.

Pour afficher une fonction, nous pouvons utiliser curl mais nous devons analyser une commandline output, il est plus simple d’écrire un script de nœud rapide. Nous n’avons même pas besoin d’un compte 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 se dénomme au 24, le yocto.

3_000_000_000_000__000_000_000_000

est de 3,0

Cela met fin à la première série ici, la suivante travaillerait avec une interface Web et comment obtenir correctement le balance, l’état et plus encore.

20
Retour haut de page