Lisk umożliwia stworzenie aplikacji opartej o własny blockchain w języku programowania Javascript. Z chwilą opublikowania Alpha SDK możliwe stało się prototypowanie pierwszych aplikacji wykorzystując Liska. Technologia jest wyczekiwana przez inwestorów projektu od długiego czasu. W tym artykule przejdę przez proces zainstalowania Liska i wszystkich składowych technologii w systemie oraz stworzę i uruchomię własny blockchain.

Jak wygląda proces stworzenia aplikacji opartej o Lisk Alpha SDK?
Jak wygląda kod aplikacji i własnego blockchaina?
Jakie są możliwości i potencjał technologii tworzonej przez Lisk?

Krytycznym inżynierskim okiem przyjrzę się komponentom Lisk SDK, możliwościach produktu, widocznych wadach i zaletach.

Przygotowanie środowiska

Lisk SDK to tak naprawdę biblioteki programistyczne i narzędzia umożliwiające zaprogramowanie własnego blockchaina. Składowych wymaganych do stworzenia kompletnej aplikacji opartej o Lisk jest więcej i są to technologie istniejące i wykorzystywane na rynku od lat.

Przygotowanie środowiska polega na zainstalowaniu i skonfigurowaniu niezbędnych komponentów docelowej aplikacji Lisk w systemie operacyjnym. Przygotuję środowisko wg instrukcji opublikowanej przez Lisk. Wspierane systemy operacyjne to aktualnie Ubuntu (Linux) oraz MacOS. Ja jednak pracuję na systemie operacyjnym Arch Linux, więc niektóre kroki będą wykonane trochę w inny sposób niż w instrukcji Lisk’a.

Instalacja PostgreSQL

PostgreSQL to uniwersalna relacyjna baza danych. Wykorzystywana przez Liska do przechowywania danych dotyczących blockchaina (np. informacje o kontach, blokach, itp.). Lisk w swoim tutorialu przedstawia instalację Postgresa bezpośrednio w systemie operacyjnym oraz wersję drugą – opartą o obrazy dockerowe. Ja wykorzystam gotowe obrazy dockerowe bazy danych Postgres. Zaletą tego rozwiązania jest fakt, że baza danych istnieje tylko w uruchomionym kontenerze, który po zatrzymaniu (wyłączeniu komputera) znika. Nie mieszam więc nic w lokalnym systemie. Wykorzystam narzędzie docker compose do uruchomienia obrazów dockerowych. Skrypt docker compose’owy wygląda następująco (zapisany jako plik postgres.yaml).

version: '3.1'
networks:
  pgnet:
services:
  postgres:
    container_name: postgres
    image: postgres:12-alpine
    restart: always
    environment:
      POSTGRES_PASSWORD: pass1234
      POSTGRES_USER: lisk
      POSTGRES_DB: lisk_dev
    ports:
      - 5432:5432
    networks:
      - pgnet

  adminer:
    image: adminer
    restart: always
    ports:
      - 9000:8080
    networks:
      - pgnet

Wykorzystując powyższy skrypt, uruchomienie bazy danych Postgres sprowadza się do (bash):

docker-compose -f postgres.yaml up

Instalacja Node.js

Node.js to środowisko uruchomieniowe języka Javascript, wykorzystywane głównie jako serwer webowy (aplikacje internetowe). Node.js to środowisko uruchamiające tworzony przez nas blockchain – przetwarza całą logikę programu komputerowego jakim jest blockchain. Do instalacji serwera Node.js wykorzystam narzędzie nvm, zgodnie zresztą z instrukcją instalacyjną Lisk’a. Narzędzie to jest menadżerem wersji Node’a, dzięki czemu mamy możliwość przełączania się między wersjami. Jest to przydatne zwłaszcza w normalnej pracy z Node’em, gdzie często aplikacje bazują na innej wersji serwera. Wg dokumentacji wymagana wersja Node.js dla Lisk’a to 10.15.3, która jest jedną z ostatnich wersji Node.js 10. Mając więc narzędzie nvm w swoim systemie wywołuję w bashu:

