ბლოკჩეინი: რა PoC უნდა ავაშენოთ?

თვალები გეშინია და ხელები გტკივა!

წინა სტატიებში ჩვენ განვიხილეთ ტექნოლოგიები, რომლებზეც აგებულია ბლოკჩეინი (რა უნდა ავაშენოთ ბლოკჩეინი?) და შემთხვევები, რომლებიც შეიძლება განხორციელდეს მათი დახმარებით (რატომ უნდა ავაშენოთ საქმე?). ხელებით მუშაობის დროა! პილოტების და PoC-ის (Proof of Concept) განსახორციელებლად მირჩევნია ღრუბლების გამოყენება, რადგან... მათზე წვდომა შესაძლებელია მსოფლიოს ნებისმიერი ადგილიდან და ხშირად არ არის საჭირო დროის დაკარგვა გარემოს დამღლელი ინსტალაციისთვის, რადგან არის წინასწარ დაყენებული კონფიგურაციები. მოდით გავაკეთოთ რაღაც მარტივი, მაგალითად, მონეტების გადაცემის ქსელი მონაწილეებს შორის და მოკრძალებულად დავარქვათ მას ბიტკოინი. ამისთვის გამოვიყენებთ IBM ღრუბელს და უნივერსალურ ბლოკჩეინს Hyperledger Fabric-ს. პირველ რიგში, მოდით გავარკვიოთ, რატომ ჰქვია Hyperledger Fabric-ს უნივერსალური ბლოკჩეინი?

Hyperledger Fabric - უნივერსალური ბლოკჩეინი

ზოგადად რომ ვთქვათ, უნივერსალური საინფორმაციო სისტემა არის:

• სერვერების ნაკრები და პროგრამული ბირთვი, რომელიც ასრულებს ბიზნეს ლოგიკას;
• ინტერფეისები სისტემასთან ურთიერთობისთვის;
• მოწყობილობების/ადამიანების რეგისტრაციის, ავთენტიფიკაციისა და ავტორიზაციის ინსტრუმენტები;
• მონაცემთა ბაზა, რომელიც ინახავს ოპერაციულ და საარქივო მონაცემებს:

ოფიციალური ვერსია იმის შესახებ, თუ რა არის Hyperledger Fabric, შეგიძლიათ წაიკითხოთ აქ ონლაინიდა მოკლედ, Hyperledger Fabric არის ღია წყაროს პლატფორმა, რომელიც საშუალებას გაძლევთ შექმნათ კერძო ბლოკჩეინები და შეასრულოთ თვითნებური ჭკვიანი კონტრაქტები დაწერილი JS და Go პროგრამირების ენებზე. მოდით დეტალურად განვიხილოთ Hyperledger Fabric-ის არქიტექტურა და დავრწმუნდეთ, რომ ეს არის უნივერსალური სისტემა, რომელსაც აქვს მხოლოდ მონაცემების შენახვისა და ჩაწერის სპეციფიკა. სპეციფიკა არის ის, რომ მონაცემები, როგორც ყველა ბლოკჩეინში, ინახება ბლოკებში, რომლებიც მოთავსებულია ბლოკჩეინზე მხოლოდ იმ შემთხვევაში, თუ მონაწილეები მიაღწევენ კონსენსუსს და ჩაწერის შემდეგ მონაცემების ჩუმად გასწორება ან წაშლა შეუძლებელია.

Hyperledger ქსოვილის არქიტექტურა

დიაგრამა გვიჩვენებს Hyperledger Fabric არქიტექტურას:

ორგანიზაციები — ორგანიზაციები შეიცავენ თანატოლებს, ე.ი. ბლოკჩეინი არსებობს ორგანიზაციების მხარდაჭერით. სხვადასხვა ორგანიზაცია შეიძლება იყოს ერთი და იგივე არხის ნაწილი.

არხი — ლოგიკური სტრუქტურა, რომელიც აერთიანებს თანატოლებს ჯგუფებად, ე.ი. მითითებულია ბლოკჩეინი. Hyperledger Fabric-ს შეუძლია ერთდროულად დაამუშავოს მრავალი ბლოკჩეინი სხვადასხვა ბიზნეს ლოგიკით.

