🥇Blockchain: เราควรสร้าง PoC อะไร

ดวงตาของคุณกลัวและมือของคุณก็คัน!

ในบทความก่อนหน้านี้ เราจัดการกับเทคโนโลยีที่ใช้สร้างบล็อกเชน (เราควรสร้างบล็อคเชนอย่างไร?) และกรณีต่างๆ ที่สามารถดำเนินการได้ด้วยความช่วยเหลือ (ทำไมเราต้องสร้างเคส?). ถึงเวลาทำงานด้วยมือของคุณแล้ว! ในการใช้งานโปรแกรมนำร่องและ PoC (Proof of Concept) ฉันชอบใช้คลาวด์มากกว่า เพราะ... สามารถเข้าถึงได้จากทุกที่ในโลก และบ่อยครั้งไม่จำเป็นต้องเสียเวลากับการติดตั้งสภาพแวดล้อมที่น่าเบื่อ เนื่องจาก มีการกำหนดค่าที่กำหนดไว้ล่วงหน้า ดังนั้น เรามาสร้างสิ่งง่ายๆ กัน เช่น เครือข่ายสำหรับการโอนเหรียญระหว่างผู้เข้าร่วม และเรียกมันว่า Bitcoin กันดีกว่า สำหรับสิ่งนี้ เราจะใช้ IBM cloud และ universal blockchain Hyperledger Fabric ก่อนอื่น เรามาดูกันว่าเหตุใด Hyperledger Fabric จึงถูกเรียกว่าบล็อกเชนสากล

Hyperledger Fabric - บล็อกเชนสากล

โดยทั่วไปแล้ว ระบบสารสนเทศที่เป็นสากลคือ:

ชุดเซิร์ฟเวอร์และแกนซอฟต์แวร์ที่ทำงานเชิงตรรกะทางธุรกิจ
อินเทอร์เฟซสำหรับการโต้ตอบกับระบบ
เครื่องมือสำหรับการลงทะเบียน การรับรองความถูกต้อง และการอนุญาตอุปกรณ์/บุคคล
ฐานข้อมูลที่จัดเก็บข้อมูลการดำเนินงานและการเก็บถาวร:

สามารถอ่าน Hyperledger Fabric เวอร์ชันอย่างเป็นทางการได้ที่ เว็บไซต์กล่าวโดยย่อคือ Hyperledger Fabric เป็นแพลตฟอร์มโอเพ่นซอร์สที่ช่วยให้คุณสามารถสร้างบล็อกเชนส่วนตัวและดำเนินการสัญญาอัจฉริยะตามอำเภอใจที่เขียนด้วยภาษาการเขียนโปรแกรม JS และ Go มาดูรายละเอียดเกี่ยวกับสถาปัตยกรรมของ Hyperledger Fabric และตรวจสอบให้แน่ใจว่านี่เป็นระบบสากลที่มีเฉพาะในการจัดเก็บและบันทึกข้อมูลเท่านั้น ความเฉพาะเจาะจงคือข้อมูล เช่นเดียวกับในบล็อกเชนทั้งหมด จะถูกจัดเก็บไว้ในบล็อกที่วางอยู่บนบล็อกเชนก็ต่อเมื่อผู้เข้าร่วมได้รับฉันทามติ และหลังจากบันทึกข้อมูลแล้ว จะไม่สามารถแก้ไขหรือลบอย่างเงียบๆ ได้

สถาปัตยกรรมผ้าไฮเปอร์เลดเจอร์

แผนภาพแสดงสถาปัตยกรรม Hyperledger Fabric:

องค์กร — องค์กรประกอบด้วยเพื่อนร่วมงาน เช่น blockchain มีอยู่เนื่องจากการสนับสนุนจากองค์กรต่างๆ องค์กรต่างๆ สามารถเป็นส่วนหนึ่งของช่องทางเดียวกันได้

ช่อง — โครงสร้างเชิงตรรกะที่รวมกลุ่มเพื่อนออกเป็นกลุ่ม เช่น มีการระบุบล็อคเชน Hyperledger Fabric สามารถประมวลผลบล็อกเชนหลายรายการพร้อมกันด้วยตรรกะทางธุรกิจที่แตกต่างกัน

ผู้ให้บริการสมาชิก (MSP) เป็น CA (ผู้ออกใบรับรอง) สำหรับการออกข้อมูลประจำตัวและการกำหนดบทบาท หากต้องการสร้างโหนด คุณต้องโต้ตอบกับ MSP

โหนดเพียร์ — ตรวจสอบธุรกรรม จัดเก็บบล็อคเชน ดำเนินการสัญญาอัจฉริยะ และโต้ตอบกับแอปพลิเคชัน เพื่อนร่วมงานมีตัวตน (ใบรับรองดิจิทัล) ซึ่งออกโดย MSP ต่างจากเครือข่าย Bitcoin หรือ Etherium ที่โหนดทั้งหมดมีสิทธิ์เท่าเทียมกัน ในโหนด Hyperledger Fabric มีบทบาทที่แตกต่างกัน:

เพื่อนอาจจะ รับรองเพื่อน (EP) และดำเนินการสัญญาอัจฉริยะ
มุ่งมั่นเพียร์ (CP) - บันทึกเฉพาะข้อมูลใน blockchain และอัปเดต "สถานะโลก"
แองเคอร์ เพียร์ (AP) - หากหลายองค์กรมีส่วนร่วมในบล็อคเชน ก็จะมีการใช้ Anchor peer เพื่อการสื่อสารระหว่างกัน แต่ละองค์กรต้องมีเพื่อน Anchor อย่างน้อย XNUMX คน เมื่อใช้ AP เพื่อนในองค์กรสามารถรับข้อมูลเกี่ยวกับเพื่อนทั้งหมดในองค์กรอื่นได้ ใช้เพื่อซิงโครไนซ์ข้อมูลระหว่าง AP โปรโตคอลการนินทา.
ผู้นำเพียร์ — หากองค์กรมีเพื่อนหลายราย เฉพาะผู้นำเท่านั้นที่จะได้รับบล็อกจากบริการการสั่งซื้อและมอบบล็อกเหล่านั้นให้กับเพื่อนที่เหลือ ผู้นำสามารถระบุแบบคงที่หรือเลือกแบบไดนามิกโดยเพื่อนในองค์กร โปรโตคอลการนินทายังใช้เพื่อซิงโครไนซ์ข้อมูลเกี่ยวกับผู้นำอีกด้วย

สินทรัพย์ — เอนทิตีที่มีมูลค่าและถูกจัดเก็บไว้ในบล็อกเชน กล่าวอย่างเจาะจงคือ นี่คือข้อมูลคีย์-ค่าในรูปแบบ JSON เป็นข้อมูลนี้ที่ถูกบันทึกไว้ใน Blockchain พวกเขามีประวัติซึ่งจัดเก็บไว้ในบล็อกเชน และสถานะปัจจุบันซึ่งจัดเก็บไว้ในฐานข้อมูล "สถานะโลก" โครงสร้างข้อมูลถูกเติมโดยพลการขึ้นอยู่กับงานทางธุรกิจ ไม่มีฟิลด์บังคับ คำแนะนำเดียวคือสินทรัพย์ต้องมีเจ้าของและมีคุณค่า

บัญชีแยกประเภท — ประกอบด้วยฐานข้อมูล Blockchain และ Word ซึ่งจัดเก็บสถานะปัจจุบันของสินทรัพย์ รัฐโลกใช้ LevelDB หรือ CouchDB

สัญญาสมาร์ท — การใช้สัญญาอัจฉริยะ ตรรกะทางธุรกิจของระบบจะถูกนำไปใช้ ใน Hyperledger Fabric สัญญาอัจฉริยะเรียกว่าเชนโค้ด การใช้รหัสลูกโซ่ สินทรัพย์และธุรกรรมจะถูกระบุ ในแง่เทคนิค สัญญาอัจฉริยะคือโมดูลซอฟต์แวร์ที่ใช้งานในภาษาโปรแกรม JS หรือ Go