nvm install 10.15.3

Instalacja lisk-sdk

lisk-sdk to serce aplikacji tworzonej w Lisku: narzędzia developerskie i biblioteka agregująca całą logikę niezbędną do stworzenia i uruchomienia własnego blockchaina. Aktualnie składa się z 3 komponentów: Lisk Framework, Lisk Elements, Lisk Commander. Lisk Elements i Framework to biblioteki programistyczne, natomiast Lisk Commander to narzędzie konsolowe. Biblioteki programistyczne zaimplementowane są w języku Javascript. Wszystkie biblioteki Liska dostępne są w jednej paczce lisk-sdk, dostępnej w repozytorium npm. Mimo, że w instrukcji przygotowania środowiska znajduje się krok instalacji tej paczki – ja zrobię to dopiero tworząc przykładową aplikację. Dzięki temu paczka będzie zainstalowana w folderze projektu, a nie gdzieś w systemie.

Uwagi do przygotowania środowiska i technologii

• wspierane tylko Ubuntu i MacOS – dokumentacja sugeruje, że wspierane są tylko 2 systemy operacyjne. Ta informacja jest odstraszająca, myląca i mam nadzieję, że wkrótce zniknie. API powinno być maksymalnie agnostyczne co do systemu. W przypadku Liska technologie składowe, jakie wykorzystuje są dostępne na różne systemy operacyjne. Niedopuszczalna jest sytuacja, w której w przyszłości Lisk będzie faworyzował jakikolwiek z systemów. To już nawet nie jest prawda na ten moment, ponieważ bez problemu zainstalowałem wszystko co potrzebne w systemie operacyjnym Arch Linux.
• stara wersja Node.js – wspierana wersja to 10.15.3, tymczasem aktualnie najnowsza wersja Node.js to generacja 12. Miejmy nadzieję Lisk wkrótce podwyższy zależności.
• myląca instrukcja dotycząca lisk-sdk – instalacja tej paczki na własny system operacyjny raczej nie powinna znajdować się w opisie przygotowania środowiska. Po pierwsze jest to mylące – paczka jest niepotrzebna w bezpośrednio w systemie. Nie zawiera ona narzędzia (Lisk Commander), które miałoby być dostępne globalnie w systemie, więc instalacja globalnie jest zbędna. Instalacja zależności aplikacji standardowo powinna (i tak będzie w moim przypadku) ograniczać się do konfiguracji tworzonej aplikacji (dzięki czemu całość jest bardziej zhermetyzowana, a zależności należą do projektu).

Cashback App – tworzę przykładową aplikację Lisk

Mając przygotowane środowisko, mogę teraz stworzyć i uruchomić własną aplikację Lisk, opartą o swój blockchain. Będę bazował na referencyjnej aplikacji Lisk’a, czyli Cashback App.

Ściągnięcie i instalacja źródeł projektu

Aby pobrać kod źródłowy aplikacji, należy pobrać ją z repozytorium Github. Wykorzystam narzędzie git i sklonuję zdalne repozytorium na własny system:

git clone https://github.com/LiskHQ/lisk-sdk-examples

Pobrany zostaje folder lisk-sdk-examples (70 MB, bardzo dużo). Przejdźmy do docelowego katalogu:

cd lisk-sdk-examples/cashback/

Instalujemy zależności (upewniając się, że pracujemy na wersji Node.js 10.15.3)

npm install

Powyższa komenda pobiera wszystkie zależności – czyli niezbędne biblioteki wymagane do uruchomienia tworzonej aplikacji. Mowa tu o tych stworzonych bezpośrednio przez Lisk’a, ale też o tych wykorzystywanych przez biblioteki Lisk’a. Po wykonaniu tej operacji, wszystkie niezbędne pliki wymagane do uruchomienia aplikacji są już dostarczone.

Struktura projektu

