Wie entwickelt man auf dem NEAR Protocol? Ein Leitfaden

8 min read
To Share and +4 nLEARNs

Voraussetzungen:

Entwickler sind das Lebenselixier des Blockchain-Ökosystems. Damit die Blockchain-Technologie von der breiten Masse angenommen wird, müssen die Einstiegshürden für Entwickler gesenkt werden. So können sie unterhaltsame und ausgefeilte Anwendungen erstellen, an denen sich auch normale Leute erfreuen können. Genau aus diesem Grund sind die Smart Contracts von NEAR in AssemblyScript geschrieben, da es dem JavaScript sehr ähnlich ist.

Wenn Du also gerne auf dem NEAR Protocol entwickeln möchten, kannst die folgenden Tools verwenden:

  • JavaScript SDK. Verbinden, signieren, Transaktionen tätigen und deployen in jedem NEAR-Network aus jedem JS-Kontext
  • Rust Contract SDK. Erstelle sichere Contracts, die hochwertige Assets managen.
  • AssemblyScript Contract SDK. Lernen und Prototyping ohne Schwierigkeiten mit JS-Syntax
  • JSON RPC API. Die gesamte Kommunikation mit der Plattform läuft über diese API, einschließlich des
  • Command Line Interface. Voll funktionsfähiges Kommandozeilen-Toolkit für Entwickler
  • NEAR-Explorer. Ein Blockchain-Suchwerkzeug, mit dem Entwickler Transaktionsdetails, Accounts, Blockdetails und mehr anzeigen können
  • NEAR-Wallet. Erstellen von Accounts, Verwalten von Access Keys und mehr mit unserer benutzerfreundlichen UI und human-readable public keys
  • Nearup. Lokales Management von Deployments und Zugang zu jedem öffentlichen oder privaten Netzwerk
  • Rainbow Bridge. Schnelle, sichere Interoperabilität mit der Ethereum Blockchain
  • EVM. Ethereum-kompatible virtuelle Maschine.

Gut, lasst uns die ersten Schritte unternehmen.

Eine kurze Übersicht

Anwendungen auf NEAR haben zwei unterschiedliche Teile – ein Back-End und ein Front-End.

  • Smart Contract (Back-End): Speichern und Ändern von Daten auf der Blockchain. Contracts müssen Methoden deployen, die es den Clients ermöglichen, den Zustand zu „view“ und zu „change“ anzupassen.
  • Interaktionen mit Smart Contract (Front-End): Du kannst mit Deinen Contracts oder mit Contracts, die von anderen Personen bereitgestellt wurden, interagieren. Du tust dies, indem Du near-api-js Quickstart und Code Snippets in Deiner Anwendung verwendest.

Anwendungen auf NEAR bestehen aus zwei verschiedenen Teilen - einem Backend und einem Frontend. Das Backend ist das.....

Correct! Wrong!

Wie man Smart Contracts erstellt und bezeichnet.

NEAR unterstützt derzeit:

  • Rust – near-sdk-rs: Ein Wrapper, der die Sicherheit der Programmiersprache Rust für hochwertige Contracts verwendet, die nach WASM compiled werden.
  • AssemblyScript near-sdk-as: Eine Sammlung von Hilfsmitteln, die Ihre SmartContracts ähnlich wie TypeScript aussehen lassen, während sie für die Ausführung nach Wasm compiled werden.

HINWEIS: AssemblyScript wird derzeit nicht für produktive Finanzanwendungen empfohlen, da die Sprache und die verfügbaren Compilation Tools noch neu sind.

In Ordnung, legen wir los.

Einrichten des Testnet

Der einfachste Weg, einen Account bei NEAR zu erstellen, ist mit der NEAR Wallet. NEAR hat mehrere Development Networks, die unabhängig voneinander mit eigenen AccountIDs arbeiten. Folge den Schritten, um eine Wallet zu erstellen. Vergewissere Dich, dass Du die erforderlichen Schritte für Dein Sicherheits-Backup befolgt hast.

HINWEIS: Das Erstellen eines Accounts im Mainnet ist fast identisch mit dem Testnet, erfordert jedoch eine anfängliche Finanzierung des Kontos. Hier findest Du eine Anleitung zur Erstellung eines Mainnet-Kontos.

Beim Deployment spielt es keine Rolle, ob die Anwendung in Rust oder AssemblyScript geschrieben ist. Der gesamte Contract-Code wird in WebAssembly compiled und in das Netzwerk deployed, um in einer Wasm-kompatiblen virtuellen Maschine ausgeführt zu werden. Für die meisten Anwendungen wirst Du einen Befehl wie yarn dev verwenden, aber Du kannst eine Anwendung genauso einfach über NEAR CLI mit near dev-deploy für TestNet deployen (oder near deploy, wenn Du bereits einen Account erstellt hast).