นโยบายการรับรอง — สำหรับแต่ละ chaincode คุณสามารถกำหนดนโยบายว่าควรจะมีการยืนยันธุรกรรมกี่ครั้งและจากใคร หากไม่ได้ตั้งค่านโยบาย ค่าเริ่มต้นคือ "ธุรกรรมจะต้องได้รับการยืนยันโดยสมาชิกขององค์กรใดๆ ในช่องทาง" ตัวอย่างของนโยบาย:

ธุรกรรมจะต้องได้รับการอนุมัติจากผู้ดูแลระบบขององค์กร
ต้องได้รับการยืนยันจากสมาชิกหรือลูกค้าขององค์กร
จะต้องได้รับการยืนยันจากองค์กรที่คล้ายคลึงกัน

บริการสั่งซื้อ — แพ็คธุรกรรมเป็นบล็อคและส่งให้เพื่อนในช่อง รับประกันการส่งข้อความถึงเพื่อนทุกคนบนเครือข่าย ใช้สำหรับระบบอุตสาหกรรม นายหน้าข้อความคาฟคาเพื่อการพัฒนาและการทดสอบ เดียว.

คอลโฟลว์

แอปพลิเคชันสื่อสารกับ Hyperledger Fabric โดยใช้ Go, Node.js หรือ Java SDK
ลูกค้าสร้างธุรกรรม tx และส่งไปยังเพื่อนที่รับรอง
เพียร์จะตรวจสอบลายเซ็นของลูกค้า ทำธุรกรรมให้เสร็จสิ้น และส่งลายเซ็นรับรองกลับไปยังลูกค้า Chaincode จะดำเนินการบนเพียร์ที่รับรองเท่านั้น และผลลัพธ์ของการดำเนินการจะถูกส่งไปยังเพียร์ทั้งหมด อัลกอริธึมการทำงานนี้เรียกว่าฉันทามติ PBFT (Practical Byzantine Fault Tolerant) แตกต่างจาก บีเอฟที คลาสสิค ความจริงที่ว่าข้อความถูกส่งและการยืนยันไม่ได้คาดหวังจากผู้เข้าร่วมทุกคน แต่จากบางชุดเท่านั้น
หลังจากที่ลูกค้าได้รับการตอบกลับตามจำนวนที่สอดคล้องกับนโยบายการรับรองแล้ว เขาจะส่งธุรกรรมไปยังบริการการสั่งซื้อ
บริการสั่งซื้อจะสร้างบล็อกและส่งไปยังเพื่อนที่กระทำการทั้งหมด บริการสั่งซื้อช่วยให้มั่นใจได้ถึงการบันทึกบล็อกตามลำดับ ซึ่งกำจัดสิ่งที่เรียกว่าการแยกบัญชีแยกประเภท (ดูส่วน "ส้อม");
เพื่อนร่วมงานจะได้รับบล็อก ตรวจสอบนโยบายการรับรองอีกครั้ง เขียนบล็อกลงในบล็อกเชน และเปลี่ยนสถานะในฐานข้อมูล "สถานะโลก"

เหล่านั้น. ส่งผลให้มีการแบ่งบทบาทระหว่างโหนด สิ่งนี้ทำให้มั่นใจได้ว่าบล็อคเชนสามารถปรับขนาดได้และปลอดภัย:

สัญญาอัจฉริยะ (รหัสลูกโซ่) ดำเนินการรับรองเพื่อน สิ่งนี้ทำให้มั่นใจได้ถึงการรักษาความลับของสัญญาอัจฉริยะเพราะว่า มันไม่ได้ถูกจัดเก็บโดยผู้เข้าร่วมทั้งหมด แต่โดยการรับรองจากเพื่อนเท่านั้น
การสั่งซื้อควรจะทำงานได้อย่างรวดเร็ว สิ่งนี้รับประกันได้ด้วยความจริงที่ว่า Ordering จะสร้างบล็อกและส่งไปยังกลุ่มผู้นำที่ตายตัวเท่านั้น
เพื่อนร่วมงานที่คอมมิตจะจัดเก็บเฉพาะบล็อคเชนเท่านั้น - อาจมีหลายๆ บล็อคเชน และพวกเขาไม่ต้องการพลังงานจำนวนมากและการดำเนินการทันที