Struktura projektu składa się z kilku plików i folderów. Kilka z nich stanowi standardową część konfiguracji projektu opartego o Node.js. Na kod aplikacji blockchianowej, którą tworzymy składają się 3 pliki: index.js, cashback_transaction.js, print_sendable_cashback.js.

Tworzymy własny blockchain

Kod inicjalizujący i uruchamiający blockchain znajduje się w pliku index.js. Tak prezentuje się zawartość tego pliku:

// importy odpowiednich klas i konfiguracji z Lisk SDK
const { Application, genesisBlockDevnet, configDevnet } = require('lisk-sdk');
const CashbackTransaction = require('./cashback_transaction');

// konifugracja aplikacji - nazwa
configDevnet.app.label = 'Cashback-blockchain-app';
// konifugracja hasła do bazy danych
configDevnet.components.storage.password = 'pass1234';

// stworzona instacja aplikacji
const app = new Application(genesisBlockDevnet, configDevnet);

// rejestracja własnego typu transakcji Cashback
app.registerTransaction(CashbackTransaction);

// uruchomienie aplikacji, inicjalizacja blockchaina
app
  .run()
  .then(() => app.logger.info('App started...'))
  .catch(error => {
    console.error('Faced error in application', error);
    process.exit(1);
  });

Zmieniłem hasło bazy danych (zmienna configDevnet.components.storage.password) aby pasowało do hasła bazy, którą uruchamiam. Jak widać kod jest bardzo minimalistyczny i hermetyczny. Brak w tym kodzie wyraźnego pojęcia blockchain – tak naprawdę programujemy Aplikację (klasa Application oraz powstały obiekt app). Warto zwrócić uwagę, że nie ma tu żadnej mowy sidechainach – tak naprawdę nie tworzymy tutaj żadnego bocznego łańcucha pozostającego w relacji z głównym blockchainem Lisk Core, tylko całkowicie niezależny blockchain. W celu zainicjalizowania obiektu app klasy Application wykorzystujemy 2 inne obiekty zaimportowane bezpośrednio z lisk-sdk. Reprezentują one odpowiednio genesis block (pierwszy blok), oraz wstępną, podstawową konfigurację. Całość jest o tyle łatwa do stworzenia, że możemy oprzeć się na gotowej konfiguracji i wedle własnych potrzeb ją zmieniać – co niewątpliwie ułatwia rozpoczęcię pracy z Liskiem.

W stworzonej aplikacji, w stworzonym blockchainie rejestrujemy własny typ transakcji, jaki będzie przez ten blockchain obsługiwany: CashbackTransaction. Jego definicja znajduje się w drugim z kluczowych plików tworzonej aplikacji: cashback_transaction.js. Jego zawartość:

const {
  transactions: { TransferTransaction },
  BigNum,
} = require('lisk-sdk');


class CashbackTransaction extends TransferTransaction {

  // typ transakcji, 1-9 są zarezerwowane przez Lisk'a
  static get TYPE () {
    return 11;
  };

  // opłata za transakcję
  static get FEE () {
    return `${10 ** 7}`;
  };

  
  applyAsset(store) {
    const errors = super.applyAsset(store);

    const sender = store.account.get(this.senderId);
    
    // aktualizacja ilości tokenów wysyłającego
    // otrzyma on 10% wysyłanej kwoty
    const updatedSenderBalanceAfterBonus = new BigNum(sender.balance).add(
      new BigNum(this.amount).div(10)
    );
    const updatedSender = {
      ...sender,
      balance: updatedSenderBalanceAfterBonus.toString(),
    };
    store.account.set(sender.address, updatedSender);

    return errors;
  }

  undoAsset(store) {
    const errors = super.undoAsset(store);

    const sender = store.account.get(this.senderId);
    const updatedSenderBalanceAfterBonus = new BigNum(sender.balance).sub(
      new BigNum(this.amount).div(10)
    );
    const updatedSender = {
      ...sender,
      balance: updatedSenderBalanceAfterBonus.toString(),
    };
    store.account.set(sender.address, updatedSender);

    return errors;
  }
}