წევრობის სერვისების პროვაიდერი (MSP) არის CA (სერთიფიკატის ორგანო) პირადობის გაცემისა და როლების მინიჭებისთვის. კვანძის შესაქმნელად, თქვენ უნდა დაუკავშირდეთ MSP-ს.

თანატოლების კვანძები - გადაამოწმეთ ტრანზაქციები, შეინახეთ ბლოკჩეინი, შეასრულეთ ჭკვიანი კონტრაქტები და დაუკავშირდით აპლიკაციებს. თანატოლებს აქვთ პირადობა (ციფრული სერტიფიკატი), რომელსაც გასცემს MSP. ბიტკოინის ან ეთერიუმის ქსელისგან განსხვავებით, სადაც ყველა კვანძს აქვს თანაბარი უფლებები, Hyperledger Fabric-ში კვანძები სხვადასხვა როლს ასრულებენ:

• თანატოლები იქნებ მოწონება თანატოლს (EP) და შეასრულეთ ჭკვიანი კონტრაქტები.
• ჩადენილი თანატოლი (CP) - შეინახეთ მხოლოდ მონაცემები ბლოკჩეინში და განაახლეთ „მსოფლიო მდგომარეობა“.
• წამყვანი პეერი (AP) - თუ ბლოკჩეინში რამდენიმე ორგანიზაცია მონაწილეობს, მაშინ მათ შორის კომუნიკაციისთვის გამოიყენება წამყვანი თანატოლები. თითოეულ ორგანიზაციას უნდა ჰყავდეს ერთი ან მეტი წამყვანი თანატოლი. AP-ის გამოყენებით, ორგანიზაციის ნებისმიერ თანატოლს შეუძლია მიიღოს ინფორმაცია სხვა ორგანიზაციების ყველა თანატოლის შესახებ. გამოიყენება AP-ებს შორის ინფორმაციის სინქრონიზაციისთვის ჭორის პროტოკოლი.
• ლიდერი პეერ — თუ ორგანიზაციას ჰყავს რამდენიმე თანატოლი, მაშინ მხოლოდ პარტნიორის ლიდერი მიიღებს ბლოკებს შეკვეთის სერვისიდან და გადასცემს მათ დანარჩენ თანატოლებს. ლიდერი შეიძლება იყოს მითითებული სტატიკურად ან დინამიურად შერჩეული ორგანიზაციის თანატოლების მიერ. ჭორის პროტოკოლი ასევე გამოიყენება ლიდერების შესახებ ინფორმაციის სინქრონიზაციისთვის.

აქტივები - სუბიექტები, რომლებსაც აქვთ ღირებულება და ინახება ბლოკჩეინზე. უფრო კონკრეტულად, ეს არის გასაღები-მნიშვნელობის მონაცემები JSON ფორმატში. სწორედ ეს მონაცემებია ჩაწერილი ბლოკჩეინში. მათ აქვთ ისტორია, რომელიც ინახება ბლოკჩეინში და მიმდინარე მდგომარეობა, რომელიც ინახება „მსოფლიო სახელმწიფოს“ მონაცემთა ბაზაში. მონაცემთა სტრუქტურები ივსება თვითნებურად, ბიზნეს ამოცანების მიხედვით. არ არის აუცილებელი ველები, ერთადერთი რეკომენდაციაა, რომ აქტივებს უნდა ჰყავდეს მფლობელი და იყოს ღირებული.

ledger — შედგება Blockchain-ისა და Word-ის სახელმწიფო მონაცემთა ბაზისგან, რომელიც ინახავს აქტივების ამჟამინდელ მდგომარეობას. მსოფლიო სახელმწიფო იყენებს LevelDB ან CouchDB.

ჭკვიანი კონტრაქტი — ჭკვიანი კონტრაქტების გამოყენებით ხდება სისტემის ბიზნეს ლოგიკის დანერგვა. Hyperledger Fabric-ში ჭკვიან კონტრაქტებს ჯაჭვის კოდი ეწოდება. ჯაჭვის კოდის გამოყენებით მითითებულია აქტივები და მათზე ტრანზაქციები. ტექნიკური თვალსაზრისით, ჭკვიანი კონტრაქტები არის პროგრამული მოდულები, რომლებიც დანერგილია JS ან Go პროგრამირების ენებზე.