Der gesamte Contract-Code wird in WebAssembly compiled und im Netz deployed, um in eienr _______ ausgeführt zu werden.

Correct! Wrong!

Mache nun Folgendes, um Dich aufzuwärmen:

  1. Schaue Dich  im NEAR Explorer um. Hier kannst du nach allen Transaktionen und Blöcken suchen, die auf NEAR erzeugt wurden. Versuche, nach dem Account zu suchen, den Du gerade erstellt hast, und sieh Dir die Transaktionen an, die Du erstellt hast.
  2. Installiere nun near-cli. Dies ist eine Command Line Interface, mit der Du nahtlos mit NEAR interagieren kannst. In den NEAR-Dokumenten findest Du alle near-cli-Befehle mit Beispielen.
  3. Versuche Deinen ersten Befehl auszuführen: near login. Dadurch wirst Du zu Deiner NEAR-Wallet weitergeleitet und die Keys Deines Testnet Accounts werden lokal gespeichert.

Nachdem Du das Testnet ausprobiert hast, kannst Du die lokale Node ausführen. Wenn du jedoch vorerst nur mit dem Code herumspielen möchtest ist es empfohlen, im Testnet zu bleiben.

Wie betreibe ich eine eigene Node?

Wie bei jedem Blockchain-basierten Ökosystem läuft das NEAR-Protokoll auf einer Sammlung von öffentlich betriebenen Computern (oder „Nodes“).

Du kannst sich aus verschiedenen Gründen dafür entscheiden, eine eigene Node zu betreiben:

  • Um Contracts auf einer mit dem MainNet, TestNet oder BetaNet verbundenen Node zu entwickeln und deployen.
  • Um Contracts auf einer lokalen (unabhängigen und isolierten) Node zu entwickeln und deployen (manchmal „LocalNet“ genannt).
  • Um einem Netzwerk als Validierer beizutreten, der eine „Validator Node“ betreibt

Da kannst NEAR betanet- und testnet-Nodes starten, indem Du nearup installierst. Befolge dazu die Anweisungen unter https://github.com/near/nearup

Wie jedes Blockchain-basierte Ökosystem läuft auch das NEAR-Protokoll auf einer Sammlung von öffentlich gewarteten Computern, die _______ genannt werden.

Correct! Wrong!

Betreiben einer offiziellen Node mit Docker

NEAR verwendet standardmäßig Docker, um den Client auszuführen. Als Erstes musst Du also Docker und Nearup installieren. Führe nun Dein System hiermit aus:

nearup betanet

(Wenn Du TestNet verwenden möchten, ersetze im obigen Befehl „betanet“ durch „testnet“)

Du wirst dann zur Eingabe einer Account-ID aufgefordert. Du kannst diese leer lassen, wenn Du nur eine Node ausführen möchtest. Validatoren sollten die Account-ID des Accounts verwenden, mit dem sie staken wollen. Anschließend musst Du diesen Code eingeben:

Gib Deine Ihre Account-ID ein (leer lassen, wenn Du kein Validator sein willst)

Nun wird Deine Node im Hintergrund mit Docker gestartet. Um die Protokolle innerhalb von Docker zu überprüfen, führe „docker logs -follow nearcore“ aus.

Einen einfachen Code auf NEAR erstellen

NEAR hat eine Liste von hilfreichen Programmen oder Beispielcodes, die Du einfach abrufen kannst. Der Code, den wir uns ansehen werden, ist das Guest Book. Mit diesem Programm kannst Du Dich bei NEAR anmelden und eine Nachricht in das Guest Book eintragen! Es handelt sich hierbei um eine Starter-App, die mit einem AssemblyScript-Backend und einem React-Frontend entwickelt wurde.

Einblick in den Guest Book Code