module.exports = CashbackTransaction;

Klasa CashbackTransaction jest transakcją transferującą (w tym przypadku natywną kryptowalutę tworzonego blockchaina, nazwijmy ją LSK2). Chcąc stworzyć transakcję, która będzie się zachowywała w pewien określony i zdefiniowany przez nas sposób – tworzymy nowy typ transakcji, który rozszerza możliwości podstawowego typu transakcji, jakim jest TransferTransaction (zgodnie z mechaniką programowania obiektowego). Taki model programowania pozwala nam rozszerzać działanie blockchainowych komponentów, zamiast definiować ich działanie od podstaw. Jest to na pewno prostsze i szybsze, niż projektowanie wszystkiego od podstaw. Można by zapytać – czy tak będzie wyglądać cały proces tworzenia bardziej złożonych aplikacji opartych o Lisk? Na to wygląda. Warto podkreślić, że tak naprawdę Lisk Core, czyli główny blockchain Lisk’a (z kryptowalutą LSK) – jest niczym innym, niż aplikacją stworzoną przy użyciu Lisk SDK. Tak więc te bazowe komponenty są dokładnie tym samym kodem, który przetwarzany jest przez wszystkie węzły w obecnej sieci Lisk blockchain. Ich działanie jest więc adekwatne do działania produkcyjnej sieci Lisk.

Transakcja transferu w Lisku polega na przesłaniu środków z jednego konta na drugie, pobierając za tą operację stosowną opłatę (to funkcjonalność TransferTransaction). CashbackTransaction zmienia tą logikę, wprowadzając pewną modyfikację: wysyłający otrzymuje 10% kwoty, którą wysyła, np. Bob (posiadający 100 tokenów) wysyłając Alicji (posiadjącej 0 tokenów) 100 tokenów, dostanie 10 tokenów za darmo. Ostatecznie Alicja będzie mieć 100 tokenów, a Bob 10. Dodane tokeny są “stworzone” – nowe.

Tworzona przez nas aplikacja blockchainowa została skonfigurowana, tak aby domyślnie realizować transakcję typu CashbackTransaction (zamiast klasycznej transakcji). Za rejestrację tego konkretnego typu transakcji w tworzonej aplikacji odpowiada poniższa linia (plik cashback_transaction.js):

app.registerTransaction(CashbackTransaction);

Uruchomienie aplikacji

Uruchomienie aplikacja sprowadza się do komendy (bash):

node index.js

Logi konsoli są następujące:

Uruchomiony blockchain działa – generuje bloki w określonych interwałach czasowych. Moja aplikacja jest jedynym “węzłem” stworzonej sieci blockchain, całe więc przetwarzanie blockchaina ogranicza się do procesu Node.js, który uruchomiłem.

Interakcja z blockchainem

Ostatni z trzech wymienionych plików to print_sendable_cashback.js. Plik ten zawiera prostą logikę przygotowania transakcji przesyłającej środki – w formcie JSON. Transakcja przesyła 2 tokeny LSK2 na konto odbiorcy. Skrypt ten drukuje transakcję na wyjście standardowe.

const CashbackTransaction = require('../cashback_transaction');
const transactions = require('@liskhq/lisk-transactions');
const { EPOCH_TIME } = require('@liskhq/lisk-constants');


/**
 *  To directly send the printed transaction:
 *  > node print_sendable_cashback.js | curl -X POST -H "Content-Type: application/json" -d @- localhost:4000/api/transactions
 *  Note: An node needs to run on port 4000 (the default one) before. If the node runs on a different port, adjust the query accordingly.
 */

const getTimestamp = () => {
    // check config file or curl localhost:4000/api/node/constants to verify your epoc time
    const millisSinceEpoc = Date.now() - Date.parse(EPOCH_TIME);
  const inSeconds = ((millisSinceEpoc) / 1000).toFixed(0);
  return  parseInt(inSeconds);
};

