Comment développer sur NEAR ? Guide de démarrage

Les développeurs sont la pierre angulaire de l’écosystème blockchain. Pour que la technologie blockchain soit adoptée par le grand public, elle doit abaisser les barrières à l’entrée pour les développeurs et leur permettre de créer des applications amusantes et sophistiquées pour le plaisir des gens ordinaires. C’est pour cette raison même que les contrats intelligents de NEAR sont écrits en utilisant AssemblyScript en raison de sa similitude avec JavaScript.

Donc, si vous êtes désireux de construire sur NEAR, vous pouvez utiliser les outils suivants :

• SDK JavaScript. Connectez-vous, signez, effectuez des transactions et déployez sur n’importe quel réseau NEAR à partir de n’importe quel contexte JS
• Kit de développement logiciel antirouille. Construisez des contrats sûrs et sécurisés qui gèrent des actifs de grande valeur
• Kit de développement logiciel de contrat AssemblyScript. Apprenez et prototypez sans friction en utilisant la syntaxe JS
• API RPC JSON. Toutes les communications avec la plateforme passent par cette API y compris la nôtre
• Interface de ligne de commande. Boîte à outils de ligne de commande complète pour les développeurs et les validateurs
• NEAR de l’explorateur. Un outil de recherche blockchain permettant aux développeurs d’afficher les détails des transactions, les comptes, les détails des blocs et plus encore
• NEAR Portefeuille. Créez des comptes, gérez les clés d’accès et plus encore avec notre interface utilisateur conviviale
• nearup. Gérez les déploiements localement et rejoignez n’importe quel réseau public ou privé
• Pont. Interopérabilité rapide et sécurisée
• EVM. Machine virtuelle compatible Ethereum.

Bon, faisons les premiers pas.

Un bref aperçu

Les applications sur NEAR comportent deux parties distinctes : un back-end et un front-end.

• Smart Contract (back-end) : Stockage et modification des données sur la chaîne. Les contrats doivent exposer des méthodes qui permettent aux clients de « visualiser » et de « modifier » l’état.
• Interactions avec Smart Contract (front-end) : Vous pouvez interagir avec vos contrats ou les contrats déployés par d’autres personnes. Pour ce faire, utilisez le démarrage rapide et les extraits de code near-api-js dans votre application.

Comment créer et appeler des contrats intelligents

NEAR prend actuellement en charge :

• Rust — near-sdk-rs : un wrapper qui améliore la sécurité du langage de programmation Rust pour les contrats de grande valeur.
• AssemblyScript near-sdk-as : Une collection d’aides qui font que vos SmartContracts ressemblent à TypeScript lors de la compilation vers Wasm pour l’exécution.

REMARQUE : AssemblyScript n’est actuellement pas recommandé pour les applications financières de production en raison de la nouveauté du langage et des outils de compilation disponibles.

Bon, soyons sérieux.

Configuration de Testnet

Le moyen le plus simple de créer un compte sur NEAR est avec NEAR Wallet. NEAR dispose de plusieurs réseaux de développement fonctionnant indépendamment les uns des autres avec leurs propres identifiants de compte. Allez, suivez les étapes pour créer un portefeuille. Assurez-vous d’avoir suivi les étapes requises pour votre sauvegarde de sécurité.

REMARQUE : La création d’un compte sur le réseau principal est presque identique à celle de testnet, mais nécessitera un financement initial pour le compte. Voici un guide de création de compte sur le réseau principal.

Peu importe, lors du déploiement, que l’application soit écrite en Rust ou en AssemblyScript. Tout le code du contrat est compilé dans WebAssembly et déployé sur le réseau pour être exécuté dans une machine virtuelle compatible Wasm. Vous utiliserez une commande telle que fil dev pour la plupart des applications, mais vous pouvez tout aussi facilement déployer une application à l’aide de NEAR CLI avec Near dev-deploy pour TestNet (ou Near deploy si vous avez déjà créé un compte).