Um dieses Projekt lokal auszuführen, musst Du Folgendes sicherstellen.

  • Stelle sicher, dass Du Node.js ≥ 12 installiert hast (https://nodejs.org), dann installiere damit yarn: npm install -global yarn (oder einfach npm i -g yarn)
  • Installiere Dependencies: yarn install (oder einfach nur yarn)
  • Starte nun den Lokalen Development Server: yarn dev (siehe package.json für eine vollständige Liste der Skripte, die Du mit yarn ausführen kannst)

Jetzt hast Du eine lokale Entwicklungsumgebung, die durch das NEAR TestNet unterstützt wird! Wenn Du yarn dev ausführst, wird Dir die URL mitgeteilt, die Du in Deinem Browser aufrufen kannst, um die Anwendung zu sehen.

Oh, und stelle sicher, dass Du die GitHub-Seite geöffnet hast. 

Vielleicht findest Du auch dieses Video nützlich.

Den Code erforschen

Wie Du siehst, gibt es zwei Seiten des Codes – Backend und Frontend:

  • Der Backend-Code befindet sich im /assembly folder. Dieser Code wird auf der NEAR-Blockchain deployed, wenn Du yarn deploy:contract ausführst. Dies ist ein Smart Contract von NEAR.
  • Der Frontend-Code befindet sich im /src folder. /src/index.html ist ein guter Ort, um mit der Entdeckung zu beginnen. Beachte, dass der Code in /src/index.js geladen wird, wo Du lernen kannst, wie das Frontend mit der NEAR-Blockchain verbunden ist.

Der Backend Code

#1 Contract Data Model :  assembly/model.ts

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");

Analysis

@nearBindgen markiert die Klasse als serialisierbar. „Serializable“ ist ein Marker Interface, das verwendet wird, um Klassen zu „markieren“, so dass die Objekte dieser Klassen eine bestimmte Capability erhalten können.

Die Klasse „PostedMessage“ hat drei Eigenschaften –

  • Premium zur Kennzeichnung von Nachrichten mit angehängten NEAR-Tokens
  • Sender, um den Signer der Guest Book Message zu ermitteln
  • Text, um die Guest Book Message zu speichern

Schließlich ist „messages“ eine Sammlung von Guest Book Messages, die als ein PersistentVector von PostedMessage-Objekten gespeichert wird

#2 Contract Behavior :  assembly/main.ts

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

Analysis

MESSAGE_LIMIT wird verwendet, um unbegrenzte (d.h. potenziell teure) Aufrufe zum Abrufen von Guest Book Messages aus dem Storage zu vermeiden.

Wir verwenden in diesem Contract auch zwei verschiedene öffentliche Funktionen – addMessage() und getMessages()

Der Frontend Code

#1 Network Connection :  src/config.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;

Analysis

Der obige Code definiert die Daten und Endpunkte, die für die Verbindung mit dem NEAR-Netzwerk erforderlich sind. Die hier definierten Verbindungsinformationen sind sowohl für MainNet, TestNet und BetaNet als auch für die Standardkonfiguration LocalNet enthalten

#2 Configuration :  src/index.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')
    );
  });

Analysis

Dies ist das Kernstück des Frontend-Abschnitts bei der Konfigurierung der Verbindung zum NEAR-Netzwerk. Du kannst das Contract Interface konfigurieren, indem Du eine Wallet-Verbindung einrichtest und beide Contract-Methoden miteinander verbindest.

Deployen eines Smart Contracts

Jeder Smart Contract in NEAR hat sein eigenen, zugehörigen Account. Wenn Du yarn dev ausführst, werden Deine Smart Contracts mit einem temporären Account im NEAR TestNet deployed. Wenn Du diesen Account nun dauerhaft einrichten möchtest, musst Du Folgendes tun.

Schritt 0: near-cli installieren

So installierst Du near-cli global

npm install --global near-cli

Dadurch erhältst Du das Near-CLI-Tool. Stelle sicher, dass es mit installiert ist:

near --version

Schritt 1: Erstelle einen Account für den Contract

Besuche die NEAR Wallet und erstelle einen neuen Account. Du wirst diese Smart Contracts für diesen neuen Account deployen.

Autorisiere nun NEAR CLI für diesen neuen Account und folge den Anweisungen, die es Dir gibt:

near login

Schritt 2: Festlegen des Contract-Namens im Code

Ändere die Zeile in src/config.js, die den Account Namen des Contracts festlegt. Setze ihn auf die Account-ID, die Du oben verwendet hast.

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

Schritt 3: Ändere die Remote-URL, wenn Du dieses Repository geklont hast.

Wenn Du das Repository forkst, musst Du die Remote-URL in ein Repository ändern, auf das Du „commit“-Zugriff hast. Dies ermöglicht das automatische Deployment auf Github Pages über die Command Line.

Gehe zu GitHub und erstelle ein neues Repository für dieses Projekt.

Öffne Dein Terminal und gib im Root des Projekts Folgendes ein:

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

Schritt 4: Deploy!

Du brauchst nur den folgenden Befehl, um Deinen Smart Contract zu deployen:

yarn deploy

Dieser Befehl führt zwei Dinge aus:

  • Er erstellt Smart Contracts und deployed sie im NEAR TestNet.
  • Er erstellt und deployed den Code des Contract-Frontends auf GitHub mit gh-pages. Dies funktioniert nur, wenn für das Projekt bereits ein Repository auf GitHub eingerichtet wurde. Es steht Dir frei, das Deployment-Skript in package.json zu ändern, um es anderswo zu deployen.

Jeder Smart Contract in NEAR hat seinen eigenen, zugehörigen ____

Correct! Wrong!

Wie geht es weiter?

Nun, da Du weißt, wie man einen grundlegenden Code ausführt, möchtest Du vielleicht tiefer in NEAR einsteigen. Sieh Dir dazu die NEAR-Developer Docs an.

68
Scroll to Top