// Tworzymy transakcję typu CashbackTransaction
const tx = new CashbackTransaction({
    // wyślij 2 tokeny (skonwertowane do najmniejszej jednostki w Lisku)
    amount: `${transactions.utils.convertLSKToBeddows('2')}`,
    fee: `${transactions.utils.convertLSKToBeddows('0.1')}`,
    recipientId: '10881167371402274308L', //delegate genesis_100
    timestamp: getTimestamp(),
});

tx.sign('wagon stock borrow episode laundry kitten salute link globe zero feed marble');

console.log(tx.stringify());
process.exit(1);

Jak widać w komentarzu, możemy uruchomić skrypt i od razu przekazać rezultat jego wykonania do narzędzia curl, które wyśle zapytanie HTTP do tworzonej aplikacji. Komunikacja z węzłem blockchaina jest oparta o protokół HTTP. Zapytanie to powinno zostać przetworzone przez nasza aplikację i powinno skutkować wysłaniem transakcji. Zanim to jednak zrobię sprawdźmy ilość tokenów posiadanych przez odbiorcę, jego ID to 10881167371402274308L. Wywołuję zapytanie:

curl -X GET "http://localhost:4000/api/accounts?address=10881167371402274308L"

Rezultat:

{
  "meta": {
    "offset": 0,
    "limit": 10
  },
  "data": [
    {
      "address": "10881167371402274308L",
      "publicKey": "addb0e15a44b0fdc6ff291be28d8c98f5551d0cd9218d749e30ddb87c6e31ca9",
      "balance": "0",
      "secondPublicKey": "",
      "asset": {},
      "delegate": {
        "username": "genesis_100",
        "vote": "10000000000000000",
        "rewards": "0",
        "producedBlocks": 0,
        "missedBlocks": 0,
        "rank": 70,
        "productivity": 0,
        "approval": 100
      }
    }
  ],
  "links": {}
}

Stan rachunku (balance) wynosi 0. Wywołuję transakcję:

node print_sendable_cashback.js | curl -X POST -H "Content-Type: application/json" -d @- localhost:4000/api/transactions

Rezultat wykonania sugeruje sukces:

{"meta":{"status":true},"data":{"message":"Transaction(s) accepted"},"links":{}}

Ponowne sprawdzenie rachunku odbiorcy zwraca rezultat:

{
  "meta": {
    "offset": 0,
    "limit": 10
  },
  "data": [
    {
      "address": "10881167371402274308L",
      "publicKey": "addb0e15a44b0fdc6ff291be28d8c98f5551d0cd9218d749e30ddb87c6e31ca9",
      "balance": "200000000",
      "secondPublicKey": "",
      "asset": {},
      "delegate": {
        "username": "genesis_100",
        "vote": "10000000000000000",
        "rewards": "0",
        "producedBlocks": 2,
        "missedBlocks": 0,
        "rank": 70,
        "productivity": 100,
        "approval": 100
      }
    }
  ],
  "links": {}
}

Niestety ponieważ aktualnie dokumentacja Lisk’a jest bardzo niepełna, nie udało mi się znaleźć sposobu na łatwą identyfikację adresu wysyłającego. Docelowo do tego celu (łatwej interakcji z siecią blockchain) służyć będzie narzędzie Lisk Commander, które aktualnie wspiera interakcję z główną siecią Lisk’a. Podpisanie transakcji sprowadza się aktualnie do wpisania 12 słów identyfikujących konto, podobnie jak to ma miejsce przy logowaniu się do portfela Lisk – więc nie znamy adresu nadawcy. Sposób w jaki zweryfikuję stan konta wysyłającego, to identyfikacja stanu rachunku w bazie danych lisk_dev (w PostgreSQL). W stworzonej bazie danych znajduje się tabela mem_accounts. Zapytanie zwracające jej wiesze:

Na screenie widać, że stan rachunku konta o adresie 10881167371402274308L wynosi 200000000, co tak naprawdę oznacza wartość 2 tokenów. Drugi wiersz tabeli, który nie ma zdefiniowanej nazwy użytkownika (username), posiada 99999998,1 tokenów co zgadzałoby się z oczekiwanym wynikiem (99999999 to stan najwyraźniej stan początkowy konta nadawcy, 2 tokeny zostały wysłane, 0.1 to koszt transakcji, natomiast zwrócone z transakcji cashback zostało 0.2 tokena => -2 – 0.1 + 0.2 = 0.1). Wywołałem ponownie transakcję i po transakcji: wiersz 2 – 9999999620000000, konto o adresie 10881167371402274308L – 400000000. Wygląda na to, że wszystko działa zgodnie z oczekiwaniami.

Uwagi do procesu tworzenia prototypu aplikacji

Wiele z moich uwag na pewno zostanie zaadresowanych w przyszłości, więc moje zastrzeżenia są aktualne w dużej mierze na ten moment.

• brak dokumentacji – aktualny stan dokumentacji uniemożliwia eksplorację możliwości dostosowywania działania tworzonego blockchaina do własnych potrzeb.
• nieintuicyjne nazewnictwo bibliotek i narzędzi – Lisk SDK jako nazwa agregująca w sobie wszystkie produkty tworzone przez Lisk’a dedykowane tworzeniu aplikacji w Lisk nie ułatwia zrozumienia, czym tak naprawdę jest Lisk. Dotyczy to także składowych SDK, czyli Lisk Framework i Lisk Elements – jednoznaczne określenie funkcjonalności tych bibliotek jest trudne. Nazewnictwo i opisy nie są wystarczająco informatywne, ani intuicyjne.
• niepełne wsparcie dla Typescript’u – tworzenie bardziej złożonych aplikacji w Node.js najczęściej oparte jest o typowany język Typescript, kompilowalny do Javascriptu. Aktualnie Lisk tworzy większość swoich produktów w TS (choćby Elements i Commander), natomiast Lisk Framework napisany jest Javascript. Długofalowo może nie być to najlepszą decyzją (łatwiej jest utrzymywać typowany kod), a dwa że może opóźnić dostarczenie typów dla tworzonych bibliotek.

Podsumowanie i wnioski

Lisk jest projektem trudnym do opisania: ma służyć do tworzenia aplikacji blockchain – jednak działa inaczej niż aktualnie tworzone aplikacje blockchain w modelu: blockchain – smart contract. Tworząc aplikację w Lisku, tworzymy własny, kompletnie niezależny od głównej sieci blockchain (przynajmniej w aktualnym modelu). Aktualnie definiowanie logiki aplikacji opartej o Lisk polega na modyfikacji działania domyślnej logiki mechanizmów blockchaina i konfiguracji właściwości tego blockchaina: np. definiowanie działania (logiki) transakcji, czy wysokość opłaty za transakcje.

Zauważyłem, że Lisk zaprzestał używania określenia sidechain i jest to właściwe – tworzony blockchain nie pozostaje w żadnej relacji z głównym blockchainem (tytuł tego artykułu jest trochę przekłamany). Można go uruchomić, wyłączyć, zmienić jego działanie poprzez zmianę w kilku liniach kodu. Aktualnie Lisk nie prezentuje żadnego modelu tworzenia własnej sieci blockchainej (złożonej z wielu węzłów) – jak miałaby wyglądać demokratyzacja takiej sieci, w jaki sposób miałaby działać sieć węzłów tworzących blockchain, na czym polega niemutowalność przetwarzanego kodu, i wiele innych kwestii. Oczywiście te reguły muszą istnieć, ponieważ aktualna główna sieć Lisk funkcjonuje wg pewnych reguł. Pytanie jednak na jaki zakres modyfikacji twórcy aplikacji będą mogli sobie pozwolić. Obecnie możliwości Alpha SDK sprowadzają się do uruchomienia procesu Node.js, który “ma działać” zgodnie z protokołem Lisk Protocol, czyli tak jak węzeł Lisk Core.

