Erstellen eines Smart Contracts auf der NEAR Blockchain

5 min readFeb 18, 2024

In diesem Artikel zeigen wir euch, wie man einen einfachen Smart Contract auf der Near Protocol Blockchain entwickelt. Davor geben wir euch noch eine kurze Einführung zu den Eigenschaften der NEAR Smart Contracts.

Was ist ein Smart Contract?

Smart Contracts (auf Deutsch: Intelligente Verträge) sind Teile eines ausführbaren Codes, die in einem Account (Konto) gespeichert sind. Sie können Daten speichern, Transaktionen im Namen des Kontos durchführen und Methoden offenlegen, damit andere Konten mit ihnen interagieren können.

NEAR-Smart-Contracts haben folgende Eigenschaften:

Sie verfügen über begrenzte Rechenressourcen.
Sie interagieren asynchron mit anderen Verträgen.
Sie handeln mit echtem Geld, bei dem Sicherheit oberste Priorität haben muss.

Wo werden Smart Contracts bereitgestellt?

Smart Contracts werden in NEAR-Konten bereitgestellt. Jedes NEAR-Konto kann einen Vertrag enthalten und muss für den Vertragscode und die darin gespeicherten Daten bezahlen.

Sobald sie sich in einem Konto befinden, kann jeder mit dem Vertrag interagieren. Dank der zugrunde liegenden Netzwerkstruktur ist die Ausführung von Code aus einem Vertrag sowohl schnell (durchschnittlich 1,4 Sekunden Finality) als auch kostengünstig. Darüber hinaus sind Read-only Vorgänge (Lesevorgänge) für alle kostenlos.

Entwicklungablauf

Wie jede Software haben auch Smart Contracts einen Entwicklungsablauf — beginnend mit der Erstellung und endend mit dem Monitoring.

Der Entwicklungsablauf lässt sich wie folgt zusammenfassen:

Scaffold: Der einfachste Weg, ein Projekt zu erstellen, besteht darin, von einer Vorlage (Template) auszugehen.
Build: Um einen Vertrag zu schreiben, können Entwickler zwischen JavaScript und Rust wählen.
Test: Die NEAR Sandbox ermöglicht die Simulation von Interaktionen mit einem oder mehreren Verträgen in einer realistischen Umgebung.
Deploy: Nachdem sichergestellt wurde, dass der Vertrag sicher ist, können Entwickler den Vertrag in ihren Konten bereitstellen.
Use: Jeder Benutzer kann über sein NEAR Wallet mit dem Vertrag interagieren.
Monitoring: Die Vertragsaktivität kann über einfache APIs überwacht werden.

Unterstützte Sprachen
Während des gesamten Zyklus können Entwickler zwischen JavaScript und Rust wählen.

Nun kommen wir zu unserem kleinen Tutorial, wie man einen Smart Contract auf der NEAR Blockchain entwickelt.

Voraussetzungen

Stelle vor dem Start sicher, dass Folgendes installiert ist:

Node.js fürs Aufsetzen des Grundgerüsts
NEAR CLI oder NEAR CLI-RS, um den Vertrag bereitzustellen und mit ihm zu interagieren. Wir verwenden die NEAR CLI RS, da diese unserer Meinung nach angenehmer zu verwenden ist.

npm i -g near-cli-rs

(optional) Cargo-Near, um schnell und einfach Testnet-Konten zu erstellen. Wir werden in diesem Beispiel darauf verzichten, da wir den Smart Contract auf ein “offizielles” Konto im Testnet veröffentlichen möchten.

npm i -g cargo-near

(optional) Rust, um Rust-Verträge zu erstellen. Wir werden in unserem Beispiel den Smart Contract mit JavaScript erstellen, daher brauchen wir Rust nicht installieren.

Contract erstellen

Wir erstellen einen Smart Contract, indem wir das Scaffolding-Tool „Create-Near-App“ ausführen und dem interaktiven Menü folgen.

npx create-near-app@latest

“Smart Contract”
“JS/TS Contract” (wie bereits erwähnt, erstellen wir einen Smart Contract mit Javascript)
Beliebigen Projektnamen eingeben
Run “npm install” -> Yes. Die dazugehörigen NPM Packages werden installiert