Maintenant, procédez comme suit pour vous réchauffer :

1. Regardez autour de vous dans NEAR Explorer. Ici, vous pouvez rechercher toutes les transactions et tous les blocs produits sur NEAR. Essayez de rechercher le compte que vous venez de créer et de voir les transactions que vous avez créées.
2. Installez maintenant near-cli. Il s’agit d’une interface en ligne de commande qui vous permet d’interagir de manière transparente avec NEAR. Cette documentation NEAR contient toutes les commandes near-cli avec des exemples.
3. Essayez d’exécuter votre première commande : near login. Cela vous redirigera vers votre portefeuille NEAR et enregistrera vos clés de compte testnet localement.

Après avoir consulté le testnet, vous pouvez vous sentir libre d’exécuter votre nœud local. Cependant, si vous voulez juste jouer avec les codes, nous vous suggérons de vous en tenir au testnet.

Comment exécuter un nœud ?

Comme pour tout écosystème basé sur la blockchain, le protocole NEAR s’exécute sur un ensemble d’ordinateurs publics (ou « nœuds »).

Vous pouvez décider d’exécuter votre propre nœud pour plusieurs raisons:

• Pour développer et déployer des contrats sur un nœud connecté à MainNet, TestNet ou BetaNet
• Développer et déployer des contrats sur un nœud local (indépendant et isolé) (parfois appelé « LocalNet »).
• Pour rejoindre un réseau en tant que validateur exécutant un « nœud de validation »

Vous pouvez lancer NEAR betanet et testnet nodes en installant Nearup. Vous pouvez le faire en suivant les instructions sur

https://github.com/near/nearup

Exécuter un nœud officiel à l’aide de Docker

Par défaut, NEAR utilise Docker pour exécuter le client. Donc, la première chose à faire est d’installer Docker et à proximité. Maintenant, lancez votre système avec ceci :

nearup betanet

(Si vous préférez utiliser TestNet, remplacez simplement betanet par testnet dans la commande ci-dessus)

Vous serez alors invité à entrer un identifiant de compte. Vous pouvez laisser ce champ vide si vous souhaitez simplement exécuter un nœud. Les validateurs doivent utiliser l’ID de compte du compte avec lequel vous souhaitez jouer. Ensuite, vous devez entrer ce code :

Entrez votre identifiant de compte (laissez vide si vous ne voulez pas être un validateur)

Maintenant, votre nœud démarrera alors en arrière-plan avec Docker. Pour vérifier les journaux dans Docker, exécutez docker logs — suivez nearcore.

Créer un code simple sur NEAR

NEAR propose une liste de programmes utiles ou d’exemples de codes que vous pouvez consulter facilement. Le code que nous allons vérifier est donc le GuestBook. L’utilisation du programme vous permet de vous connecter avec NEAR et d’ajouter un message au livre d’or ! Une application de démarrage construite avec un backend AssemblyScript et un frontend React.

Recherche dans le code du GuestBook

Pour exécuter ce projet localement, vous devez vous assurer des points suivants.