Lisk przypomina swoją ideą projekty służące do budowania prywatnych sieci blockchain, takie jak np. Hyperledger Fabric. Fabric jest mocno rozwinięty i znajduje już zastosowanie w wielu komercyjnych zastosowaniach, ze względu na modularność i dużą możliwość kontroli nad protokołem blockchain. Prywatne blockchainy dedykowane są zamkniętemu gronu uczestników. Lisk zdaje się z założenia wspierać budowę publicznych blockchainów – takich, które są dostępne dla wszystkich. Niezmienia to jednak faktu, że zarówno w przypadku Liska, jak i Hyperledger Fabric mówimy o projekcie, budowie i utrzymaniu własnego blockchaina. Niezależnie od przeznaczenia (publiczny/prywatny) koszt i odpowiedzialność utrzymania takiej sieci blockchain leży na twórcy tej sieci.

Javascript, który początkowo miał uatrakcyjnić Lisk’a – długofalowo będzie powodował wiele problemów. Utrzymanie złożonych aplikacji Javascript jest trudne (nietypowany język, Lisk nie korzysta z Typescript’u). Ponadto co widać już dzisiaj, Alpha SDK posiada bardzo dużo zależności, które powodują wiele powszechnych i znanych dzisiaj problemów utrzymania kodu: między innymi bardzo częstą konieczność aktualizacji zależności (po to aby zachować kompatybilność, lub np. w związku z wadami bezpieczeństwa w zależnościach). Co warto podkreślić – wiele tego typu czynników ma duży wpływ na wykluczenie zastosowania Javascript i jego ekosystemu do poważnych rozwiązań IT na rzecz bardziej stabilnych technologii (np. Java).

Node.js jako środowisko uruchomieniowe aplikacji opartej o Lisk z racji swojej budowy (asynchroniczność, pętla) ma także pewne ograniczenia. Zakładając, że aplikacja Lisk ma realizować coś więcej niż logikę przesyłu transakcji i że ma działać w obrębie procesu węzła blockchain – przetwarzanie to będzie ograniczone do uruchomienia w środowisku Node.js (co może być wadą, chociaż jest promowane jako zaleta).

Lisk aspiruje stać się atrakcyjnym i nowoczesnym narzędziem do tworzenia aplikacji opartych o własny blockchain dla dużej grupy programistów webowych. Wizja i produkty ciąglę się kreuja. Inwestorów projektu zastanawiać może użyteczność tokena Lisk, w modelu produktów, który Lisk tworzy. Na ten moment główna sieć Lisk Core, z tokenem LSK zdaje się być tylko aplikacją stworzoną za pomocą Lisk SDK. Token głównego węzłą nie posiada aktualnie konkretnej użyteczności w tworzonych aplikacjach za pomocą Liska.

Mówiąc o przeznaczeniu Lisk’a warto jeszcze raz warto podkreślić, że nie jest to standardowa platforma do przetwarzania smart contractów. W Lisku tworzymy własny blockchain, który w bardzo dużym stopniu determinuje potencjalne wykorzystanie Liska. Utrzymanie własnego blockchaina jest kosztowne i odpowiedzialne. Ponadto decentralizacja blockchaina stworzonego w Lisku zależna jest od jego twórców. Z tego względu Lisk raczej nie będzie wykorzystywany do wszelkiego rodzaju publicznych zastosowań – czyli tych w których blockchain ma być ostatecznym źródłem prawdy (np. tokenizacje, cyfrowe umowy). Do tych zastosowań nadają się blockchainy, które dają możliwość tworzenia smart contractów (niezmienialnych umów, np. Ethereum) oraz których blockchain jest mocno zdecentralizowany, przez co wiarygodny (ponieważ praktycznie niemożliwe jest oszustwo).

To moje wnioski na temat aktualnego stanu projektu Lisk.
Jeśli chciałbyś poruszyć jakiś temat dotyczący Liska, napisz w komentarzu – Przemek.