รายละเอียดเพิ่มเติมเกี่ยวกับโซลูชันทางสถาปัตยกรรมของ Hyperledger Fabric และเหตุใดจึงทำงานในลักษณะนี้ สามารถพบได้ที่นี่: ต้นกำเนิดสถาปัตยกรรม หรือที่นี่: Hyperledger Fabric: ระบบปฏิบัติการแบบกระจายสำหรับบล็อกเชนที่ได้รับอนุญาต.

ดังนั้น Hyperledger Fabric จึงเป็นระบบสากลอย่างแท้จริงซึ่งคุณสามารถ:

ใช้ตรรกะทางธุรกิจตามอำเภอใจโดยใช้กลไกสัญญาอัจฉริยะ
บันทึกและรับข้อมูลจากฐานข้อมูล blockchain ในรูปแบบ JSON
ให้สิทธิ์และตรวจสอบการเข้าถึง API โดยใช้ผู้ออกใบรับรอง

ตอนนี้เราเข้าใจเพียงเล็กน้อยเกี่ยวกับลักษณะเฉพาะของ Hyperledger Fabric แล้ว เรามาทำอะไรที่มีประโยชน์กันดีกว่า!

การปรับใช้บล็อคเชน

คำแถลงปัญหา

ภารกิจคือการใช้เครือข่าย Citcoin ด้วยฟังก์ชันต่อไปนี้: สร้างบัญชี รับยอดคงเหลือ เติมเงินในบัญชีของคุณ โอนเหรียญจากบัญชีหนึ่งไปยังอีกบัญชีหนึ่ง มาวาดโมเดลออบเจ็กต์ซึ่งเราจะนำไปใช้ในสัญญาอัจฉริยะต่อไป ดังนั้นเราจะมีบัญชีที่ระบุชื่อและประกอบด้วยยอดคงเหลือและรายการบัญชี บัญชีและรายการบัญชีในแง่ของสินทรัพย์ Hyperledger Fabric พวกเขามีประวัติและสถานะปัจจุบัน ฉันจะพยายามวาดให้ชัดเจน:

ตัวเลขบนสุดคือสถานะปัจจุบันซึ่งจัดเก็บไว้ในฐานข้อมูล “สถานะโลก” ด้านล่างนี้เป็นตัวเลขที่แสดงประวัติที่จัดเก็บไว้ในบล็อกเชน สถานะปัจจุบันของสินทรัพย์มีการเปลี่ยนแปลงตามธุรกรรม สินทรัพย์เปลี่ยนแปลงในภาพรวมเท่านั้น ดังนั้นผลจากการทำธุรกรรมจึงมีการสร้างออบเจ็กต์ใหม่ขึ้น และมูลค่าปัจจุบันของสินทรัพย์จะเข้าสู่ประวัติ

ไอบีเอ็ม คลาวด์

เราสร้างบัญชีใน ไอบีเอ็มคลาวด์. หากต้องการใช้แพลตฟอร์มบล็อกเชน จะต้องอัปเกรดเป็น Pay-As-You-Go กระบวนการนี้อาจไม่รวดเร็วนักเพราะ... IBM ขอข้อมูลเพิ่มเติมและตรวจสอบด้วยตนเอง ในแง่บวก ฉันสามารถพูดได้ว่า IBM มีสื่อการฝึกอบรมที่ดีที่ช่วยให้คุณสามารถปรับใช้ Hyperledger Fabric ในระบบคลาวด์ของพวกเขาได้ ฉันชอบบทความและตัวอย่างชุดต่อไปนี้:

ต่อไปนี้เป็นภาพหน้าจอของแพลตฟอร์ม IBM Blockchain นี่ไม่ใช่คำแนะนำเกี่ยวกับวิธีการสร้างบล็อกเชน แต่เป็นเพียงการสาธิตขอบเขตของงาน ดังนั้น เพื่อจุดประสงค์ของเรา เราจึงสร้างองค์กรขึ้นมาหนึ่งองค์กร:

เราสร้างโหนดในนั้น: Orderer CA, Org1 CA, Orderer Peer:

เราสร้างผู้ใช้:

สร้างช่องและเรียกมันว่า citcoin:

โดยพื้นฐานแล้ว Channel คือ blockchain ดังนั้นจึงเริ่มต้นด้วยบล็อกศูนย์ (Genesis block):

การเขียนสัญญาอัจฉริยะ

/*
 * 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) และนี่คือวงกบ (คุณสังเกตไหม) ซึ่งนำไปสู่การเพิ่มจำนวนบัญชีอย่างไม่สิ้นสุด ควรหลีกเลี่ยงข้อผิดพลาดดังกล่าว)

ต่อไป เราจะโหลดสัญญาอัจฉริยะลงใน Channel และยกตัวอย่าง:

มาดูธุรกรรมการติดตั้ง Smart Contract กัน:

มาดูรายละเอียดเกี่ยวกับช่องของเรา:

ด้วยเหตุนี้ เราจึงได้รับไดอะแกรมของเครือข่ายบล็อกเชนใน IBM Cloud ดังต่อไปนี้ แผนภาพยังแสดงโปรแกรมสาธิตที่ทำงานในระบบคลาวด์ของ Amazon บนเซิร์ฟเวอร์เสมือน (เพิ่มเติมเกี่ยวกับเรื่องนี้ในส่วนถัดไป):

การสร้าง 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 ของ Google REST API ระหว่างไคลเอนต์และเซิร์ฟเวอร์ประกอบด้วยการเรียกหลายครั้ง:

HyperledgerDemo/v1/init - เริ่มต้น blockchain;
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 — โอนสองเหรียญจาก Bob ไปยัง Alice;
HyperledgerDemo/v1/disconnect - ปิดการเชื่อมต่อกับบล็อคเชน

คำอธิบายของ API พร้อมตัวอย่างที่รวมอยู่ใน เว็บไซต์บุรุษไปรษณีย์ - โปรแกรมที่รู้จักกันดีสำหรับการทดสอบ HTTP API

แอปพลิเคชันสาธิตในระบบคลาวด์ของ Amazon

ฉันอัพโหลดแอปพลิเคชันไปที่ Amazon เพราะ... IBM ยังไม่สามารถอัปเกรดบัญชีของฉันได้ และอนุญาตให้ฉันสร้างเซิร์ฟเวอร์เสมือนได้ วิธีเพิ่มเชอร์รี่ให้กับโดเมน: www.citcoin.info. ฉันจะเปิดเซิร์ฟเวอร์ไว้สักพักแล้วจึงปิด เพราะ... เซนต์ให้เช่ากำลังหยดและเหรียญ citcoin ยังไม่มีรายชื่อในตลาดหลักทรัพย์) ฉันกำลังรวมภาพหน้าจอของการสาธิตในบทความเพื่อให้ตรรกะของการทำงานชัดเจน แอปพลิเคชันสาธิตสามารถ:

เริ่มต้นบล็อคเชน
สร้างบัญชี (แต่ตอนนี้คุณไม่สามารถสร้างบัญชีใหม่ได้ เนื่องจากถึงจำนวนบัญชีสูงสุดที่ระบุในสัญญาอัจฉริยะในบล็อกเชนแล้ว)
รับรายการบัญชี
โอนเหรียญ citcoin ระหว่าง Alice, Bob และ Alex;
รับกิจกรรม (แต่ขณะนี้ไม่มีวิธีแสดงกิจกรรม ดังนั้นเพื่อความง่าย อินเทอร์เฟซแจ้งว่าไม่รองรับกิจกรรม)
บันทึกการกระทำ

ขั้นแรกเราเริ่มต้น blockchain:

ต่อไปเราสร้างบัญชีของเรา ไม่ต้องเสียเวลากับยอดคงเหลือ:

เราได้รับรายการบัญชีที่มีอยู่ทั้งหมด:

เราเลือกผู้ส่งและผู้รับ และรับยอดคงเหลือ หากผู้ส่งและผู้รับเหมือนกัน บัญชีของเขาจะถูกเติมเต็ม:

ในบันทึก เราตรวจสอบการดำเนินการของธุรกรรม:

จริงๆ แล้วนั่นคือทั้งหมดที่มีในโปรแกรมสาธิต ด้านล่างคุณสามารถดูธุรกรรมของเราในบล็อคเชน:

และรายการธุรกรรมทั่วไป:

ด้วยเหตุนี้ เราจึงประสบความสำเร็จในการดำเนินการตาม PoC เพื่อสร้างเครือข่าย Citcoin จะต้องทำอะไรอีกบ้างเพื่อให้ Citcoin กลายเป็นเครือข่ายการโอนเหรียญอย่างเต็มรูปแบบ? น้อยมาก:

ในขั้นตอนการสร้างบัญชี ให้ดำเนินการสร้างคีย์ส่วนตัว/สาธารณะ คีย์ส่วนตัวจะต้องถูกจัดเก็บไว้กับผู้ใช้บัญชี คีย์สาธารณะจะต้องถูกเก็บไว้ในบล็อกเชน
ทำการโอนเงินโดยใช้กุญแจสาธารณะ แทนที่จะใช้ชื่อ เพื่อระบุตัวผู้ใช้
เข้ารหัสธุรกรรมที่ส่งจากผู้ใช้ไปยังเซิร์ฟเวอร์ด้วยรหัสส่วนตัวของเขา

ข้อสรุป

เราได้ติดตั้งเครือข่าย Citcoin ด้วยฟังก์ชันดังต่อไปนี้: เพิ่มบัญชี รับยอดคงเหลือ เติมเงินในบัญชีของคุณ โอนเหรียญจากบัญชีหนึ่งไปยังอีกบัญชีหนึ่ง แล้วการสร้าง PoC มีค่าใช้จ่ายเท่าไร?

คุณต้องศึกษาบล็อกเชนโดยทั่วไปและโดยเฉพาะ Hyperledger Fabric
เรียนรู้การใช้ IBM หรือ Amazon Cloud;
เรียนรู้ภาษาการเขียนโปรแกรม JS และกรอบงานเว็บบางส่วน
หากข้อมูลบางอย่างจำเป็นต้องจัดเก็บไม่ได้อยู่ในบล็อกเชน แต่อยู่ในฐานข้อมูลแยกต่างหาก ให้เรียนรู้ที่จะบูรณาการ เช่น กับ PostgreSQL
และสุดท้ายแต่ไม่ท้ายสุด - คุณไม่สามารถอยู่ในโลกสมัยใหม่ได้หากไม่มีความรู้เกี่ยวกับ Linux!)

แน่นอนว่านี่ไม่ใช่วิทยาศาสตร์จรวด แต่คุณจะต้องทำงานหนัก!

แหล่งที่มาบน GitHub

แหล่งที่มาใส่ GitHub. คำอธิบายสั้น ๆ ของที่เก็บ:
แคตตาล็อก «เซิร์ฟเวอร์» — เซิร์ฟเวอร์ Node.js
แคตตาล็อก «ไคลเอนต์» — ไคลเอ็นต์ Node.js
แคตตาล็อก «blockchain"(แน่นอนว่าค่าพารามิเตอร์และคีย์ไม่ทำงานและให้ไว้เป็นตัวอย่างเท่านั้น):

สัญญา - ซอร์สโค้ดสัญญาอัจฉริยะ
wallet — รหัสผู้ใช้สำหรับการใช้ Hyperledger Fabric API
*.cds - สัญญาอัจฉริยะเวอร์ชันที่คอมไพล์แล้ว
ไฟล์ *.json - ตัวอย่างไฟล์การกำหนดค่าสำหรับการใช้ Hyperledger Fabric API

มันเป็นเพียงจุดเริ่มต้น!

ที่มา: will.com

Blockchain: เราควรสร้าง PoC อะไร