Բլոկչեյն. ինչ PoC պետք է կառուցենք:

Աչքերդ վախենում են, իսկ ձեռքերդ քորում են։

Նախորդ հոդվածներում մենք անդրադարձանք այն տեխնոլոգիաներին, որոնց վրա կառուցված են բլոկչեյնները (Ի՞նչ պետք է կառուցենք բլոկչեյն:) և դեպքեր, որոնք կարող են իրականացվել նրանց օգնությամբ (Ինչո՞ւ պետք է գործ սարքենք։) Ժամանակն է աշխատել ձեր ձեռքերով: Pilots-ը և PoC-ը (Proof of Concept) իրականացնելու համար ես նախընտրում եմ օգտագործել ամպերը, քանի որ... դրանք կարելի է մուտք գործել աշխարհի ցանկացած կետից, և հաճախ կարիք չկա ժամանակ վատնել շրջակա միջավայրի հոգնեցուցիչ տեղադրման վրա, քանի որ Կան նախադրված կոնֆիգուրացիաներ: Այսպիսով, եկեք մի պարզ բան ստեղծենք, օրինակ, մասնակիցների միջև մետաղադրամներ փոխանցելու ցանց և համեստորեն այն անվանենք Բիթքոյն: Դրա համար մենք կօգտագործենք IBM ամպը և ունիվերսալ բլոկչեյն Hyperledger Fabric-ը: Նախ, եկեք պարզենք, թե ինչու է Hyperledger Fabric-ը կոչվում ունիվերսալ բլոկչեյն:

Hyperledger Fabric - ունիվերսալ բլոկչեյն

Ընդհանուր առմամբ, ունիվերսալ տեղեկատվական համակարգը հետևյալն է.

• Սերվերների մի շարք և ծրագրային ապահովման միջուկ, որն իրականացնում է բիզնես տրամաբանությունը.
• Համակարգի հետ փոխգործակցության միջերեսներ;
• Սարքերի/մարդկանց գրանցման, նույնականացման և թույլտվության գործիքներ;
• Գործառնական և արխիվային տվյալներ պահող տվյալների բազա.

Hyperledger Fabric-ի պաշտոնական տարբերակը կարելի է կարդալ այստեղ Առցանցև կարճ ասած՝ Hyperledger Fabric-ը բաց կոդով հարթակ է, որը թույլ է տալիս ստեղծել մասնավոր բլոկչեյններ և կատարել կամայական խելացի պայմանագրեր՝ գրված JS և Go ծրագրավորման լեզուներով։ Եկեք մանրամասն նայենք Hyperledger Fabric-ի ճարտարապետությանը և համոզվենք, որ սա ունիվերսալ համակարգ է, որն ունի միայն տվյալների պահպանման և գրանցման առանձնահատկություններ: Առանձնահատկությունն այն է, որ տվյալները, ինչպես բոլոր բլոկչեյններում, պահվում են բլոկներում, որոնք տեղադրվում են բլոկչեյնում միայն այն դեպքում, եթե մասնակիցները կոնսենսուսի են հասնում, և գրանցումից հետո տվյալները չեն կարող անաղմուկ շտկվել կամ ջնջվել:

Hyperledger Fabric Architecture

Դիագրամը ցույց է տալիս Hyperledger Fabric ճարտարապետությունը.

Կազմակերպություններ - կազմակերպությունները պարունակում են հասակակիցներ, այսինքն. բլոկչեյնը գոյություն ունի կազմակերպությունների աջակցության շնորհիվ։ Տարբեր կազմակերպություններ կարող են լինել նույն ալիքի մաս:

Նեղուց - տրամաբանական կառուցվածք, որը միավորում է հասակակիցներին խմբերի, այսինքն. բլոկչեյնը նշված է: Hyperledger Fabric-ը կարող է միաժամանակ մշակել բազմաթիվ բլոկչեյններ՝ տարբեր բիզնես տրամաբանությամբ:

Անդամակցության ծառայությունների մատակարար (MSP) ինքնությունը տրամադրելու և դերեր նշանակելու համար CA է (Վկայագրման մարմին): Հանգույց ստեղծելու համար անհրաժեշտ է շփվել MSP-ի հետ:

Հասակակից հանգույցներ — ստուգել գործարքները, պահել բլոկչեյնը, կատարել խելացի պայմանագրեր և շփվել հավելվածների հետ: Հասակակիցներն ունեն ինքնություն (թվային վկայական), որը տրվում է MSP-ի կողմից: Ի տարբերություն Bitcoin-ի կամ Etherium ցանցի, որտեղ բոլոր հանգույցներն ունեն հավասար իրավունքներ, Hyperledger Fabric-ում հանգույցները տարբեր դերեր են խաղում.

• Հասակակից, գուցե հաստատելով հասակակից (EP) և կատարել խելացի պայմանագրեր:
• Պարտավորություն հասակակից (CP) - պահպանեք տվյալները միայն բլոկչեյնում և թարմացրեք «Համաշխարհային վիճակը»:
• Խարիսխ Պեր (AP) - Եթե մի քանի կազմակերպություններ մասնակցում են բլոկաչին, ապա խարիսխ հասակակիցները օգտագործվում են նրանց միջեւ հաղորդակցվելու համար: Յուրաքանչյուր կազմակերպություն պետք է ունենա մեկ կամ մի քանի խարիսխ հասակակիցներ: Օգտագործելով AP- ն, կազմակերպության ցանկացած հասակակիցներ կարող են տեղեկատվություն ստանալ այլ կազմակերպությունների բոլոր հասակակիցների մասին: Օգտագործվում է ԱԵԱ-ների միջև տեղեկատվության համաժամացման համար բամբասանքի արձանագրություն.
• Առաջնորդ Պեր — եթե կազմակերպությունն ունի մի քանի հասակակիցներ, ապա միայն գործընկերոջ ղեկավարը կստանա բլոկներ Պատվիրման ծառայությունից և կտրամադրի դրանք մնացած հասակակիցներին: Ղեկավարը կարող է ստատիկ կերպով կամ ընտրվել դինամիկ կերպով կազմակերպության հասակակիցների կողմից: Բամբասանքի արձանագրությունն օգտագործվում է նաև առաջնորդների մասին տեղեկատվությունը համաժամեցնելու համար:

Ակտիվներ - միավորներ, որոնք արժեք ունեն և պահվում են բլոկչեյնում: Ավելի կոնկրետ, սա բանալի-արժեքի տվյալներ է JSON ձևաչափով: Հենց այս տվյալներն են գրանցվում Blockchain-ում։ Նրանք ունեն պատմություն, որը պահվում է բլոկչեյնում և ընթացիկ վիճակ, որը պահվում է «World state» տվյալների բազայում։ Տվյալների կառուցվածքները լրացվում են կամայականորեն՝ կախված բիզնես առաջադրանքներից: Պահանջվող դաշտեր չկան, միակ խորհուրդն այն է, որ ակտիվները պետք է ունենան սեփականատեր և արժեքավոր լինեն:

սալաքար գերեզմանաքար — բաղկացած է Blockchain-ից և Word-ի պետական ​​տվյալների բազայից, որը պահպանում է ակտիվների ընթացիկ վիճակը: Համաշխարհային պետությունն օգտագործում է LevelDB կամ CouchDB:

Smart պայմանագիր - Smart պայմանագրերի օգտագործմամբ իրականացվում է համակարգի բիզնես տրամաբանությունը: Hyperledger Fabric-ում խելացի պայմանագրերը կոչվում են շղթայական կոդ: Նշվում են շղթայի, ակտիվների եւ դրանց նկատմամբ գործարքների օգտագործումը: Տեխնիկական առումով խելացի պայմանագրերը ծրագրային մոդուլներ են, որոնք իրականացվում են JS կամ Go ծրագրավորման լեզուներով:

Հաստատման քաղաքականություն — յուրաքանչյուր շղթայական կոդի համար կարող եք քաղաքականություն սահմանել այն մասին, թե գործարքի քանի հաստատում և ումից պետք է սպասել: Եթե ​​քաղաքականությունը սահմանված չէ, ապա լռելյայն է. «գործարքը պետք է հաստատվի ալիքի ցանկացած կազմակերպության անդամի կողմից»: Քաղաքականության օրինակներ.

• Գործարքը պետք է հաստատվի կազմակերպության ցանկացած ադմինիստրատորի կողմից.
• Պետք է հաստատվի կազմակերպության ցանկացած անդամի կամ հաճախորդի կողմից.
• Պետք է հաստատվի ցանկացած գործընկեր կազմակերպության կողմից:

Պատվերների ծառայություն — գործարքները փաթեթավորում է բլոկների մեջ և դրանք ուղարկում ալիքի գործընկերներին: Երաշխավորում է հաղորդագրությունների առաքումը ցանցի բոլոր հասակակիցներին: Օգտագործվում է արդյունաբերական համակարգերի համար Կաֆկայի հաղորդագրությունների միջնորդ, մշակման և փորձարկման համար Միայնակ.

CallFlow

• Հավելվածը հաղորդակցվում է Hyperledger Fabric-ի հետ՝ օգտագործելով Go, Node.js կամ Java SDK;
• Հաճախորդը ստեղծում է tx գործարք և ուղարկում այն ​​հաստատող գործընկերներին.
• Գործընկերը ստուգում է հաճախորդի ստորագրությունը, ավարտում է գործարքը և հետ է ուղարկում հաստատման ստորագրությունը հաճախորդին: Chaincode-ը կատարվում է միայն հաստատող գործընկերոջ վրա, և դրա կատարման արդյունքն ուղարկվում է բոլոր գործընկերներին: Աշխատանքի այս ալգորիթմը կոչվում է PBFT (Practical Byzantine Fault Tolerant) կոնսենսուս: Տարբերվում է դասական BFT այն փաստը, որ հաղորդագրությունն ուղարկվում է և հաստատում է ակնկալվում ոչ բոլոր մասնակիցներից, այլ միայն որոշակի հավաքածուից.
• Այն բանից հետո, երբ հաճախորդը ստանում է հաստատման քաղաքականությանը համապատասխանող պատասխանների քանակը, նա գործարքն ուղարկում է Պատվիրման ծառայությանը.
• «Պատվերներ» ծառայությունը ստեղծում է բլոկ և ուղարկում այն ​​բոլոր հավատարիմ գործընկերներին: Պատվերների ծառայությունը ապահովում է բլոկների հաջորդական գրանցում, որը վերացնում է այսպես կոչված մատյան պատառաքաղը (Տես «Պատառաքաղներ» բաժինը);
• Գործընկերները ստանում են բլոկ, նորից ստուգում են հաստատման քաղաքականությունը, բլոկը գրում են բլոկչեյնում և փոխում վիճակը «Համաշխարհային վիճակ» DB-ում:

Նրանք. Սա հանգեցնում է հանգույցների միջև դերերի բաժանմանը: Սա ապահովում է, որ բլոկչեյնը մասշտաբային և ապահով է.

• Խելացի պայմանագրերը (շղթայական կոդը) կատարում են հաստատող գործընկերներ: Սա ապահովում է խելացի պայմանագրերի գաղտնիությունը, քանի որ այն պահվում է ոչ բոլոր մասնակիցների կողմից, այլ միայն հասակակիցների կողմից:
• Պատվերը պետք է արագ աշխատի: Դա ապահովվում է նրանով, որ Ordering-ը միայն ձևավորում է բլոկ և ուղարկում այն ​​լիդերների ֆիքսված շարքին:
• Հավատարիմ գործընկերները պահպանում են միայն բլոկչեյնը. նրանցից շատերը կարող են լինել, և դրանք մեծ հզորություն և ակնթարթային շահագործում չեն պահանջում:

Ավելի մանրամասն Hyperledger Fabric-ի ճարտարապետական ​​լուծումների և այն մասին, թե ինչու է այն աշխատում այսպես և ոչ այլ կերպ, կարելի է գտնել այստեղ. Ճարտարապետության ծագումը կամ այստեղ՝ Hyperledger Fabric. բաշխված օպերացիոն համակարգ թույլատրված բլոկչեյնների համար.

Այսպիսով, Hyperledger Fabric-ը իսկապես ունիվերսալ համակարգ է, որով կարող եք.

• Իրականացնել կամայական բիզնես տրամաբանություն, օգտագործելով խելացի պայմանագրի մեխանիզմը.
• Գրանցեք և ստացեք տվյալներ բլոկչեյնի տվյալների բազայից JSON ձևաչափով;
• Տրամադրեք և հաստատեք API-ի հասանելիությունը՝ օգտագործելով Վկայագրման մարմինը:

Այժմ, երբ մենք մի փոքր հասկացանք Hyperledger Fabric-ի առանձնահատկությունների մասին, եկեք վերջապես ինչ-որ օգտակար բան անենք:

Տեղակայել BlockChain- ը

Խնդրի ձևակերպում

Խնդիրն է իրականացնել Citcoin ցանցը հետևյալ գործառույթներով՝ ստեղծել հաշիվ, ստանալ մնացորդ, լրացնել ձեր հաշիվը, մետաղադրամներ փոխանցել մի հաշվից մյուսը։ Եկեք գծենք օբյեկտի մոդել, որը մենք հետագայում կիրականացնենք խելացի պայմանագրում։ Այսպիսով, մենք կունենանք հաշիվներ, որոնք նույնականացվում են անուններով և պարունակում են մնացորդ և հաշիվների ցուցակ: Հաշիվները և հաշիվների ցանկն են՝ Hyperledger Fabric-ի ակտիվների առումով: Ըստ այդմ, նրանք ունեն պատմություն և ներկա վիճակ։ Ես կփորձեմ պարզ նկարել սա.

Լավագույն ցուցանիշները ներկայիս վիճակն են, որը պահվում է «Համաշխարհային պետություն» տվյալների բազայում: Նրանց ներքևում ներկայացված են թվեր, որոնք ցույց են տալիս պատմությունը, որը պահվում է բլոկչեյնում: Գործարքներով փոխվում է ակտիվների ընթացիկ վիճակը: Ակտիվը փոխվում է միայն որպես ամբողջություն, ուստի գործարքի արդյունքում ստեղծվում է նոր օբյեկտ, և ակտիվի ընթացիկ արժեքը անցնում է պատմության մեջ:

IBM Cloud

Մենք ստեղծում ենք հաշիվ IBM ամպ. Բլոկչեյն հարթակն օգտագործելու համար այն պետք է թարմացվի Pay-As-You-Go-ի: Այս գործընթացը կարող է արագ չլինել, քանի որ... IBM-ը լրացուցիչ տեղեկություններ է պահանջում և ստուգում է դրանք ձեռքով: Դրական նկատառումով կարող եմ ասել, որ IBM-ն ունի լավ ուսումնական նյութեր, որոնք թույլ են տալիս տեղակայել Hyperledger Fabric-ը իրենց ամպում: Ինձ դուր եկավ հոդվածների և օրինակների հետևյալ շարքը.

• Ստեղծեք հիմնական բլոկչեյն ցանց՝ օգտագործելով Blockchain պլատֆորմը
• Ստեղծեք և կատարեք բլոկչեյնի խելացի պայմանագիր
• Արձանագրեք իրադարձություններ Blockchain հարթակից

Հետեւյալը IBM BlockChain պլատֆորմի սքրինշոթներ են: Սա հրահանգ չէ, թե ինչպես ստեղծել բլոկաչիա, բայց պարզապես առաջադրանքի շրջանակի դրսեւորում: Այսպիսով, մեր նպատակների համար մենք ստեղծում ենք մեկ Կազմակերպություն.

Մենք դրա մեջ ստեղծում ենք հանգույցներ՝ Orderer CA, Org1 CA, Orderer Peer:

Մենք ստեղծում ենք օգտվողներ.

Ստեղծեք ալիք և այն անվանեք citcoin.

Ըստ էության Channel-ը բլոկչեյն է, ուստի այն սկսվում է զրոյական բլոկից (Genesis բլոկ).

Խելացի պայմանագիր գրել

/*
 * 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 ֆունկցիաները առաջացնում են իրադարձություններ, որոնք ցուցադրական ծրագիրը կստանա:
• Ակնթարթային ֆունկցիան կանչվում է մեկ անգամ, երբ խելացի պայմանագիրը դրվում է: Փաստորեն, այն կոչվում է ոչ միայն մեկ անգամ, այլ ամեն անգամ, երբ փոփոխվում է խելացի պայմանագրի տարբերակը։ Հետևաբար, դատարկ զանգվածով ցուցակի սկզբնավորումը վատ գաղափար է, քանի որ Այժմ, երբ մենք փոխենք խելացի պայմանագրի տարբերակը, մենք կկորցնենք ընթացիկ ցանկը: Բայց ոչինչ, ես պարզապես սովորում եմ):
• Հաշիվները և հաշիվների ցանկը JSON տվյալների կառուցվածքներն են: JS-ն օգտագործվում է տվյալների մանիպուլյացիայի համար:
• Դուք կարող եք ստանալ ակտիվի ընթացիկ արժեքը՝ օգտագործելով getState ֆունկցիայի կանչը և թարմացնել այն putState-ի միջոցով:
• Հաշիվ ստեղծելիս կանչվում է AddAccount ֆունկցիան, որում համեմատություն է արվում բլոկչեյնի առավելագույն քանակի հաշիվների համար (maxAccounts = 5): Իսկ ահա մի ջամբ (նկատե՞լ եք), որը հանգեցնում է աքաունթերի անվերջ ավելացման։ Նման սխալներից պետք է խուսափել)

Այնուհետև մենք բեռնում ենք խելացի պայմանագիրը ալիքի մեջ և ներկայացնում ենք այն.

Դիտարկենք Smart Contract-ի տեղադրման գործարքը.

Եկեք նայենք մեր ալիքի մանրամասներին.

Արդյունքում մենք ստանում ենք IBM ամպի բլոկչեյն ցանցի հետևյալ դիագրամը. Դիագրամը ցույց է տալիս նաև ցուցադրական ծրագիր, որն աշխատում է Amazon ամպի մեջ վիրտուալ սերվերի վրա (այդ մասին ավելին հաջորդ բաժնում).

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 — ստեղծել Bob հաշիվ;
• HyperledgerDemo/v1/info?account=Bob — տեղեկություններ ստանալ Bob հաշվի մասին;
• HyperledgerDemo/v1/transaction?from=Bob&to=Alice&volume=2 - փոխանցել երկու մետաղադրամ Բոբից Ալիս;
• HyperledgerDemo/v1/disconnect - փակեք կապը բլոկչեյնի հետ:

API-ի նկարագրությունը ներառված օրինակներով Փոստատարի կայք - հայտնի ծրագիր HTTP API-ի փորձարկման համար:

Դեմո հավելված Amazon ամպում

Հավելվածը բեռնել եմ Amazon-ում, քանի որ... IBM-ը դեռ չի կարողացել թարմացնել իմ հաշիվը և թույլ տալ ինձ ստեղծել վիրտուալ սերվերներ: Ինչպես ավելացնել բալ տիրույթում. www.citcoin.info. Սերվերը մի քիչ միացված կպահեմ, հետո կանջատեմ, քանի որ... վարձակալության ցենտները կաթում են, իսկ citcoin մետաղադրամները դեռ ցուցակված չեն ֆոնդային բորսայում) Ես հոդվածում ներառում եմ ցուցադրության սքրինշոթները, որպեսզի աշխատանքի տրամաբանությունը պարզ լինի: Դեմո հավելվածը կարող է.

• Նախաձեռնել բլոկչեյնը;
• Ստեղծեք Հաշիվ (բայց այժմ դուք չեք կարող ստեղծել նոր Հաշիվ, քանի որ խելացի պայմանագրում նշված հաշիվների առավելագույն թիվը հասել է բլոկչեյնում);
• Ստացեք հաշիվների ցուցակ;
• Փոխանցել citcoin մետաղադրամներ Ալիսի, Բոբի և Ալեքսի միջև;
• Ստացեք իրադարձություններ (բայց այժմ իրադարձությունները ցույց տալու միջոց չկա, այնպես որ պարզության համար ինտերֆեյսը ասում է, որ իրադարձությունները չեն աջակցվում);
• Գրանցման գործողություններ:

Սկզբում մենք նախաստորագրում ենք բլոկչեյնը.

Հաջորդը, մենք ստեղծում ենք մեր հաշիվը, ժամանակ մի վատնեք մնացորդի հետ.

Մենք ստանում ենք բոլոր հասանելի հաշիվների ցանկը.

Մենք ընտրում ենք ուղարկողին և ստացողին և ստանում նրանց մնացորդները: Եթե ​​ուղարկողը և ստացողը նույնն են, ապա նրա հաշիվը կհամալրվի.

Գրանցամատյանում մենք վերահսկում ենք գործարքների կատարումը.

Փաստորեն, այս ամենը դեմո ծրագրի հետ է: Ստորև կարող եք տեսնել մեր գործարքը բլոկչեյնում.

Եվ գործարքների ընդհանուր ցանկը.

Դրանով մենք հաջողությամբ ավարտեցինք 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-ի օգտագործման համար կազմաձևման ֆայլերի օրինակներ

Դա միայն սկիզբն է:

Source: www.habr.com