დამტკიცების პოლიტიკა — თითოეული ჯაჭვის კოდისთვის შეგიძლიათ დააყენოთ პოლიტიკა იმის შესახებ, თუ რამდენი დადასტურება უნდა იყოს მოსალოდნელი ტრანზაქციისთვის და ვისგან. თუ დებულება არ არის დაყენებული, მაშინ ნაგულისხმევია: „ტრანზაქცია უნდა დაადასტუროს არხის რომელიმე ორგანიზაციის ნებისმიერმა წევრმა“. პოლიტიკის მაგალითები:

• ტრანზაქცია დამტკიცებული უნდა იყოს ორგანიზაციის ნებისმიერი ადმინისტრატორის მიერ;
• უნდა დაადასტუროს ორგანიზაციის რომელიმე წევრი ან კლიენტი;
• უნდა დაადასტუროს ნებისმიერი თანატოლი ორგანიზაცია.

შეკვეთის სერვისი — აწყობს ტრანზაქციებს ბლოკებად და აგზავნის მათ არხის თანატოლებთან. უზრუნველყოფს შეტყობინებების მიწოდებას ქსელის ყველა თანატოლისთვის. გამოიყენება სამრეწველო სისტემებისთვის კაფკას შეტყობინების ბროკერი, განვითარებისა და ტესტირებისთვის SOLO.

CallFlow

• აპლიკაცია აკავშირებს Hyperledger Fabric-თან Go, Node.js ან Java SDK-ის გამოყენებით;
• კლიენტი ქმნის tx ტრანზაქციას და აგზავნის მას ინდოსანტთან;
• თანატოლი ამოწმებს კლიენტის ხელმოწერას, ასრულებს ტრანზაქციას და აგზავნის ხელმოწერას უკან კლიენტს. Chaincode შესრულებულია მხოლოდ დამტკიცებულ თანატოლზე და მისი შესრულების შედეგი ეგზავნება ყველა თანატოლს. მუშაობის ამ ალგორითმს ეწოდება PBFT (Practical Byzantine Fault Tolerant) კონსენსუსი. განსხვავდება კლასიკური BFT ის ფაქტი, რომ შეტყობინება იგზავნება და დადასტურება მოსალოდნელია არა ყველა მონაწილისგან, არამედ მხოლოდ გარკვეული ნაკრებიდან;
• მას შემდეგ, რაც კლიენტი მიიღებს ინდოსამენტის პოლიტიკის შესაბამისი პასუხების რაოდენობას, ის აგზავნის ტრანზაქციას შეკვეთის სერვისში;
• შეკვეთის სერვისი აგენერირებს ბლოკს და უგზავნის მას ყველა მონაწილე თანატოლს. შეკვეთის სერვისი უზრუნველყოფს ბლოკების თანმიმდევრულ ჩაწერას, რაც გამორიცხავს ე.წ.იხილეთ განყოფილება "ჩანგალები");
• თანატოლები იღებენ ბლოკს, ხელახლა ამოწმებენ დამტკიცების პოლიტიკას, ჩაწერენ ბლოკს ბლოკჩეინში და შეცვლიან მდგომარეობას "მსოფლიო სახელმწიფო" DB-ში.

იმათ. ეს იწვევს როლების დაყოფას კვანძებს შორის. ეს უზრუნველყოფს ბლოკჩეინის მასშტაბირებას და უსაფრთხოებას:

• სმარტ კონტრაქტები (chaincode) ასრულებენ თანხმობას. ეს უზრუნველყოფს ჭკვიანი კონტრაქტების კონფიდენციალურობას, რადგან ის არ ინახება ყველა მონაწილის მიერ, არამედ მხოლოდ თანატოლების მოწონებით.
• შეკვეთამ უნდა იმუშაოს სწრაფად. ეს უზრუნველყოფილია იმით, რომ შეკვეთა აყალიბებს მხოლოდ ბლოკს და აგზავნის ლიდერ თანატოლების ფიქსირებულ კომპლექტს.
• თანატოლების ჩადენა მხოლოდ ბლოკჩეინს ინახავს - შეიძლება იყოს ბევრი მათგანი და არ საჭიროებს დიდ ენერგიას და მყისიერ მუშაობას.

დამატებითი დეტალები Hyperledger Fabric-ის არქიტექტურული გადაწყვეტილებების შესახებ და რატომ მუშაობს იგი ასე და არა სხვაგვარად, შეგიძლიათ იხილოთ აქ: არქიტექტურის წარმოშობა ან აქ: Hyperledger Fabric: განაწილებული ოპერაციული სისტემა ნებადართული ბლოკჩეინებისთვის.

ასე რომ, Hyperledger Fabric არის ჭეშმარიტად უნივერსალური სისტემა, რომლითაც შეგიძლიათ:

• თვითნებური ბიზნეს ლოგიკის განხორციელება ჭკვიანი კონტრაქტის მექანიზმის გამოყენებით;
• ჩაწერეთ და მიიღეთ მონაცემები ბლოკჩეინის მონაცემთა ბაზიდან JSON ფორმატში;
• მიეცით და დაადასტურეთ API წვდომა სერტიფიკატის ავტორიტეტის გამოყენებით.

ახლა, როცა ცოტათი გავიგეთ Hyperledger Fabric-ის სპეციფიკის შესახებ, საბოლოოდ გავაკეთოთ რაიმე სასარგებლო!

ბლოკჩეინის დანერგვა

პრობლემის შესახებ განცხადება

ამოცანაა Citcoin ქსელის დანერგვა შემდეგი ფუნქციებით: შექმენით ანგარიში, მიიღეთ ბალანსი, შეავსეთ თქვენი ანგარიში, გადაიტანეთ მონეტები ერთი ანგარიშიდან მეორეზე. მოდით დავხატოთ ობიექტის მოდელი, რომელსაც შემდგომ განვახორციელებთ სმარტ კონტრაქტში. ამრიგად, ჩვენ გვექნება ანგარიშები, რომლებიც იდენტიფიცირებულია სახელებით და შეიცავს ბალანსს და ანგარიშების ჩამონათვალს. ანგარიშები და ანგარიშების სია არის Hyperledger Fabric აქტივების თვალსაზრისით. შესაბამისად, მათ აქვთ ისტორია და დღევანდელი მდგომარეობა. ვეცდები ნათლად დავხატო ეს:

ზედა მაჩვენებლები არის მიმდინარე მდგომარეობა, რომელიც ინახება „მსოფლიო სახელმწიფოს“ მონაცემთა ბაზაში. მათ ქვემოთ მოცემულია ფიგურები, რომლებიც აჩვენებს ისტორიას, რომელიც ინახება ბლოკჩეინში. აქტივების ამჟამინდელი მდგომარეობა იცვლება ტრანზაქციებით. აქტივი იცვლება მხოლოდ მთლიანობაში, ამიტომ ტრანზაქციის შედეგად იქმნება ახალი ობიექტი და აქტივის მიმდინარე ღირებულება ისტორიაში გადადის.

IBM Cloud

ჩვენ ვქმნით ანგარიშს IBM ღრუბელი. ბლოკჩეინის პლატფორმის გამოსაყენებლად ის უნდა განახლდეს Pay-As-You-Go-ზე. ეს პროცესი შეიძლება არ იყოს სწრაფი, რადგან... IBM ითხოვს დამატებით ინფორმაციას და ამოწმებს ხელით. დადებითად შემიძლია ვთქვა, რომ IBM-ს აქვს კარგი სასწავლო მასალები, რომელიც საშუალებას გაძლევთ განათავსოთ Hyperledger Fabric მათ ღრუბელში. მომეწონა შემდეგი სტატიების სერია და მაგალითები:

• შექმენით ძირითადი ბლოკჩეინის ქსელი ბლოკჩეინის პლატფორმის გამოყენებით
• შექმენით და შეასრულეთ ბლოკჩეინის ჭკვიანი კონტრაქტი
• გამოაქვეყნეთ მოვლენები ბლოკჩეინის პლატფორმიდან

ქვემოთ მოცემულია IBM Blockchain პლატფორმის ეკრანის ანაბეჭდები. ეს არ არის ინსტრუქცია იმის შესახებ, თუ როგორ უნდა შექმნათ ბლოკჩეინი, არამედ უბრალოდ დავალების მასშტაბის დემონსტრირებაა. ასე რომ, ჩვენი მიზნებისთვის, ჩვენ ვქმნით ერთ ორგანიზაციას:

ჩვენ ვქმნით მასში კვანძებს: Orderer CA, Org1 CA, Orderer Peer:

ჩვენ ვქმნით მომხმარებლებს:

შექმენით არხი და დაარქვით citcoin:

არსებითად Channel არის ბლოკჩეინი, ამიტომ ის იწყება ნულოვანი ბლოკით (გენეზისის ბლოკი):

ჭკვიანი კონტრაქტის დაწერა

/*
 * Citcoin smart-contract v1.5 for Hyperledger Fabric
 * (c) Alexey Sushkov, 2019
 */
 
'use strict';
 
const { Contract } = require('fabric-contract-api');
const maxAccounts = 5;
 
class CitcoinEvents extends Contract {
 
    async instantiate(ctx) {
        console.info('instantiate');
        let emptyList = [];
        await ctx.stub.putState('accounts', Buffer.from(JSON.stringify(emptyList)));
    }
    // Get all accounts
    async GetAccounts(ctx) {
        // Get account list:
        let accounts = '{}'
        let accountsData = await ctx.stub.getState('accounts');
        if (accountsData) {
            accounts = JSON.parse(accountsData.toString());
        } else {
            throw new Error('accounts not found');
        }
        return accountsData.toString()
    }
     // add a account object to the blockchain state identifited by their name
    async AddAccount(ctx, name, balance) {
        // this is account data:
        let account = {
            name: name,
            balance: Number(balance),       
            type: 'account',
        };
        // create account:
        await ctx.stub.putState(name, Buffer.from(JSON.stringify(account)));
 
        // Add account to list:
        let accountsData = await ctx.stub.getState('accounts');
        if (accountsData) {
            let accounts = JSON.parse(accountsData.toString());
            if (accounts.length < maxAccounts)
            {
                accounts.push(name);
                await ctx.stub.putState('accounts', Buffer.from(JSON.stringify(accounts)));
            } else {
                throw new Error('Max accounts number reached');
            }
        } else {
            throw new Error('accounts not found');
        }
        // return  object
        return JSON.stringify(account);
    }
    // Sends money from Account to Account
    async SendFrom(ctx, fromAccount, toAccount, value) {
        // get Account from
        let fromData = await ctx.stub.getState(fromAccount);
        let from;
        if (fromData) {
            from = JSON.parse(fromData.toString());
            if (from.type !== 'account') {
                throw new Error('wrong from type');
            }   
        } else {
            throw new Error('Accout from not found');
        }
        // get Account to
        let toData = await ctx.stub.getState(toAccount);
        let to;
        if (toData) {
            to = JSON.parse(toData.toString());
            if (to.type !== 'account') {
                throw new Error('wrong to type');
            }  
        } else {
            throw new Error('Accout to not found');
        }
 
        // update the balances
        if ((from.balance - Number(value)) >= 0 ) {
            from.balance -= Number(value);
            to.balance += Number(value);
        } else {
            throw new Error('From Account: not enought balance');          
        }
 
        await ctx.stub.putState(from.name, Buffer.from(JSON.stringify(from)));
        await ctx.stub.putState(to.name, Buffer.from(JSON.stringify(to)));
                 
        // define and set Event
        let Event = {
            type: "SendFrom",
            from: from.name,
            to: to.name,
            balanceFrom: from.balance,
            balanceTo: to.balance,
            value: value
        };
        await ctx.stub.setEvent('SendFrom', Buffer.from(JSON.stringify(Event)));
 
        // return to object
        return JSON.stringify(from);
    }
 
    // get the state from key
    async GetState(ctx, key) {
        let data = await ctx.stub.getState(key);
        let jsonData = JSON.parse(data.toString());
        return JSON.stringify(jsonData);
    }
    // GetBalance   
    async GetBalance(ctx, accountName) {
        let data = await ctx.stub.getState(accountName);
        let jsonData = JSON.parse(data.toString());
        return JSON.stringify(jsonData);
    }
     
    // Refill own balance
    async RefillBalance(ctx, toAccount, value) {
        // get Account to
        let toData = await ctx.stub.getState(toAccount);
        let to;
        if (toData) {
            to = JSON.parse(toData.toString());
            if (to.type !== 'account') {
                throw new Error('wrong to type');
            }  
        } else {
            throw new Error('Accout to not found');
        }
 
        // update the balance
        to.balance += Number(value);
        await ctx.stub.putState(to.name, Buffer.from(JSON.stringify(to)));
                 
        // define and set Event
        let Event = {
            type: "RefillBalance",
            to: to.name,
            balanceTo: to.balance,
            value: value
        };
        await ctx.stub.setEvent('RefillBalance', Buffer.from(JSON.stringify(Event)));
 
        // return to object
        return JSON.stringify(from);
    }
}
module.exports = CitcoinEvents;

ინტუიციურად, აქ ყველაფერი გასაგები უნდა იყოს:

• არსებობს რამდენიმე ფუნქცია (AddAccount, GetAccounts, SendFrom, GetBalance, RefillBalance), რომლებსაც დემო პროგრამა გამოიძახებს Hyperledger Fabric API-ის გამოყენებით.
• SendFrom და RefillBalance ფუნქციები ქმნიან მოვლენებს, რომლებსაც დემო პროგრამა მიიღებს.
• Instantiate ფუნქცია გამოიძახება ერთხელ, როდესაც სმარტ კონტრაქტი დადებულია. სინამდვილეში, მას უწოდებენ არა მხოლოდ ერთხელ, არამედ ყოველ ჯერზე, როდესაც იცვლება ჭკვიანი კონტრაქტის ვერსია. ამიტომ, სიის ინიციალიზაცია ცარიელი მასივით ცუდი იდეაა, რადგან ახლა, როდესაც ჩვენ შევცვლით სმარტ კონტრაქტის ვერსიას, დავკარგავთ მიმდინარე სიას. მაგრამ არა უშავს, უბრალოდ ვსწავლობ).
• ანგარიშები და ანგარიშების სია არის JSON მონაცემთა სტრუქტურები. JS გამოიყენება მონაცემთა მანიპულირებისთვის.
• შეგიძლიათ მიიღოთ აქტივის მიმდინარე ღირებულება getState ფუნქციის გამოძახებით და განაახლოთ putState-ის გამოყენებით.
• ანგარიშის შექმნისას გამოიძახება AddAccount ფუნქცია, რომელშიც შედარება ხდება ბლოკჩეინში არსებული ანგარიშების მაქსიმალური რაოდენობა (maxAccounts = 5). და აქ არის ჯამი (შეგიმჩნევიათ?), რაც იწვევს ანგარიშების რაოდენობის გაუთავებელ ზრდას. ასეთი შეცდომები თავიდან უნდა იქნას აცილებული)

შემდეგი, ჩვენ ვტვირთავთ სმარტ კონტრაქტს არხში და ვაყენებთ მას:

მოდით შევხედოთ ტრანზაქციას Smart Contract-ის ინსტალაციისთვის:

მოდით შევხედოთ დეტალებს ჩვენი არხის შესახებ:

შედეგად, ჩვენ ვიღებთ ბლოკჩეინის ქსელის შემდეგ დიაგრამას IBM ღრუბელში. დიაგრამა ასევე აჩვენებს დემო პროგრამას, რომელიც მუშაობს ამაზონის ღრუბელში, ვირტუალურ სერვერზე (დაწვრილებით ამის შესახებ შემდეგ განყოფილებაში):

GUI-ს შექმნა Hyperledger Fabric API ზარებისთვის

Hyperledger Fabric-ს აქვს API, რომელიც შეიძლება გამოყენებულ იქნას:

• არხის შექმნა;
• არხთან კავშირები;
• არხზე სმარტ კონტრაქტების დაყენება და ინსტალაცია;
• დარეკვის ტრანზაქციები;
• მოითხოვეთ ინფორმაცია ბლოკჩეინზე.

აპლიკაციის შემუშავება

ჩვენს დემო პროგრამაში ჩვენ გამოვიყენებთ API-ს მხოლოდ ტრანზაქციების დასარეკად და ინფორმაციის მოსათხოვად, რადგან ჩვენ უკვე დავასრულეთ დარჩენილი ნაბიჯები IBM ბლოკჩეინის პლატფორმის გამოყენებით. ჩვენ ვწერთ GUI-ს სტანდარტული ტექნოლოგიური სტეკის გამოყენებით: Express.js + Vue.js + Node.js. თქვენ შეგიძლიათ დაწეროთ ცალკე სტატია, თუ როგორ უნდა დაიწყოთ თანამედროვე ვებ აპლიკაციების შექმნა. აქ დავტოვებ ლინკს ლექციების სერიის შესახებ, რომელიც ყველაზე მეტად მომეწონა: Full Stack ვებ აპი Vue.js და Express.js გამოყენებით. შედეგი არის კლიენტ-სერვერის აპლიკაცია ნაცნობი გრაფიკული ინტერფეისით Google-ის Material Design-ის სტილში. REST API კლიენტსა და სერვერს შორის შედგება რამდენიმე ზარისგან:

• HyperledgerDemo/v1/init - ბლოკჩეინის ინიციალიზაცია;
• HyperledgerDemo/v1/accounts/list — მიიღეთ ყველა ანგარიშის სია;
• HyperledgerDemo/v1/account?name=Bob&balance=100 — შექმენით ბობ ანგარიში;
• HyperledgerDemo/v1/info?account=Bob — მიიღეთ ინფორმაცია ბობ ანგარიშის შესახებ;
• HyperledgerDemo/v1/transaction?from=Bob&to=Alice&volume=2 - გადაიტანეთ ორი მონეტა ბობიდან ალისაზე;
• HyperledgerDemo/v1/disconnect - დახურეთ კავშირი ბლოკჩეინთან.

API-ს აღწერა მაგალითებით ფოსტალიონის საიტი - ცნობილი პროგრამა HTTP API-ს შესამოწმებლად.

დემო აპლიკაცია ამაზონის ღრუბელში

აპლიკაცია ამაზონზე ავტვირთე, რადგან... IBM-მა ჯერ კიდევ ვერ შეძლო ჩემი ანგარიშის განახლება და ვირტუალური სერვერების შექმნის საშუალება. როგორ დავამატოთ ალუბალი დომენში: www.citcoin.info. სერვერს ცოტა ხნით ჩართული დავტოვებ, მერე გავთიშავ, რადგან... ქირავნობის ცენტები წვეთობს, ციტკოინის მონეტები კი ჯერ არ არის გამოტანილი ბირჟაზე) სტატიაში დემო-ს სქრინშოტებს ვდებ, რომ საქმის ლოგიკა გასაგები იყოს. დემო აპლიკაციას შეუძლია:

• ბლოკჩეინის ინიცირება;
• შექმენით ანგარიში (მაგრამ ახლა თქვენ ვერ შექმნით ახალ ანგარიშს, რადგან სმარტ კონტრაქტში მითითებული ანგარიშების მაქსიმალური რაოდენობა მიღწეულია ბლოკჩეინში);
• მიიღეთ ანგარიშების სია;
• გადაიტანეთ ციტკოინის მონეტები ალისს, ბობსა და ალექსს შორის;
• მიიღეთ მოვლენები (მაგრამ ახლა არ არსებობს მოვლენების ჩვენების საშუალება, ასე რომ, სიმარტივისთვის, ინტერფეისი ამბობს, რომ მოვლენები არ არის მხარდაჭერილი);
• ჟურნალის მოქმედებები.

ჯერ ჩვენ ბლოკჩეინის ინიციალიზაციას ვაკეთებთ:

შემდეგი, ჩვენ ვქმნით ჩვენს ანგარიშს, ნუ დაკარგავთ დროს ბალანსზე:

ჩვენ ვიღებთ ყველა ხელმისაწვდომი ანგარიშის ჩამონათვალს:

ჩვენ ვირჩევთ გამგზავნს და მიმღებს და ვიღებთ მათ ბალანსს. თუ გამგზავნი და მიმღები ერთნაირია, მაშინ მისი ანგარიში შეივსება:

ჟურნალში ჩვენ ვაკვირდებით ტრანზაქციების შესრულებას:

სინამდვილეში, ეს ყველაფერი დემო პროგრამითაა. ქვემოთ შეგიძლიათ იხილოთ ჩვენი ტრანზაქცია ბლოკჩეინში:

და ტრანზაქციების ზოგადი სია:

ამით ჩვენ წარმატებით დავასრულეთ PoC-ის დანერგვა Citcoin ქსელის შესაქმნელად. კიდევ რა უნდა გაკეთდეს იმისათვის, რომ Citcoin გახდეს მონეტების გადაცემის სრულფასოვანი ქსელი? Ძალიან პატარა:

• ანგარიშის შექმნის ეტაპზე, განახორციელეთ პირადი / საჯარო გასაღების გენერაცია. პირადი გასაღები უნდა იყოს შენახული ანგარიშის მომხმარებელთან, საჯარო გასაღები უნდა იყოს შენახული ბლოკჩეინში.
• გააკეთეთ მონეტის გადაცემა, რომელშიც მომხმარებლის იდენტიფიცირებისთვის გამოიყენება საჯარო გასაღები და არა სახელი.
• დაშიფრეთ ტრანზაქციები, რომლებიც მიდის მომხმარებლისგან სერვერზე მისი პირადი გასაღებით.

დასკვნა

ჩვენ განვახორციელეთ Citcoin ქსელი შემდეგი ფუნქციებით: დაამატეთ ანგარიში, მიიღეთ ბალანსი, შეავსეთ თქვენი ანგარიში, გადაიტანეთ მონეტები ერთი ანგარიშიდან მეორეზე. მაშ, რა დაგვიჯდა PoC-ის აშენება?

• თქვენ უნდა შეისწავლოთ ბლოკჩეინი ზოგადად და Hyperledger Fabric კერძოდ;
• ისწავლეთ IBM ან Amazon ღრუბლების გამოყენება;
• ისწავლეთ JS პროგრამირების ენა და ზოგიერთი ვებ ჩარჩო;
• თუ გარკვეული მონაცემების შენახვა საჭიროა არა ბლოკჩეინში, არამედ ცალკე მონაცემთა ბაზაში, მაშინ ისწავლეთ ინტეგრირება, მაგალითად, PostgreSQL-თან;
• და ბოლოს, მაგრამ არანაკლებ მნიშვნელოვანი - თქვენ არ შეგიძლიათ იცხოვროთ თანამედროვე სამყაროში Linux-ის ცოდნის გარეშე!)

რა თქმა უნდა, ეს არ არის სარაკეტო მეცნიერება, მაგრამ თქვენ მოგიწევთ ბევრი მუშაობა!

წყაროები GitHub-ზე

წყაროები დააყენა GitHub. საცავის მოკლე აღწერა:
კატალოგი «სერვერზე» — Node.js სერვერი
კატალოგი «კლიენტი» — Node.js კლიენტი
კატალოგი «blockchain"(პარამეტრების მნიშვნელობები და გასაღებები, რა თქმა უნდა, არ მუშაობს და მოცემულია მხოლოდ მაგალითის სახით):

• კონტრაქტი — ჭკვიანი კონტრაქტის საწყისი კოდი
• საფულე — მომხმარებლის გასაღებები Hyperledger Fabric API-ის გამოსაყენებლად.
• *.cds - ჭკვიანი კონტრაქტების შედგენილი ვერსიები
• *.json ფაილები - კონფიგურაციის ფაილების მაგალითები Hyperledger Fabric API-ის გამოსაყენებლად

ეს მხოლოდ დასაწყისია!

წყარო: www.habr.com