Blockchain: איזה PoC עלינו לבנות?

העיניים שלך מפחדות והידיים שלך מגרדות!

במאמרים קודמים עסקנו בטכנולוגיות שעליהן בנויים בלוקצ'יין (מה עלינו לבנות בלוקצ'יין?) ומקרים שניתן ליישם בעזרתם (למה אנחנו צריכים לבנות תיק?). זה הזמן לעבוד עם הידיים! כדי ליישם פיילוטים ו-PoC (Proof of Concept), אני מעדיף להשתמש בעננים, כי... ניתן לגשת אליהם מכל מקום בעולם, ולעתים קרובות, אין צורך לבזבז זמן על התקנה מייגעת של הסביבה, מכיוון ישנן תצורות מוגדרות מראש. אז בואו נעשה משהו פשוט, למשל, רשת להעברת מטבעות בין משתתפים ובואו נקרא לזה בצניעות ביטקוין. לשם כך נשתמש בענן IBM וב-Blockchain האוניברסלי Hyperledger Fabric. ראשית, בואו נבין מדוע Hyperledger Fabric נקרא בלוקצ'יין אוניברסלי?

Hyperledger Fabric - בלוקצ'יין אוניברסלי

באופן כללי, מערכת מידע אוניברסלית היא:

• קבוצה של שרתים וליבה תוכנה המבצעת לוגיקה עסקית;
• ממשקים לאינטראקציה עם המערכת;
• כלים לרישום, אימות והרשאה של מכשירים/אנשים;
• מסד נתונים המאחסן נתונים תפעוליים וארכיוניים:

ניתן לקרוא את הגרסה הרשמית של מה זה Hyperledger Fabric ב מקוון, ובקיצור, Hyperledger Fabric היא פלטפורמת קוד פתוח המאפשרת לבנות בלוקצ'יין פרטיים ולבצע חוזים חכמים שרירותיים שנכתבו בשפות התכנות JS ו-Go. בואו נסתכל בפירוט על הארכיטקטורה של Hyperledger Fabric ונוודא שזו מערכת אוניברסלית שיש לה רק פרטים ספציפיים לאחסון והקלטת נתונים. הספציפיות היא שהנתונים, כמו בכל הבלוקצ'יין, מאוחסנים בבלוקים שממוקמים בבלוקצ'יין רק אם המשתתפים מגיעים להסכמה ולאחר הקלטת הנתונים לא ניתן לתקן או למחוק בשקט.

Hyperledger Fabric Architecture

התרשים מציג את ארכיטקטורת ה-Hyperledger Fabric:

ארגונים - ארגונים מכילים עמיתים, כלומר. blockchain קיים עקב תמיכה של ארגונים. ארגונים שונים יכולים להיות חלק מאותו ערוץ.

ערוץ - מבנה לוגי המאחד עמיתים לקבוצות, כלומר. הבלוקצ'יין מצוין. Hyperledger Fabric יכול לעבד בו זמנית מספר בלוקצ'יין עם היגיון עסקי שונה.

ספק שירותי חברות (MSP) הוא CA (רשות אישורים) להנפקת זהות והקצאת תפקידים. כדי ליצור צומת, עליך ליצור אינטראקציה עם ה-MSP.

צמתים עמיתים - אימות עסקאות, אחסן את הבלוקצ'יין, בצע חוזים חכמים ואינטראקציה עם יישומים. לעמיתים יש זהות (תעודה דיגיטלית), המונפקת על ידי ה-MSP. בניגוד לרשת הביטקוין או האתריום, שבה לכל הצמתים יש זכויות שוות, ב-Hyperledger Fabric צמתים ממלאים תפקידים שונים:

• עמית אולי מחזק עמית (EP) ולבצע חוזים חכמים.
• עמית מתחייב (CP) - שמור נתונים רק בבלוקצ'יין ועדכן את "מצב העולם".
• עוגן פאר (AP) - אם מספר ארגונים משתתפים בבלוקצ'יין, אזי משתמשים ב-Anchor עמיתים לתקשורת ביניהם. לכל ארגון חייב להיות עמית עוגן אחד או יותר. באמצעות AP, כל עמית בארגון יכול לקבל מידע על כל עמיתים בארגונים אחרים. משמש לסנכרון מידע בין נקודות גישה פרוטוקול רכילות.
• מנהיג פאר - אם לארגון יש כמה עמיתים, אז רק מנהיג העמית יקבל בלוקים משירות ההזמנה וימסור אותם לשאר העמיתים. ניתן לציין את המנהיג באופן סטטי או לבחור באופן דינמי על ידי עמיתים בארגון. פרוטוקול הרכילות משמש גם לסנכרון מידע על מנהיגים.

נכסים - ישויות שיש להן ערך ומאוחסנות בבלוקצ'יין. ליתר דיוק, מדובר בנתוני מפתח-ערך בפורמט JSON. הנתונים האלה מתועדים בבלוקצ'יין. יש להם היסטוריה, אשר מאוחסנת בבלוקצ'יין, ומצב נוכחי, אשר מאוחסן במסד הנתונים "מצב עולמי". מבני נתונים מתמלאים באופן שרירותי בהתאם למשימות העסקיות. אין שדות חובה, ההמלצה היחידה היא שנכסים חייבים להיות בעלי ערך ובעלי ערך.

פנקס - מורכב מבסיס הנתונים של Blockchain ומסד הנתונים של Word, המאחסן את המצב הנוכחי של הנכסים. המדינה העולמית משתמשת ב-LevelDB או ב-CouchDB.

חוזה חכם - באמצעות חוזים חכמים, ההיגיון העסקי של המערכת מיושם. ב-Hyperledger Fabric, חוזים חכמים נקראים chaincode. באמצעות קוד שרשרת, מצוינים נכסים ועסקאות מעליהם. במונחים טכניים, חוזים חכמים הם מודולי תוכנה המיושמים בשפות התכנות JS או Go.

מדיניות אישורים - עבור כל קוד שרשרת, אתה יכול להגדיר מדיניות לגבי כמה אישורים לעסקה יש לצפות וממי. אם המדיניות לא מוגדרת, ברירת המחדל היא: "העסקה חייבת להיות מאושרת על ידי כל חבר בארגון כלשהו בערוץ." דוגמאות לפוליסות:

• העסקה חייבת להיות מאושרת על ידי כל מנהל בארגון;
• חייב להיות מאושר על ידי כל חבר או לקוח בארגון;
• חייב להיות מאושר על ידי כל ארגון עמיתים.

שירות הזמנה - אורז עסקאות לבלוקים ושולח אותן לעמיתים בערוץ. מבטיח משלוח הודעות לכל העמיתים ברשת. משמש למערכות תעשייתיות מתווך הודעות קפקא, לפיתוח ובדיקה סולו.

CallFlow

• היישום מתקשר עם Hyperledger Fabric באמצעות Go, Node.js או Java SDK;
• הלקוח יוצר עסקת TX ושולח אותה לעמיתים תומכים;
• עמית מאמת את חתימת הלקוח, משלים את העסקה ושולח את חתימת האישור בחזרה ללקוח. Chaincode מבוצע רק על עמית המאשר, והתוצאה של ביצועו נשלחת לכל העמיתים. אלגוריתם עבודה זה נקרא קונצנזוס PBFT (Practical Byzantine Fault Tolerant). שונה מ BFT קלאסי העובדה שההודעה נשלחת ואישור צפוי לא מכל המשתתפים, אלא רק מסט מסוים;
• לאחר שהלקוח קיבל את מספר התגובות התואמות את מדיניות האישורים, הוא שולח את העסקה לשירות ההזמנה;
• שירות ההזמנה יוצר בלוק ושולח אותו לכל העמיתים המתחייבים. שירות ההזמנה מבטיח רישום רציף של בלוקים, מה שמבטל את מה שנקרא מזלג חשבונות חשבונות (ראה סעיף "מזלגות");
• עמיתים מקבלים חסימה, בודקים שוב את מדיניות האישורים, כותבים את הבלוק לבלוקצ'יין ומשנים את המצב ב-DB "מצב עולמי".

הָהֵן. זה מביא לחלוקת תפקידים בין הצמתים. זה מבטיח שה-blockchain ניתן להרחבה ומאובטח:

• חוזים חכמים (chaincode) מבצעים אישור עמיתים. זה מבטיח את הסודיות של חוזים חכמים, כי זה לא מאוחסן על ידי כל המשתתפים, אלא רק על ידי אישור עמיתים.
• ההזמנה אמורה לעבוד במהירות. זה מובטח על ידי העובדה שסדר יוצר רק בלוק ושולח אותו לקבוצה קבועה של עמיתים מובילים.
• עמיתים מתחייבים מאחסנים רק את הבלוקצ'יין - יכולים להיות רבים מהם והם לא דורשים הרבה כוח ותפעול מיידי.

פרטים נוספים על הפתרונות הארכיטקטוניים של Hyperledger Fabric ומדוע הוא עובד כך ולא אחרת ניתן למצוא כאן: מקורות אדריכלות או פה: Hyperledger Fabric: מערכת הפעלה מבוזרת לבלוקצ'יין מורשים.

אז, Hyperledger Fabric היא מערכת אוניברסלית באמת שאיתה אתה יכול:

• הטמעת היגיון עסקי שרירותי באמצעות מנגנון החוזה החכם;
• הקלט וקבל נתונים ממסד הנתונים של blockchain בפורמט JSON;
• הענק ואמת גישת API באמצעות רשות האישורים.

עכשיו, כשהבנו קצת על הפרטים של Hyperledger Fabric, בואו סוף סוף נעשה משהו שימושי!

פריסת בלוקצ'יין

הצהרת הבעיה

המשימה היא ליישם את רשת Citcoin עם הפונקציות הבאות: יצירת חשבון, קבלת יתרה, הטעינה בחשבון, העברת מטבעות מחשבון אחד לאחר. נצייר מודל אובייקט, אותו נמשיך ליישם בחוזה חכם. אז יהיו לנו חשבונות שמזוהים בשמות ומכילים יתרה ורשימת חשבונות. חשבונות ורשימת חשבונות הם, במונחים של נכסי Hyperledger Fabric. בהתאם, יש להם היסטוריה ומצב נוכחי. אני אנסה לצייר את זה בצורה ברורה:

הנתונים העליונים הם המצב הנוכחי, המאוחסן במסד הנתונים "מצב עולמי". מתחתיהן מופיעות דמויות המציגות את ההיסטוריה המאוחסנת בבלוקצ'יין. המצב הנוכחי של הנכסים משתנה על ידי עסקאות. הנכס משתנה רק כמכלול, כך שכתוצאה מהעסקה, נוצר אובייקט חדש, והערך הנוכחי של הנכס נכנס להיסטוריה.

ענן IBM

אנו יוצרים חשבון ב ענן IBM. כדי להשתמש בפלטפורמת הבלוקצ'יין, יש לשדרג אותה ל-Pay-As-You-Go. תהליך זה עשוי להיות לא מהיר, כי... IBM מבקשת מידע נוסף ומאמתת אותו באופן ידני. בנימה חיובית, אני יכול לומר של-IBM יש חומרי הדרכה טובים המאפשרים לך לפרוס את Hyperledger Fabric בענן שלהם. אהבתי את סדרת המאמרים והדוגמאות הבאות:

• צור רשת בלוקצ'יין בסיסית באמצעות פלטפורמת הבלוקצ'יין
• צור ובצע חוזה חכם בלוקצ'יין
• פליט אירועים מפלטפורמת Blockchain

להלן צילומי מסך של פלטפורמת IBM Blockchain. זו לא הוראה כיצד ליצור בלוקצ'יין, אלא פשוט הדגמה של היקף המשימה. אז, למטרותינו, אנו יוצרים ארגון אחד:

אנו יוצרים בו צמתים: מסדר CA, Org1 CA, עמית מזמין:

אנו יוצרים משתמשים:

צור ערוץ וקרא לו citcoin:

בעצם ערוץ הוא בלוקצ'יין, אז הוא מתחיל בבלוק אפס (בלוק בראשית):

כתיבת חוזה חכם

/*
 * 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). והנה יש משקוף (שמתם לב?), שמביא לעלייה אינסופית במספר החשבונות. יש להימנע מטעויות כאלה)

לאחר מכן, אנו טוענים את החוזה החכם לערוץ ומציגים אותו:

בואו נסתכל על העסקה להתקנת חוזה חכם:

בואו נסתכל על הפרטים על הערוץ שלנו:

כתוצאה מכך, אנו מקבלים את הדיאגרמה הבאה של רשת בלוקצ'יין בענן IBM. התרשים מציג גם תוכנית הדגמה הפועלת בענן אמזון על שרת וירטואלי (עוד על כך בסעיף הבא):

יצירת GUI עבור קריאות Hyperledger Fabric API

ל-Hyperledger Fabric יש API שניתן להשתמש בו כדי:

• צור ערוץ;
• חיבורים משווים לערוץ;
• התקנה ומופע של חוזים חכמים בערוץ;
• עסקאות שיחות;
• בקש מידע על הבלוקצ'יין.

פיתוח אפליקציות

בתוכנית ההדגמה שלנו נשתמש ב-API רק כדי להתקשר לעסקאות ולבקש מידע, מכיוון את שאר השלבים כבר השלמנו באמצעות פלטפורמת הבלוקצ'יין של IBM. אנו כותבים GUI באמצעות מחסנית טכנולוגיה סטנדרטית: Express.js + Vue.js + Node.js. אתה יכול לכתוב מאמר נפרד על איך להתחיל ליצור יישומי אינטרנט מודרניים. כאן אשאיר קישור לסדרת ההרצאות שהכי אהבתי: Full Stack Web App באמצעות Vue.js & Express.js. התוצאה היא אפליקציית שרת-לקוח עם ממשק גרפי מוכר בסגנון 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 עם דוגמאות הכלולות ב אתר Postman - תוכנית ידועה לבדיקת HTTP API.

אפליקציית הדגמה בענן אמזון

העליתי את האפליקציה לאמזון כי... IBM עדיין לא הצליחה לשדרג את החשבון שלי ולאפשר לי ליצור שרתים וירטואליים. כיצד להוסיף דובדבן לדומיין: www.citcoin.info. אני אשאיר את השרת דולק לזמן מה, ואז כבה אותו, כי... סנטים להשכרה נוטפים, ומטבעות citcoin עדיין לא רשומים בבורסה) אני כולל צילומי מסך של ההדגמה בכתבה כדי שההיגיון של העבודה יהיה ברור. אפליקציית ההדגמה יכולה:

• אתחול הבלוקצ'יין;
• צור חשבון (אך כעת אינך יכול ליצור חשבון חדש, מכיוון שהמספר המרבי של חשבונות שצוין בחוזה החכם הושג בבלוקצ'יין);
• קבל רשימה של חשבונות;
• העבר מטבעות citcoin בין אליס, בוב ואלכס;
• קבל אירועים (אבל עכשיו אין דרך להציג אירועים, אז לשם הפשטות הממשק אומר שאירועים אינם נתמכים);
• יומן פעולות.

ראשית אנו מאתחלים את הבלוקצ'יין:

לאחר מכן, אנו יוצרים את החשבון שלנו, אל תבזבז זמן עם היתרה:

אנו מקבלים רשימה של כל החשבונות הזמינים:

אנו בוחרים את השולח והנמען, ומקבלים את היתרות שלהם. אם השולח והנמען זהים, החשבון שלו יתחדש:

ביומן אנו עוקבים אחר ביצוע העסקאות:

למעשה, זה הכל עם תוכנית ההדגמה. להלן תוכלו לראות את העסקה שלנו בבלוקצ'יין:

והרשימה הכללית של העסקאות:

עם זה, השלמנו בהצלחה את היישום של PoC ליצירת רשת Citcoin. מה עוד צריך לעשות כדי ש-Citcoin תהפוך לרשת מלאה להעברת מטבעות? מעט מאוד:

• בשלב יצירת החשבון יש ליישם יצירת מפתח פרטי/ציבורי. המפתח הפרטי חייב להיות מאוחסן אצל משתמש החשבון, המפתח הציבורי חייב להיות מאוחסן בבלוקצ'יין.
• בצע העברת מטבע שבה מפתח ציבורי, ולא שם, משמש לזיהוי המשתמש.
• הצפין עסקאות העוברות מהמשתמש לשרת באמצעות המפתח הפרטי שלו.

מסקנה

הטמענו את רשת Citcoin עם הפונקציות הבאות: הוספת חשבון, קבלת יתרה, הטעינה בחשבון, העברת מטבעות מחשבון אחד למשנהו. אז מה עלה לנו לבנות PoC?

• אתה צריך ללמוד בלוקצ'יין בכלל ו-Hyperledger Fabric בפרט;
• למד להשתמש בעננים של IBM או אמזון;
• למד את שפת התכנות JS ומסגרת אינטרנט כלשהי;
• אם נתונים מסוימים צריכים להיות מאוחסנים לא בבלוקצ'יין, אלא במסד נתונים נפרד, אז למד לשלב, למשל, עם PostgreSQL;
• ואחרון חביב - אתה לא יכול לחיות בעולם המודרני בלי ידע בלינוקס!)

כמובן, זה לא מדע טילים, אבל תצטרך לעבוד קשה!

מקורות ב-GitHub

מקורות שמו על GitHub. תיאור קצר של המאגר:
קטלוג «שרת» — שרת Node.js
קטלוג «לקוחות» — לקוח Node.js
קטלוג «blockchain"(ערכי פרמטרים ומפתחות, כמובן, אינם פועלים וניתנים רק כדוגמה):

• חוזה - קוד מקור חוזה חכם
• ארנק - מפתחות משתמש לשימוש ב- Hyperledger Fabric API.
• *.cds - גרסאות הידור של חוזים חכמים
• קבצי *.json - דוגמאות לקובצי תצורה לשימוש ב- Hyperledger Fabric API

זו רק ההתחלה!

מקור: www.habr.com