Ist die Erstellung des Projektes durchgelaufen, sollte folgende Meldung erscheinen:

Wir wechseln in das Projektverzeichnis

cd <project-name>

Es wurde folgende Verzeichnisstruktur erstellt:

├── README.md
├── src
│   └── contract.ts # contract's code
├── sandbox-ts      # sandbox testing
│   ├── ava.config.cjs
│   ├── package.json
│   └── src
│       └── main.ava.ts
├── package.json    # package manager
└── tsconfig.json

Contract entwickeln

Wir werden in unserem einfachen Beispiel einen “Counter“-Contract entwickeln. Mit diesem Contract ist es möglich, eine Zahl, die im Contract gespeichert wird, zu inkrementieren, zu dekrementieren und zurückzusetzen.

import { NearBindgen, near, call, view } from 'near-sdk-js';


@NearBindgen({})
class Counter {
  val: number = 0;

  @view({}) // Public read-only method: Returns the counter value.
  get_num(): number {
    return this.val
  }

  @call({}) // Public method: Increment the counter.
  increment() {
    this.val += 1;
    near.log(`Increased number to ${this.val}`)
  }

  @call({}) // Public method: Decrement the counter.
  decrement() {
    this.val -= 1;
    near.log(`Decreased number to ${this.val}`)
  }

  @call({}) // Public method - Reset to zero.
  reset() {
    this.val = 0;
    near.log(`Reset counter to zero`)
  }
}

Smart Contract bauen und testen

Im von der „Create-Near-App“ generierten “package.json” nennen wir das Projekt auf “counter” um.

{
  "name": "counter",
  "version": "1.0.0",
  "license": "(MIT AND Apache-2.0)",
  "type": "module",
  "scripts": {
    "build": "near-sdk-js build src/contract.ts build/counter.wasm",
    "test": "$npm_execpath run build && cd sandbox-ts && $npm_execpath run test -- -- ../build/counter.wasm",
    "postinstall": "cd sandbox-ts && $npm_execpath install"
  },
  "dependencies": {
    "near-cli": "4.0.0",
    "near-cli-rs": "^0.7.8",
    "near-sdk-js": "1.0.0"
  },
  "devDependencies": {
    "ts-morph": "^20.0.0",
    "typescript": "^5.2.2"
  }
}

Anschließend bauen wir den Contract:

npm run build

Es wurde ein Ordner “build” mit folgender Struktur erstellt:

├── builder.c
├── code.h
├── counter.js      
├── counter.js.map  
├── counter.wasm
└── methods.h

Test Account erstellen

Wie oben erwähnt wird ein Smart Contract immer in einem NEAR Konto gespeichert. Hierfür erstellen wir einen Konto im Testnet von NEAR.

Wir verwenden hier den Account: “near-deutsch.testnet”

Ein Test Account kann zum Beispiel hier erstellt werden: https://testnet.mynearwallet.com/

Alternativ kann mit Cargo ein zufälliges Testkonto erstellt werden:

cargo-near near create-dev-account use-random-account-id autogenerate-new-keypair save-to-legacy-keychain network-config testnet create

Contract veröffentlichen (deployen)

Mit der NEAR CLI RS veröffentlichen wir unseren Smart Contract.

near

Es öffnet sich eine interaktive CLI:

“contract”
“deploy”
Account ID: Testkonto ID auswählen
File Location: “build/counter.wasm”
“without-init-call”
“testnet”
Transaktion signieren (je nach Präferenz eine Möglichkeit auswählen)
“send”

Wenn der Contract erfolgreich deployt wurde, sollte folgende Meldung erscheinen:

Contract testen

Zum Schluss probieren wir noch unseren veröffentlichten Contract

Wir verwenden dazu wieder die NEAR CLI RS

near

Es öffnet sich eine interaktive CLI:

“contract”
“call-function”
“as-read-only” (wir wollen die View-Methode “get_num” aufrufen, um den aktuellen Wert des counters zu sehen)
Contract Account ID auswählen
Methodenname: “get_num”
“Text args” (wir übergeben in diesem Fall aber keine Argumente)
Keine Argumente
Block view: “now”

Konten wir die Methode get_num erfolgreich aufrufen, erhalten wir folgendes Ergebnis: