🥇Blockchain៖ តើយើងចំណាយប្រាក់ប៉ុន្មានក្នុងការសាងសង់ PoC?

ភ្នែករបស់អ្នកខ្លាចហើយដៃរបស់អ្នករមាស់!

នៅក្នុងអត្ថបទមុន យើងបានដោះស្រាយជាមួយនឹងបច្ចេកវិទ្យាដែល blockchains ត្រូវបានសាងសង់ (តើយើងគួរបង្កើត blockchain អ្វីខ្លះ?) និងករណីដែលអាចត្រូវបានអនុវត្តដោយជំនួយរបស់ពួកគេ (ហេតុអ្វីបានជាយើងគួរកសាងសំណុំរឿង?) ដល់ពេលធ្វើការជាមួយដៃរបស់អ្នកហើយ! ដើម្បីអនុវត្ត Pilots និង PoC (Proof of Concept) ខ្ញុំចូលចិត្តប្រើពពក ព្រោះ... ពួកគេអាចចូលប្រើបានពីគ្រប់ទិសទីក្នុងពិភពលោក ហើយជារឿយៗ មិនចាំបាច់ខ្ជះខ្ជាយពេលវេលាលើការដំឡើងបរិស្ថានដ៏ធុញទ្រាន់នោះទេ ពីព្រោះ មានការកំណត់រចនាសម្ព័ន្ធជាមុន។ ដូច្នេះ ចូរយើងបង្កើតអ្វីដែលសាមញ្ញ ឧទាហរណ៍ បណ្តាញសម្រាប់ផ្ទេរកាក់រវាងអ្នកចូលរួម ហើយហៅវាថា Bitcoin ដោយសុភាពរាបសា។ សម្រាប់បញ្ហានេះយើងនឹងប្រើ IBM cloud និង universal blockchain Hyperledger Fabric ។ ជាដំបូង ចូរយើងស្វែងយល់ថាហេតុអ្វីបានជាក្រណាត់ Hyperledger ត្រូវបានគេហៅថាជាសកល blockchain?

ក្រណាត់ Hyperledger - ជា blockchain សកល

និយាយជាទូទៅ ប្រព័ន្ធព័ត៌មានសកលគឺ៖

សំណុំនៃម៉ាស៊ីនមេ និងស្នូលកម្មវិធីដែលដំណើរការតក្កវិជ្ជាអាជីវកម្ម។
ចំណុចប្រទាក់សម្រាប់អន្តរកម្មជាមួយប្រព័ន្ធ;
ឧបករណ៍សម្រាប់ការចុះឈ្មោះ ការផ្ទៀងផ្ទាត់ និងការអនុញ្ញាតឧបករណ៍/មនុស្ស;
មូលដ្ឋានទិន្នន័យរក្សាទុកទិន្នន័យប្រតិបត្តិការ និងបណ្ណសារ៖

កំណែផ្លូវការនៃអ្វីដែល Hyperledger Fabric គឺអាចអានបាននៅ តំបន់បណ្តាញហើយនិយាយឱ្យខ្លី Hyperledger Fabric គឺជាវេទិកាប្រភពបើកចំហដែលអនុញ្ញាតឱ្យអ្នកបង្កើត blockchains ឯកជន និងអនុវត្តកិច្ចសន្យាឆ្លាតវៃដែលបានសរសេរនៅក្នុងភាសាសរសេរកម្មវិធី JS និង Go ។ សូមក្រឡេកមើលលម្អិតអំពីស្ថាបត្យកម្មនៃ Hyperledger Fabric ហើយត្រូវប្រាកដថានេះគឺជាប្រព័ន្ធសកលដែលមានលក្ខណៈពិសេសសម្រាប់រក្សាទុក និងកត់ត្រាទិន្នន័យប៉ុណ្ណោះ។ ភាពជាក់លាក់គឺថាទិន្នន័យដូចនៅក្នុង blockchain ទាំងអស់ត្រូវបានរក្សាទុកក្នុងប្លុកដែលត្រូវបានដាក់នៅលើ blockchain លុះត្រាតែអ្នកចូលរួមឈានដល់ការយល់ស្របហើយបន្ទាប់ពីការកត់ត្រាទិន្នន័យមិនអាចកែតម្រូវឬលុបដោយស្ងៀមស្ងាត់បានទេ។

ស្ថាបត្យកម្មក្រណាត់ Hyperledger

ដ្យាក្រាមបង្ហាញពីស្ថាបត្យកម្ម Hyperledger Fabric៖

អង្គការ - អង្គការមានមិត្តរួមការងារ ឧ. blockchain មានដោយសារតែការគាំទ្រពីអង្គការ។ អង្គការផ្សេងគ្នាអាចជាផ្នែកមួយនៃឆានែលដូចគ្នា។

ឆានែល - រចនាសម្ព័ន្ធឡូជីខលដែលបង្រួបបង្រួមមិត្តរួមការងារជាក្រុម ឧ. blockchain ត្រូវបានបញ្ជាក់។ ក្រណាត់ Hyperledger អាចដំណើរការ blockchains ជាច្រើនក្នុងពេលដំណាលគ្នាជាមួយនឹងតក្កវិជ្ជាអាជីវកម្មផ្សេងៗគ្នា។

អ្នកផ្តល់សេវាសមាជិកភាព (MSP) គឺជា CA (អាជ្ញាធរវិញ្ញាបនបត្រ) សម្រាប់ចេញអត្តសញ្ញាណ និងផ្តល់តួនាទី។ ដើម្បីបង្កើតថ្នាំង អ្នកត្រូវធ្វើអន្តរកម្មជាមួយ MSP ។

ថ្នាំងមិត្តភក្ដិ - ផ្ទៀងផ្ទាត់ប្រតិបត្តិការ រក្សាទុក blockchain ប្រតិបត្តិកិច្ចសន្យាឆ្លាតវៃ និងធ្វើអន្តរកម្មជាមួយកម្មវិធី។ មិត្តភ័ក្តិមានអត្តសញ្ញាណ (វិញ្ញាបនបត្រឌីជីថល) ដែលត្រូវបានចេញដោយ MSP ។ មិនដូចបណ្តាញ Bitcoin ឬ Etherium ដែលថ្នាំងទាំងអស់មានសិទ្ធិស្មើគ្នាទេ ក្នុង Hyperledger Fabric nodes ដើរតួនាទីផ្សេងៗគ្នា៖

ប្រហែល ការគាំទ្រមិត្តភក្តិ (EP) និងអនុវត្តកិច្ចសន្យាឆ្លាតវៃ។
ការប្តេជ្ញាចិត្ត (CP) - រក្សាទុកតែទិន្នន័យនៅក្នុង blockchain និងធ្វើបច្ចុប្បន្នភាព "ស្ថានភាពពិភពលោក" ។
យុថ្កា Peer (AP) - ប្រសិនបើអង្គការមួយចំនួនចូលរួមក្នុង blockchain នោះ មិត្តរួមយុថ្កាត្រូវបានប្រើសម្រាប់ការទំនាក់ទំនងរវាងពួកគេ។ ស្ថាប័ននីមួយៗត្រូវតែមានដៃគូសហការយុថ្កាមួយ ឬច្រើន។ ដោយប្រើ AP មិត្តភ័ក្តិក្នុងស្ថាប័នណាមួយអាចទទួលបានព័ត៌មានអំពីមិត្តភក្ដិទាំងអស់នៅក្នុងអង្គការផ្សេងទៀត។ ប្រើដើម្បីធ្វើសមកាលកម្មព័ត៌មានរវាង APs ពិធីការនិយាយដើម.
អ្នកដឹកនាំ Peer — ប្រសិនបើស្ថាប័នមួយមានមិត្តភ័ក្តិច្រើននាក់ នោះមានតែអ្នកដឹកនាំនៃមិត្តភក្ដិប៉ុណ្ណោះដែលនឹងទទួលបានប្លុកពីសេវាកម្មបញ្ជាទិញ ហើយផ្តល់ឱ្យពួកគេទៅមិត្តភក្ដិដែលនៅសល់។ អ្នកដឹកនាំអាចត្រូវបានបញ្ជាក់ដោយឋិតិវន្ត ឬត្រូវបានជ្រើសរើសដោយថាមវន្តដោយមិត្តភ័ក្តិនៅក្នុងស្ថាប័ន។ ពិធីការនិយាយដើមក៏ត្រូវបានប្រើដើម្បីធ្វើសមកាលកម្មព័ត៌មានអំពីអ្នកដឹកនាំផងដែរ។

ទ្រព្យសកម្ម - អង្គភាពដែលមានតម្លៃនិងត្រូវបានរក្សាទុកនៅលើ blockchain ។ ពិសេសជាងនេះទៅទៀត នេះគឺជាទិន្នន័យតម្លៃគន្លឹះក្នុងទម្រង់ JSON ។ វាគឺជាទិន្នន័យនេះដែលត្រូវបានកត់ត្រានៅក្នុង Blockchain ។ ពួកគេមានប្រវត្តិមួយ ដែលត្រូវបានរក្សាទុកនៅក្នុង blockchain និងស្ថានភាពបច្ចុប្បន្ន ដែលត្រូវបានរក្សាទុកនៅក្នុងមូលដ្ឋានទិន្នន័យ "រដ្ឋពិភពលោក" ។ រចនាសម្ព័ន្ធទិន្នន័យត្រូវបានបំពេញតាមអំពើចិត្ត អាស្រ័យលើភារកិច្ចអាជីវកម្ម។ មិនមានវាលដែលត្រូវការទេ ការណែនាំតែមួយគត់គឺថាទ្រព្យសម្បត្តិត្រូវតែមានម្ចាស់ និងមានតម្លៃ។

សៀវភៅធំ - រួមមាន Blockchain និង Word state database ដែលរក្សាទុកស្ថានភាពបច្ចុប្បន្ននៃទ្រព្យសកម្ម។ រដ្ឋពិភពលោកប្រើ LevelDB ឬ CouchDB ។

កិច្ចសន្យាឆ្លាត - ដោយប្រើកិច្ចសន្យាឆ្លាតវៃ តក្កវិជ្ជាអាជីវកម្មនៃប្រព័ន្ធត្រូវបានអនុវត្ត។ នៅក្នុង Hyperledger Fabric កិច្ចសន្យាឆ្លាតវៃត្រូវបានគេហៅថា chaincode ។ ការប្រើប្រាស់កូដខ្សែសង្វាក់ ទ្រព្យសម្បត្តិ និងប្រតិបត្តិការលើពួកវាត្រូវបានបញ្ជាក់។ នៅក្នុងលក្ខខណ្ឌបច្ចេកទេស កិច្ចសន្យាឆ្លាតវៃគឺជាម៉ូឌុលកម្មវិធីដែលត្រូវបានអនុវត្តនៅក្នុងភាសាសរសេរកម្មវិធី JS ឬ Go ។

គោលនយោបាយអនុម័ត — សម្រាប់លេខកូដខ្សែសង្វាក់នីមួយៗ អ្នកអាចកំណត់គោលការណ៍ស្តីពីចំនួនការបញ្ជាក់សម្រាប់ប្រតិបត្តិការដែលគួរត្រូវបានរំពឹងទុក និងពីអ្នកណា។ ប្រសិនបើគោលការណ៍មិនត្រូវបានកំណត់ នោះលំនាំដើមគឺ៖ "ប្រតិបត្តិការត្រូវតែបញ្ជាក់ដោយសមាជិកនៃស្ថាប័នណាមួយនៅក្នុងប៉ុស្តិ៍។" ឧទាហរណ៍នៃគោលនយោបាយ៖

ប្រតិបត្តិការត្រូវតែត្រូវបានអនុម័តដោយអ្នកគ្រប់គ្រងណាមួយនៃអង្គការ។
ត្រូវតែបញ្ជាក់ដោយសមាជិកណាមួយ ឬអតិថិជនរបស់អង្គការ។
ត្រូវតែបញ្ជាក់ដោយអង្គការមិត្តភ័ក្តិណាមួយ។

សេវាកម្មបញ្ជាទិញ - ខ្ចប់ប្រតិបត្តិការចូលទៅក្នុងប្លុក ហើយផ្ញើវាទៅមិត្តភ័ក្តិនៅក្នុងឆានែល។ ធានាការបញ្ជូនសារទៅកាន់មិត្តភ័ក្តិទាំងអស់នៅលើបណ្តាញ។ ប្រើសម្រាប់ប្រព័ន្ធឧស្សាហកម្ម ឈ្មួញកណ្តាលសារ Kafkaសម្រាប់ការអភិវឌ្ឍន៍ និងការសាកល្បង ទោល.

CallFlow

កម្មវិធីទំនាក់ទំនងជាមួយ Hyperledger Fabric ដោយប្រើ Go, Node.js ឬ Java SDK;
អតិថិជនបង្កើតប្រតិបត្តិការ tx ហើយផ្ញើវាទៅមិត្តភក្ដិដែលគាំទ្រ។
Peer ផ្ទៀងផ្ទាត់ហត្ថលេខារបស់អតិថិជន បញ្ចប់ប្រតិបត្តិការ និងផ្ញើហត្ថលេខាយល់ព្រមត្រឡប់ទៅអតិថិជនវិញ។ Chaincode ត្រូវបានប្រតិបត្តិតែលើអ្នកគាំទ្រប៉ុណ្ណោះ ហើយលទ្ធផលនៃការប្រតិបត្តិរបស់វាត្រូវបានផ្ញើទៅមិត្តភក្តិទាំងអស់។ ក្បួនដោះស្រាយនៃការងារនេះត្រូវបានគេហៅថា PBFT (Practical Byzantine Fault Tolerant) consensus ។ ខុសគ្នាពី BFT បុរាណ ការពិតដែលថាសារត្រូវបានផ្ញើ និងការបញ្ជាក់ត្រូវបានរំពឹងថាមិនមែនមកពីអ្នកចូលរួមទាំងអស់នោះទេ ប៉ុន្តែបានមកពីសំណុំជាក់លាក់មួយប៉ុណ្ណោះ។
បន្ទាប់ពីអតិថិជនបានទទួលចំនួននៃការឆ្លើយតបដែលត្រូវនឹងគោលការណ៍យល់ព្រម គាត់ផ្ញើប្រតិបត្តិការទៅកាន់សេវាកម្មបញ្ជាទិញ។
សេវាកម្មបញ្ជាទិញបង្កើតប្លុក ហើយផ្ញើវាទៅមិត្តរួមការងារទាំងអស់។ សេវាកម្មបញ្ជាទិញធានានូវការកត់ត្រាជាលំដាប់នៃប្លុក ដែលលុបបំបាត់អ្វីដែលគេហៅថា សៀវភៅកត់ត្រាសម (សូមមើលផ្នែក "Forks");
មិត្តភ័ក្តិទទួលបានប្លុក ពិនិត្យមើលគោលការណ៍យល់ព្រមម្តងទៀត សរសេរប្លុកទៅ blockchain និងផ្លាស់ប្តូរស្ថានភាពនៅក្នុង "រដ្ឋពិភពលោក" DB ។

ទាំងនោះ។ នេះបណ្តាលឱ្យមានការបែងចែកតួនាទីរវាងថ្នាំង។ នេះធានាថា blockchain អាចធ្វើមាត្រដ្ឋានបាន និងមានសុវត្ថិភាព៖

កិច្ចសន្យាឆ្លាតវៃ (ខ្សែសង្វាក់) អនុវត្តការយល់ព្រមពីមិត្តភក្ដិ។ នេះធានានូវភាពសម្ងាត់នៃកិច្ចសន្យាឆ្លាតវៃ ពីព្រោះ វាមិនត្រូវបានរក្សាទុកដោយអ្នកចូលរួមទាំងអស់ទេ ប៉ុន្តែគ្រាន់តែដោយការគាំទ្រពីមិត្តភក្តិប៉ុណ្ណោះ។
ការបញ្ជាទិញគួរតែដំណើរការលឿន។ នេះត្រូវបានធានាដោយការពិតដែលថាការបញ្ជាទិញគ្រាន់តែបង្កើតជាប្លុកមួយហើយផ្ញើវាទៅសំណុំថេរនៃអ្នកដឹកនាំ។
មិត្តរួមការងាររក្សាទុកតែ blockchain ប៉ុណ្ណោះ - វាអាចមានច្រើនហើយពួកគេមិនតម្រូវឱ្យមានថាមពលច្រើននិងប្រតិបត្តិការភ្លាមៗទេ។

ព័ត៌មានលម្អិតបន្ថែមអំពីដំណោះស្រាយស្ថាបត្យកម្មនៃ Hyperledger Fabric និងមូលហេតុដែលវាដំណើរការតាមវិធីនេះ ហើយមិនមែនអាចត្រូវបានរកឃើញនៅទីនេះ៖ ប្រភពដើមនៃស្ថាបត្យកម្ម ឬនៅទីនេះ៖ ក្រណាត់ Hyperledger៖ ប្រព័ន្ធប្រតិបត្តិការចែកចាយសម្រាប់ Blockchains ដែលត្រូវបានអនុញ្ញាត.

ដូច្នេះ Hyperledger Fabric គឺជាប្រព័ន្ធសកលពិតដែលអ្នកអាច៖

អនុវត្តតក្កវិជ្ជាអាជីវកម្មតាមអំពើចិត្តដោយប្រើយន្តការកិច្ចសន្យាឆ្លាត;
កត់ត្រា និងទទួលទិន្នន័យពីមូលដ្ឋានទិន្នន័យ blockchain ក្នុងទម្រង់ JSON;
ផ្តល់ និងផ្ទៀងផ្ទាត់ការចូលប្រើ API ដោយប្រើអាជ្ញាធរវិញ្ញាបនបត្រ។

ឥឡូវយើងយល់បន្តិចអំពីភាពជាក់លាក់នៃ Hyperledger Fabric ជាចុងក្រោយយើងធ្វើអ្វីដែលមានប្រយោជន៍!

ការដាក់ពង្រាយ blockchain

ការបង្កើតបញ្ហា

ភារកិច្ចគឺដើម្បីអនុវត្តបណ្តាញ Citcoin ជាមួយនឹងមុខងារដូចខាងក្រោមៈ បង្កើតគណនីមួយ ទទួលបានសមតុល្យ បញ្ចូលទឹកប្រាក់ក្នុងគណនីរបស់អ្នក ផ្ទេរកាក់ពីគណនីមួយទៅគណនីមួយទៀត។ ចូរគូរគំរូវត្ថុមួយ ដែលយើងនឹងអនុវត្តបន្ថែមទៀតនៅក្នុងកិច្ចសន្យាឆ្លាតវៃ។ ដូច្នេះ យើងនឹងមានគណនីដែលត្រូវបានកំណត់ដោយឈ្មោះ និងមានសមតុល្យ និងបញ្ជីគណនី។ គណនី និងបញ្ជីគណនីគឺទាក់ទងនឹងទ្រព្យសកម្មក្រណាត់ Hyperledger ។ ដូច្នោះហើយពួកគេមានប្រវត្តិនិងស្ថានភាពបច្ចុប្បន្ន។ ខ្ញុំនឹងព្យាយាមគូរវាឱ្យច្បាស់៖

តួលេខកំពូលគឺជាស្ថានភាពបច្ចុប្បន្ន ដែលត្រូវបានរក្សាទុកក្នុងមូលដ្ឋានទិន្នន័យ "រដ្ឋពិភពលោក" ។ ខាងក្រោមនេះគឺជាតួលេខបង្ហាញពីប្រវត្តិដែលត្រូវបានរក្សាទុកនៅក្នុង blockchain ។ ស្ថានភាពបច្ចុប្បន្ននៃទ្រព្យសកម្មត្រូវបានផ្លាស់ប្តូរដោយប្រតិបត្តិការ។ ទ្រព្យសកម្មផ្លាស់ប្តូរទាំងស្រុង ដូច្នេះជាលទ្ធផលនៃប្រតិបត្តិការ វត្ថុថ្មីមួយត្រូវបានបង្កើត ហើយតម្លៃបច្ចុប្បន្ននៃទ្រព្យសកម្មនឹងចូលទៅក្នុងប្រវត្តិ។

IBM Cloud

យើងបង្កើតគណនីមួយនៅក្នុង ពពក IBM. ដើម្បីប្រើវេទិកា blockchain វាត្រូវតែត្រូវបានធ្វើឱ្យប្រសើរឡើងទៅ Pay-As-You-Go ។ ដំណើរការនេះប្រហែលជាមិនលឿនទេ ព្រោះ... IBM ស្នើសុំព័ត៌មានបន្ថែម និងផ្ទៀងផ្ទាត់វាដោយដៃ។ ជាវិជ្ជមាន ខ្ញុំអាចនិយាយបានថា IBM មានសម្ភារៈបណ្តុះបណ្តាលល្អៗ ដែលអនុញ្ញាតឱ្យអ្នកដាក់ពង្រាយ Hyperledger Fabric នៅក្នុងពពករបស់ពួកគេ។ ខ្ញុំចូលចិត្តស៊េរីអត្ថបទ និងឧទាហរណ៍ខាងក្រោម៖

ខាងក្រោមនេះគឺជារូបថតអេក្រង់នៃវេទិកា IBM Blockchain ។ នេះមិនមែនជាការណែនាំអំពីរបៀបបង្កើត blockchain ទេ ប៉ុន្តែគ្រាន់តែជាការបង្ហាញអំពីវិសាលភាពនៃកិច្ចការប៉ុណ្ណោះ។ ដូច្នេះ សម្រាប់គោលបំណងរបស់យើង យើងបង្កើតអង្គការតែមួយ៖

យើងបង្កើតថ្នាំងនៅក្នុងវា៖ Orderer CA, Org1 CA, Orderer Peer៖

យើងបង្កើតអ្នកប្រើប្រាស់៖

បង្កើត Channel ហើយហៅវាថា citcoin៖

ឆានែលសំខាន់គឺជា blockchain ដូច្នេះវាចាប់ផ្តើមដោយប្លុកសូន្យ (ប្លុកលោកុប្បត្តិ):

ការសរសេរកិច្ចសន្យាឆ្លាតវៃ

/*
 * 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 ត្រូវបានហៅ ដែលការប្រៀបធៀបត្រូវបានធ្វើឡើងសម្រាប់ចំនួនអតិបរមានៃគណនីនៅក្នុង blockchain (maxAccounts = 5)។ ហើយនៅទីនេះមានការកកស្ទះមួយ (តើអ្នកបានកត់សម្គាល់ទេ?) ដែលនាំទៅរកការកើនឡើងនៃចំនួនគណនី។ កំហុសបែបនេះគួរតែជៀសវាង)

បន្ទាប់មក យើងផ្ទុកកិច្ចសន្យាឆ្លាតវៃទៅក្នុង Channel ហើយធ្វើវាភ្លាមៗ៖

តោះមើលប្រតិបត្តិការដំឡើង Smart Contract៖

តោះទស្សនាព័ត៌មានលម្អិតអំពី Channel របស់យើងទាំងអស់គ្នា៖

ជាលទ្ធផលយើងទទួលបានដ្យាក្រាមខាងក្រោមនៃបណ្តាញ blockchain នៅក្នុងពពក IBM ។ ដ្យាក្រាមក៏បង្ហាញកម្មវិធីសាកល្បងដែលកំពុងដំណើរការនៅក្នុង Amazon cloud នៅលើម៉ាស៊ីនមេនិម្មិត (បន្ថែមអំពីវានៅក្នុងផ្នែកបន្ទាប់)៖

ការបង្កើត GUI សម្រាប់ការហៅទូរស័ព្ទ API Hyperledger Fabric

Hyperledger Fabric មាន API ដែលអាចប្រើដើម្បី៖

បង្កើតឆានែល;
ការតភ្ជាប់គ្នាទៅនឹងឆានែល;
ការដំឡើងនិងការបង្កើតកិច្ចសន្យាឆ្លាតវៃនៅក្នុងឆានែល;
ប្រតិបត្តិការហៅទូរស័ព្ទ;
ស្នើសុំព័ត៌មានអំពី blockchain ។

ការអភិវឌ្ឍន៍កម្មវិធី

នៅក្នុងកម្មវិធីសាកល្បងរបស់យើង យើងនឹងប្រើ API ដើម្បីហៅប្រតិបត្តិការ និងព័ត៌មានស្នើសុំតែប៉ុណ្ណោះ ពីព្រោះ យើងបានបញ្ចប់ជំហានដែលនៅសល់រួចហើយដោយប្រើវេទិកា blockchain របស់ IBM ។ យើងសរសេរ GUI ដោយប្រើជង់បច្ចេកវិទ្យាស្តង់ដារ៖ Express.js + Vue.js + Node.js ។ អ្នកអាចសរសេរអត្ថបទដាច់ដោយឡែកមួយអំពីរបៀបចាប់ផ្តើមបង្កើតកម្មវិធីបណ្តាញទំនើប។ នៅទីនេះ ខ្ញុំនឹងទុកតំណភ្ជាប់ទៅកាន់វគ្គនៃការបង្រៀនដែលខ្ញុំចូលចិត្តបំផុត៖ កម្មវិធីបណ្តាញជង់ពេញដោយប្រើ Vue.js & Express.js. លទ្ធផលគឺជាកម្មវិធីម៉ាស៊ីនភ្ញៀវ-ម៉ាស៊ីនមេដែលមានចំណុចប្រទាក់ក្រាហ្វិកដែលធ្លាប់ស្គាល់នៅក្នុងរចនាប័ទ្មរចនាសម្ភារៈរបស់ 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 - បិទការតភ្ជាប់ទៅ blockchain ។

ការពិពណ៌នាអំពី API ជាមួយនឹងឧទាហរណ៍រួមបញ្ចូលក្នុង គេហទំព័រ Postman - កម្មវិធីល្បីសម្រាប់សាកល្បង HTTP API ។

កម្មវិធីសាកល្បងនៅក្នុង Amazon cloud

ខ្ញុំបានអាប់ឡូតកម្មវិធីទៅ Amazon ដោយសារតែ... IBM នៅតែមិនអាចដំឡើងកំណែគណនីរបស់ខ្ញុំ និងអនុញ្ញាតឱ្យខ្ញុំបង្កើតម៉ាស៊ីនមេនិម្មិត។ វិធីបន្ថែម cherry ទៅក្នុងដែន៖ www.citcoin.info. ខ្ញុំនឹងបើកម៉ាស៊ីនបម្រើមួយរយៈសិន បន្ទាប់មកបិទវាចោលព្រោះ... សេនសម្រាប់ជួលកំពុងស្រក់ ហើយកាក់ citcoin មិនទាន់ចុះបញ្ជីនៅលើផ្សារហ៊ុនទេ) ខ្ញុំកំពុងរួមបញ្ចូលរូបថតអេក្រង់នៃការបង្ហាញនៅក្នុងអត្ថបទដើម្បីឱ្យតក្កវិជ្ជានៃការងារមានភាពច្បាស់លាស់។ កម្មវិធីសាកល្បងអាច៖

ចាប់ផ្តើម blockchain;
បង្កើតគណនីមួយ (ប៉ុន្តែឥឡូវនេះអ្នកមិនអាចបង្កើតគណនីថ្មីបានទេព្រោះចំនួនអតិបរមានៃគណនីដែលបានបញ្ជាក់នៅក្នុងកិច្ចសន្យាឆ្លាតវៃត្រូវបានឈានដល់នៅក្នុង blockchain);
ទទួលបានបញ្ជីគណនី;
ផ្ទេរកាក់ citcoin រវាង Alice, Bob និង Alex;
ទទួលព្រឹត្តិការណ៍ (ប៉ុន្តែឥឡូវនេះមិនមានវិធីដើម្បីបង្ហាញព្រឹត្តិការណ៍ដូច្នេះសម្រាប់ភាពសាមញ្ញចំណុចប្រទាក់និយាយថាព្រឹត្តិការណ៍មិនត្រូវបានគាំទ្រ);
សកម្មភាពកត់ត្រា។

ដំបូងយើងចាប់ផ្តើម blockchain៖

បន្ទាប់យើងបង្កើតគណនីរបស់យើង កុំខ្ជះខ្ជាយពេលវេលាជាមួយសមតុល្យ៖

យើងទទួលបានបញ្ជីគណនីដែលមានទាំងអស់៖

យើងជ្រើសរើសអ្នកផ្ញើ និងអ្នកទទួល ហើយទទួលបានសមតុល្យរបស់ពួកគេ។ ប្រសិនបើអ្នកផ្ញើ និងអ្នកទទួលដូចគ្នា នោះគណនីរបស់គាត់នឹងត្រូវបានបំពេញបន្ថែម៖

នៅក្នុងកំណត់ហេតុ យើងត្រួតពិនិត្យការប្រតិបត្តិប្រតិបត្តិការ៖

តាមពិត នោះជាអ្វីទាំងអស់ជាមួយនឹងកម្មវិធីសាកល្បង។ ខាងក្រោមអ្នកអាចឃើញប្រតិបត្តិការរបស់យើងនៅក្នុង blockchain៖

និងបញ្ជីទូទៅនៃប្រតិបត្តិការ៖

ជាមួយនេះ យើងបានបញ្ចប់ដោយជោគជ័យនូវការអនុវត្ត PoC ដើម្បីបង្កើតបណ្តាញ Citcoin ។ តើត្រូវធ្វើអ្វីទៀតដើម្បីឱ្យ Citcoin ក្លាយជាបណ្តាញពេញលេញសម្រាប់ការផ្ទេរកាក់? តិចតួចណាស់:

នៅដំណាក់កាលបង្កើតគណនី សូមអនុវត្តការបង្កើតសោឯកជន/សាធារណៈ។ សោឯកជនត្រូវតែរក្សាទុកជាមួយអ្នកប្រើប្រាស់គណនី សោសាធារណៈត្រូវតែរក្សាទុកនៅក្នុង blockchain ។
ធ្វើការផ្ទេរកាក់ដែលសោសាធារណៈ ជាជាងឈ្មោះត្រូវបានប្រើដើម្បីកំណត់អត្តសញ្ញាណអ្នកប្រើប្រាស់។
អ៊ិនគ្រីបប្រតិបត្តិការពីអ្នកប្រើប្រាស់ទៅកាន់ម៉ាស៊ីនមេដោយប្រើសោឯកជនរបស់គាត់។

សេចក្តីសន្និដ្ឋាន

យើងបានអនុវត្តបណ្តាញ Citcoin ជាមួយនឹងមុខងារដូចខាងក្រោម៖ បន្ថែមគណនី ទទួលបានសមតុល្យ បញ្ចូលទឹកប្រាក់ក្នុងគណនីរបស់អ្នក ផ្ទេរកាក់ពីគណនីមួយទៅគណនីមួយទៀត។ ដូច្នេះ តើយើងត្រូវចំណាយប្រាក់ប៉ុន្មានក្នុងការបង្កើត PoC?

អ្នកត្រូវសិក្សា blockchain ជាទូទៅ និង Hyperledger Fabric ជាពិសេស។
រៀនប្រើ IBM ឬ Amazon clouds;
រៀនភាសាសរសេរកម្មវិធី JS និងក្របខ័ណ្ឌគេហទំព័រមួយចំនួន។
ប្រសិនបើទិន្នន័យមួយចំនួនត្រូវរក្សាទុកមិននៅក្នុង blockchain ទេប៉ុន្តែនៅក្នុងមូលដ្ឋានទិន្នន័យដាច់ដោយឡែក បន្ទាប់មករៀនរួមបញ្ចូលឧទាហរណ៍ជាមួយ PostgreSQL ។
ហើយចុងក្រោយ ប៉ុន្តែមិនសំខាន់តិចជាងនេះទេ បើគ្មានចំណេះដឹង Linux គ្មានកន្លែងណានៅក្នុងពិភពសម័យទំនើបទេ!)

ជាការពិតណាស់ វាមិនមែនជាវិទ្យាសាស្ត្ររ៉ុក្កែតទេ ប៉ុន្តែអ្នកត្រូវតែប្រឹងប្រែង!

ប្រភពនៅលើ GitHub

ប្រភពដែលបានដាក់នៅលើ GitHub. ការពិពណ៌នាសង្ខេបនៃឃ្លាំង៖
កាតាឡុក «ម៉ាស៊ីនបម្រើ» — ម៉ាស៊ីនមេ Node.js
កាតាឡុក «អតិថិជន» - ម៉ាស៊ីនភ្ញៀវ Node.js
កាតាឡុក «blockchain"(តម្លៃប៉ារ៉ាម៉ែត្រ និងកូនសោជាការពិតណាស់ គឺមិនដំណើរការទេ ហើយត្រូវបានផ្តល់ជាឧទាហរណ៍តែប៉ុណ្ណោះ)៖

កិច្ចសន្យា — កូដប្រភពកិច្ចសន្យាឆ្លាត
កាបូប - កូនសោអ្នកប្រើប្រាស់សម្រាប់ប្រើ Hyperledger Fabric API ។
*.cds - កំណែចងក្រងនៃកិច្ចសន្យាឆ្លាតវៃ
ឯកសារ *.json - ឧទាហរណ៍នៃឯកសារកំណត់រចនាសម្ព័ន្ធសម្រាប់ការប្រើប្រាស់ Hyperledger Fabric API

វាគ្រាន់តែជាការចាប់ផ្តើមប៉ុណ្ណោះ!

ប្រភព: www.habr.com