• Assurez-vous que Node.js ≥ 12 est installé (https://nodejs.org), puis utilisez-le pour installer le fil : npm install –global fil (ou simplement npm i -g fil)
• Dépendances d’installation : installation de fil (ou simplement fil)
• Exécutez le serveur de développement local : fil dev (voir package.json pour une liste complète des scripts que vous pouvez exécuter avec fil)

Vous disposerez désormais d’un environnement de développement local soutenu par NEAR TestNet ! L’exécution de fil dev vous indiquera l’URL que vous pouvez visiter dans votre navigateur pour voir l’application.

Oh et assurez-vous que la page GitHub est ouverte.

Vous pouvez également trouver cette vidéo utile.

Explorer le code

Comme vous pouvez le voir, il y a deux côtés au code — backend et frontend :

• Le code backend réside dans le dossier /assembly. Ce code est déployé dans la blockchain NEAR lorsque vous exécutez fil deploy:contract. Il s’agit d’un contrat NEAR smart.
• Le code frontal réside dans le dossier /src. /src/index.html est un excellent endroit pour commencer à explorer. Notez qu’il se charge dans /src/index.js, où vous pouvez apprendre comment le frontend se connecte à la blockchain NEAR.

Backend Code

#1 Contract Data Model :  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]

Analyses :

@nearBindgen marque la classe comme sérialisable. Serializable est une interface marqueur utilisée pour « marquer » les classes afin que les objets de ces classes puissent obtenir une certaine capacité.

La classe “PostedMessage” a trois fonctionnalités –

• premium pour signaler les messages avec des jetons NEAR attachés
• l’expéditeur pour suivre le signataire du message du livre d’or
• texte pour tenir le message du livre d’or

Enfin, « messages » est une collection de messages du livre d’or stockés en tant que PersistentVector d’objets PostedMessage

#2 Contract Behavior :  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]

Analyses:

MESSAGE_LIMIT est utilisé pour éviter les appels illimités (c’est-à-dire potentiellement coûteux) pour récupérer les messages du livre d’or du stockage
Nous utilisons également deux fonctions publiques différentes dans ce contrat — addMessage () et getMessages ()

Frontend Code

#1 Network Connection :  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]

Analyses

Les informations de connexion définies ici sont incluses pour MainNet, TestNet et BetaNet ainsi que la configuration LocalNet par défaut.

#2 Configuration :  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]

Analyses:

C’est la viande et les pommes de terre de la section frontend, lorsque vous configurez la connexion au réseau NEAR. Vous pouvez configurer l’interface de contrat en injectant une connexion au portefeuille et en connectant les deux méthodes de contrat.

Déployer un contrat intelligent

Chaque contrat intelligent dans NEAR a son propre compte associé. Lorsque vous exécutez fil dev, vos contrats intelligents sont déployés sur le NEAR TestNet en direct avec un compte temporaire. Si vous souhaitez maintenant le rendre permanent, voici ce que vous devez faire.

Étape 0 : Installer near-cli

Voici comment vous installez globalement near-cli

npm install --global near-cli

Cela vous donnera l’outil CLI NEAR. Assurez-vous qu’il est installé avec :

near --version

Étape 1 : Créer un compte pour le contrat

Visitez NEAR Wallet et créez un nouveau compte. Vous allez commencer ces contrats intelligents sur ce nouveau compte.
Autorisez maintenant NEAR CLI pour ce nouveau compte et suivez les instructions qu’il vous donne :

near login

Étape 2 : Définir le nom du contrat dans le code

Modifiez la ligne dans src/config.js qui définit le nom de compte du contrat.

Définissez-le sur l’identifiant de compte que vous avez utilisé ci-dessus.

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

Étape 3 : modifiez l’URL distante si vous avez cloné ce dépôt

Si vous forkez le référentiel, vous devrez changer l’URL distante en un référentiel auquel vous avez un accès « commit ». Cela permettra le déploiement automatique sur les pages Github à partir de la ligne de commande.

1. Accédez à GitHub et créez un nouveau référentiel pour ce projet.
2. Ouvrez votre terminal et à la racine de ce projet entrez ce qui suit:

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

Étape 4 : Déployez!

Vous avez juste besoin de la commande suivante pour déployer votre contrat intelligent :

yarn deploy

Cette commande fait deux choses :

• Construit et déploie des contrats intelligents sur NEAR TestNet
• Construit et déploie le code du contrat frontal sur GitHub à l’aide de gh-pages. Cela ne fonctionnera que si le projet a déjà un référentiel configuré sur GitHub. N’hésitez pas à modifier le script de déploiement dans package.json pour le déployer ailleurs.

Et ensuite ?

D’accord, maintenant que vous savez comment exécuter un code de base, vous voudrez peut-être approfondir NEAR. Pour cela, consultez la documentation des développeurs de NEAR.