બ્લોકચેન: આપણે શું પીઓસી બનાવવું જોઈએ?

તમારી આંખો ભયભીત છે અને તમારા હાથ ખંજવાળ છે!

અગાઉના લેખોમાં, અમે તે તકનીકો સાથે વ્યવહાર કર્યો કે જેના પર બ્લોકચેન બનાવવામાં આવે છે (આપણે શું બ્લોકચેન બનાવવું જોઈએ?) અને કિસ્સાઓ કે જે તેમની મદદથી અમલમાં મૂકી શકાય છે (આપણે કેસ કેમ બાંધવો જોઈએ?). તમારા હાથથી કામ કરવાનો સમય છે! પાઇલોટ્સ અને PoC (પ્રૂફ ઓફ કોન્સેપ્ટ) ને અમલમાં મૂકવા માટે, હું વાદળોનો ઉપયોગ કરવાનું પસંદ કરું છું, કારણ કે... તેઓ વિશ્વમાં ગમે ત્યાંથી ઍક્સેસ કરી શકાય છે અને, ઘણીવાર, પર્યાવરણના કંટાળાજનક ઇન્સ્ટોલેશન પર સમય બગાડવાની જરૂર નથી, કારણ કે ત્યાં પ્રીસેટ રૂપરેખાંકનો છે. તેથી, ચાલો કંઈક સરળ બનાવીએ, ઉદાહરણ તરીકે, સહભાગીઓ વચ્ચે સિક્કા ટ્રાન્સફર કરવા માટેનું નેટવર્ક અને ચાલો તેને નમ્રતાથી બિટકોઈન કહીએ. આ માટે અમે IBM ક્લાઉડ અને યુનિવર્સલ બ્લોકચેન હાઇપરલેજર ફેબ્રિકનો ઉપયોગ કરીશું. પ્રથમ, ચાલો જોઈએ કે હાયપરલેજર ફેબ્રિકને સાર્વત્રિક બ્લોકચેન શા માટે કહેવામાં આવે છે?

હાઇપરલેજર ફેબ્રિક - એક સાર્વત્રિક બ્લોકચેન

સામાન્ય રીતે કહીએ તો, સાર્વત્રિક માહિતી સિસ્ટમ છે:

• સર્વરનો સમૂહ અને સોફ્ટવેર કોર જે વ્યવસાય તર્ક કરે છે;
• સિસ્ટમ સાથે ક્રિયાપ્રતિક્રિયા માટે ઇન્ટરફેસ;
• ઉપકરણો/લોકોની નોંધણી, પ્રમાણીકરણ અને અધિકૃતતા માટેના સાધનો;
• ડેટાબેઝ ઓપરેશનલ અને આર્કાઇવલ ડેટા સ્ટોર કરે છે:

હાઇપરલેજર ફેબ્રિક શું છે તેનું સત્તાવાર સંસ્કરણ અહીં વાંચી શકાય છે સાઇટ, અને ટૂંકમાં, Hyperledger Fabric એ એક ઓપનસોર્સ પ્લેટફોર્મ છે જે તમને ખાનગી બ્લોકચેન બનાવવા અને JS અને Go પ્રોગ્રામિંગ ભાષાઓમાં લખેલા મનસ્વી સ્માર્ટ કોન્ટ્રાક્ટ્સ ચલાવવા માટે પરવાનગી આપે છે. ચાલો હાયપરલેજર ફેબ્રિકના આર્કિટેક્ચર પર વિગતવાર જોઈએ અને ખાતરી કરો કે આ એક સાર્વત્રિક સિસ્ટમ છે જે ફક્ત ડેટા સ્ટોર કરવા અને રેકોર્ડ કરવા માટે વિશિષ્ટતા ધરાવે છે. વિશિષ્ટતા એ છે કે ડેટા, તમામ બ્લોકચેન્સની જેમ, બ્લોકચેન પર ફક્ત ત્યારે જ સંગ્રહિત થાય છે જો સહભાગીઓ સર્વસંમતિ સુધી પહોંચે અને ડેટા રેકોર્ડ કર્યા પછી તેને શાંતિથી સુધારી અથવા કાઢી ન શકાય.

હાઇપરલેજર ફેબ્રિક આર્કિટેક્ચર

આકૃતિ હાઇપરલેજર ફેબ્રિક આર્કિટેક્ચર બતાવે છે:

સંસ્થાઓ — સંસ્થાઓમાં સાથીદારો હોય છે, એટલે કે સંસ્થાઓના સમર્થનને કારણે બ્લોકચેન અસ્તિત્વમાં છે. વિવિધ સંસ્થાઓ એક જ ચેનલનો ભાગ બની શકે છે.

ચેનલ - એક તાર્કિક માળખું જે સાથીદારોને જૂથોમાં જોડે છે, એટલે કે. બ્લોકચેન ઉલ્લેખિત છે. હાઇપરલેજર ફેબ્રિક એકસાથે વિવિધ વ્યાપાર તર્ક સાથે બહુવિધ બ્લોકચેન પર પ્રક્રિયા કરી શકે છે.

સભ્યપદ સેવા પ્રદાતા (MSP) ઓળખ જારી કરવા અને ભૂમિકાઓ સોંપવા માટે CA (પ્રમાણપત્ર અધિકારી) છે. નોડ બનાવવા માટે, તમારે MSP સાથે સંપર્ક કરવાની જરૂર છે.

પીઅર નોડ્સ - વ્યવહારો ચકાસો, બ્લોકચેન સ્ટોર કરો, સ્માર્ટ કોન્ટ્રાક્ટ્સ ચલાવો અને એપ્લિકેશન્સ સાથે ક્રિયાપ્રતિક્રિયા કરો. સાથીઓની ઓળખ (ડિજિટલ પ્રમાણપત્ર) હોય છે, જે MSP દ્વારા જારી કરવામાં આવે છે. બિટકોઇન અથવા ઇથેરિયમ નેટવર્કથી વિપરીત, જ્યાં તમામ ગાંઠોને સમાન અધિકારો હોય છે, હાઇપરલેજરમાં ફેબ્રિક નોડ્સ વિવિધ ભૂમિકા ભજવે છે:

• પીઅર કદાચ સમર્થન આપનાર પીઅર (EP) અને સ્માર્ટ કોન્ટ્રાક્ટ એક્ઝિક્યુટ કરો.
• પ્રતિબદ્ધ પીઅર (CP) - બ્લોકચેનમાં ફક્ત ડેટા સાચવો અને "વર્લ્ડ સ્ટેટ" અપડેટ કરો.
• એન્કર પીર (એપી) - જો ઘણી સંસ્થાઓ બ્લોકચેનમાં ભાગ લે છે, તો તેમની વચ્ચેના સંચાર માટે એન્કર પીઅરનો ઉપયોગ કરવામાં આવે છે. દરેક સંસ્થામાં એક અથવા વધુ એન્કર પીઅર હોવા આવશ્યક છે. AP નો ઉપયોગ કરીને, સંસ્થામાં કોઈપણ પીઅર અન્ય સંસ્થાઓમાં તમામ સાથીદારો વિશે માહિતી મેળવી શકે છે. APs વચ્ચે માહિતી સિંક્રનાઇઝ કરવા માટે વપરાય છે ગપસપ પ્રોટોકોલ.
• નેતા પીઅર - જો કોઈ સંસ્થામાં ઘણા સાથીદારો હોય, તો ફક્ત પીઅરના નેતાને ઓર્ડરિંગ સેવામાંથી બ્લોક્સ પ્રાપ્ત થશે અને બાકીના સાથીદારોને આપશે. લીડર ક્યાં તો સ્થિર રીતે નિર્દિષ્ટ કરી શકાય છે અથવા સંસ્થાના સાથીદારો દ્વારા ગતિશીલ રીતે પસંદ કરી શકાય છે. ગપસપ પ્રોટોકોલનો ઉપયોગ નેતાઓ વિશેની માહિતીને સુમેળ કરવા માટે પણ થાય છે.

અસ્કયામતો - એકમો કે જેનું મૂલ્ય છે અને બ્લોકચેન પર સંગ્રહિત છે. વધુ વિશિષ્ટ રીતે, આ JSON ફોર્મેટમાં કી-વેલ્યુ ડેટા છે. તે આ ડેટા છે જે બ્લોકચેનમાં રેકોર્ડ કરવામાં આવે છે. તેમની પાસે એક ઇતિહાસ છે, જે બ્લોકચેનમાં સંગ્રહિત છે, અને વર્તમાન સ્થિતિ છે, જે "વર્લ્ડ સ્ટેટ" ડેટાબેઝમાં સંગ્રહિત છે. વ્યવસાયિક કાર્યોના આધારે ડેટા સ્ટ્રક્ચર્સ મનસ્વી રીતે ભરવામાં આવે છે. ત્યાં કોઈ આવશ્યક ફીલ્ડ નથી, એકમાત્ર ભલામણ એ છે કે સંપત્તિનો માલિક હોવો જોઈએ અને તે મૂલ્યવાન હોવો જોઈએ.

ખાતાવહી — બ્લોકચેન અને વર્ડ સ્ટેટ ડેટાબેઝનો સમાવેશ કરે છે, જે સંપત્તિની વર્તમાન સ્થિતિનો સંગ્રહ કરે છે. વિશ્વ રાજ્ય લેવલડીબી અથવા કોચડીબીનો ઉપયોગ કરે છે.

સ્માર્ટ કરાર - સ્માર્ટ કોન્ટ્રાક્ટનો ઉપયોગ કરીને, સિસ્ટમના વ્યવસાયિક તર્કને અમલમાં મૂકવામાં આવે છે. હાયપરલેજર ફેબ્રિકમાં, સ્માર્ટ કોન્ટ્રાક્ટને ચેઈનકોડ કહેવામાં આવે છે. ચેઇનકોડનો ઉપયોગ કરીને, અસ્કયામતો અને તેમના પરના વ્યવહારો ઉલ્લેખિત છે. ટેકનિકલ પરિભાષામાં, સ્માર્ટ કોન્ટ્રાક્ટ એ જેએસ અથવા ગો પ્રોગ્રામિંગ ભાષાઓમાં અમલમાં મૂકાયેલા સોફ્ટવેર મોડ્યુલ છે.

સમર્થન નીતિ — દરેક ચેઈનકોડ માટે, તમે એક નીતિ સેટ કરી શકો છો કે ટ્રાન્ઝેક્શન માટે કેટલા કન્ફર્મેશનની અપેક્ષા રાખવી જોઈએ અને કોની પાસેથી. જો નીતિ સેટ ન હોય, તો ડિફોલ્ટ છે: "ચેનલમાં કોઈપણ સંસ્થાના કોઈપણ સભ્ય દ્વારા વ્યવહારની પુષ્ટિ થવી જોઈએ." નીતિઓના ઉદાહરણો:

• ટ્રાન્ઝેક્શન સંસ્થાના કોઈપણ એડમિનિસ્ટ્રેટર દ્વારા મંજૂર થયેલ હોવું આવશ્યક છે;
• સંસ્થાના કોઈપણ સભ્ય અથવા ક્લાયન્ટ દ્વારા પુષ્ટિ હોવી આવશ્યક છે;
• કોઈપણ પીઅર સંસ્થા દ્વારા પુષ્ટિ થયેલ હોવી આવશ્યક છે.

ઓર્ડરિંગ સેવા — ટ્રાન્ઝેક્શનને બ્લોકમાં પેક કરે છે અને ચૅનલમાં સાથીદારોને મોકલે છે. નેટવર્ક પરના તમામ સાથીદારોને સંદેશાઓના વિતરણની ખાતરી આપે છે. ઔદ્યોગિક સિસ્ટમો માટે વપરાય છે કાફકા સંદેશ બ્રોકર, વિકાસ અને પરીક્ષણ માટે સોલો.

કૉલફ્લો

• એપ્લિકેશન Go, Node.js અથવા Java SDK નો ઉપયોગ કરીને હાઇપરલેજર ફેબ્રિક સાથે વાતચીત કરે છે;
• ક્લાયન્ટ એક tx વ્યવહાર બનાવે છે અને તેને સમર્થન આપતા સાથીદારોને મોકલે છે;
• પીઅર ક્લાયન્ટના હસ્તાક્ષરની ચકાસણી કરે છે, વ્યવહાર પૂર્ણ કરે છે અને ક્લાયન્ટને સમર્થનની સહી પરત મોકલે છે. ચેઈનકોડ માત્ર સમર્થન આપનાર પીઅર પર જ એક્ઝિક્યુટ કરવામાં આવે છે અને તેના અમલનું પરિણામ તમામ સાથીદારોને મોકલવામાં આવે છે. કાર્યના આ અલ્ગોરિધમને PBFT (પ્રેક્ટિકલ બાયઝેન્ટાઇન ફોલ્ટ ટોલરન્ટ) સર્વસંમતિ કહેવામાં આવે છે. થી અલગ પડે છે ક્લાસિક BFT હકીકત એ છે કે સંદેશ મોકલવામાં આવ્યો છે અને પુષ્ટિની અપેક્ષા બધા સહભાગીઓ પાસેથી નથી, પરંતુ માત્ર ચોક્કસ સમૂહમાંથી છે;
• ક્લાયન્ટને સમર્થન નીતિને અનુરૂપ પ્રતિસાદોની સંખ્યા પ્રાપ્ત થયા પછી, તે ઓર્ડરિંગ સેવાને વ્યવહાર મોકલે છે;
• ઑર્ડરિંગ સેવા એક બ્લોક જનરેટ કરે છે અને તેને તમામ પ્રતિબદ્ધ સાથીઓને મોકલે છે. ઓર્ડરિંગ સેવા બ્લોક્સના ક્રમિક રેકોર્ડિંગને સુનિશ્ચિત કરે છે, જે કહેવાતા ખાતાવહી ફોર્કને દૂર કરે છે (વિભાગ "ફોર્કસ" જુઓ);
• સાથીદારોને બ્લોક મળે છે, સમર્થન નીતિ ફરીથી તપાસો, બ્લોકચેન પર બ્લોક લખો અને "વર્લ્ડ સ્ટેટ" DB માં રાજ્ય બદલો.

તે. આ ગાંઠો વચ્ચે ભૂમિકાઓના વિભાજનમાં પરિણમે છે. આ ખાતરી કરે છે કે બ્લોકચેન સ્કેલેબલ અને સુરક્ષિત છે:

• સ્માર્ટ કોન્ટ્રાક્ટ્સ (ચેઈનકોડ) પીઅર્સને સમર્થન આપે છે. આ સ્માર્ટ કોન્ટ્રાક્ટની ગોપનીયતાને સુનિશ્ચિત કરે છે, કારણ કે તે બધા સહભાગીઓ દ્વારા સંગ્રહિત નથી, પરંતુ માત્ર સાથીદારોને સમર્થન દ્વારા.
• ઓર્ડરિંગ ઝડપથી કામ કરવું જોઈએ. આ એ હકીકત દ્વારા સુનિશ્ચિત થાય છે કે ઓર્ડરિંગ માત્ર એક બ્લોક બનાવે છે અને તેને લીડર સાથીદારોના નિશ્ચિત સમૂહને મોકલે છે.
• પ્રતિબદ્ધ સાથીદારો ફક્ત બ્લોકચેન સંગ્રહિત કરે છે - તેમાંના ઘણા હોઈ શકે છે અને તેમને ઘણી શક્તિ અને તાત્કાલિક કામગીરીની જરૂર નથી.

હાયપરલેજર ફેબ્રિકના આર્કિટેક્ચરલ સોલ્યુશન્સ અને તે આ રીતે કેમ કામ કરે છે અને અન્યથા નહીં તેના પર વધુ વિગતો અહીં મળી શકે છે: આર્કિટેક્ચર મૂળ અથવા અહીં: હાયપરલેજર ફેબ્રિક: પરવાનગી પ્રાપ્ત બ્લોકચેન માટે વિતરિત ઓપરેટિંગ સિસ્ટમ.

તેથી, હાયપરલેજર ફેબ્રિક એ ખરેખર સાર્વત્રિક સિસ્ટમ છે જેની સાથે તમે આ કરી શકો છો:

• સ્માર્ટ કોન્ટ્રાક્ટ મિકેનિઝમનો ઉપયોગ કરીને મનસ્વી વ્યવસાય તર્કનો અમલ કરો;
• બ્લોકચેન ડેટાબેઝમાંથી JSON ફોર્મેટમાં ડેટા રેકોર્ડ કરો અને મેળવો;
• પ્રમાણપત્ર અધિકારીનો ઉપયોગ કરીને API ઍક્સેસ આપો અને ચકાસો.

હવે જ્યારે આપણે હાયપરલેજર ફેબ્રિકની વિશિષ્ટતાઓ વિશે થોડું સમજીએ છીએ, ચાલો આખરે કંઈક ઉપયોગી કરીએ!

બ્લોકચેન જમાવવું

સમસ્યાની રચના

કાર્ય નીચેના કાર્યો સાથે Citcoin નેટવર્કને અમલમાં મૂકવાનું છે: એક એકાઉન્ટ બનાવો, બેલેન્સ મેળવો, તમારું એકાઉન્ટ ટોપ અપ કરો, એક એકાઉન્ટમાંથી બીજા એકાઉન્ટમાં સિક્કા ટ્રાન્સફર કરો. ચાલો એક ઓબ્જેક્ટ મોડેલ દોરીએ, જેને આપણે સ્માર્ટ કોન્ટ્રાક્ટમાં આગળ અમલમાં મૂકીશું. તેથી, અમારી પાસે એવા એકાઉન્ટ હશે જે નામો દ્વારા ઓળખાય છે અને તેમાં બેલેન્સ અને એકાઉન્ટ્સની સૂચિ હશે. હાઈપરલેજર ફેબ્રિક અસ્કયામતોના સંદર્ભમાં એકાઉન્ટ્સ અને એકાઉન્ટ્સની સૂચિ છે. તદનુસાર, તેમની પાસે ઇતિહાસ અને વર્તમાન સ્થિતિ છે. હું આને સ્પષ્ટ રીતે દોરવાનો પ્રયત્ન કરીશ:

ટોચના આંકડા વર્તમાન સ્થિતિ છે, જે "વર્લ્ડ સ્ટેટ" ડેટાબેઝમાં સંગ્રહિત છે. તેમની નીચે બ્લોકચેનમાં સંગ્રહિત ઇતિહાસ દર્શાવતા આંકડાઓ છે. અસ્કયામતોની વર્તમાન સ્થિતિ વ્યવહારો દ્વારા બદલાય છે. સંપત્તિ ફક્ત સંપૂર્ણ રીતે બદલાય છે, તેથી વ્યવહારના પરિણામે, એક નવો ઑબ્જેક્ટ બનાવવામાં આવે છે, અને સંપત્તિનું વર્તમાન મૂલ્ય ઇતિહાસમાં જાય છે.

IBM ક્લાઉડ

અમે એક એકાઉન્ટ બનાવીએ છીએ IBM ક્લાઉડ. બ્લોકચેન પ્લેટફોર્મનો ઉપયોગ કરવા માટે, તેને પે-એઝ-યુ-ગો પર અપગ્રેડ કરવું આવશ્યક છે. આ પ્રક્રિયા ઝડપી ન હોઈ શકે, કારણ કે... IBM વધારાની માહિતીની વિનંતી કરે છે અને તેને મેન્યુઅલી ચકાસે છે. સકારાત્મક નોંધ પર, હું કહી શકું છું કે IBM પાસે સારી તાલીમ સામગ્રી છે જે તમને તેમના ક્લાઉડમાં હાઇપરલેજર ફેબ્રિકનો ઉપયોગ કરવાની મંજૂરી આપે છે. મને લેખો અને ઉદાહરણોની નીચેની શ્રેણી ગમ્યું:

• બ્લોકચેન પ્લેટફોર્મનો ઉપયોગ કરીને મૂળભૂત બ્લોકચેન નેટવર્ક બનાવો
• બ્લોકચેન સ્માર્ટ કોન્ટ્રાક્ટ બનાવો અને એક્ઝિક્યુટ કરો
• બ્લોકચેન પ્લેટફોર્મ પરથી ઇવેન્ટ્સ બહાર કાઢો

નીચેના IBM બ્લોકચેન પ્લેટફોર્મના સ્ક્રીનશોટ છે. આ બ્લોકચેન કેવી રીતે બનાવવું તે અંગેની સૂચના નથી, પરંતુ કાર્યના અવકાશનું નિદર્શન છે. તેથી, અમારા હેતુઓ માટે, અમે એક સંસ્થા બનાવીએ છીએ:

અમે તેમાં નોડ્સ બનાવીએ છીએ: Orderer CA, Org1 CA, Orderer Peer:

અમે વપરાશકર્તાઓ બનાવીએ છીએ:

એક ચેનલ બનાવો અને તેને સિટકોઈન કહો:

આવશ્યકપણે ચેનલ બ્લોકચેન છે, તેથી તે બ્લોક શૂન્ય (જીનેસિસ બ્લોક) થી શરૂ થાય છે:

સ્માર્ટ કોન્ટ્રાક્ટ લખવો

/*
 * 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 ડેટા સ્ટ્રક્ચર્સ છે. જેએસનો ઉપયોગ ડેટા મેનીપ્યુલેશન માટે થાય છે.
• તમે getState ફંક્શન કૉલનો ઉપયોગ કરીને સંપત્તિનું વર્તમાન મૂલ્ય મેળવી શકો છો અને પુટસ્ટેટનો ઉપયોગ કરીને તેને અપડેટ કરી શકો છો.
• એકાઉન્ટ બનાવતી વખતે, AddAccount ફંક્શન કહેવામાં આવે છે, જેમાં બ્લોકચેનમાં એકાઉન્ટ્સની મહત્તમ સંખ્યા (maxAccounts = 5) માટે સરખામણી કરવામાં આવે છે. અને અહીં એક જામ છે (શું તમે નોંધ્યું છે?), જે એકાઉન્ટ્સની સંખ્યામાં અનંત વધારો તરફ દોરી જાય છે. આવી ભૂલો ટાળવી જોઈએ)

આગળ, અમે ચૅનલમાં સ્માર્ટ કોન્ટ્રાક્ટ લોડ કરીએ છીએ અને તેને ઇન્સ્ટન્ટ કરીએ છીએ:

ચાલો સ્માર્ટ કોન્ટ્રાક્ટ ઇન્સ્ટોલ કરવા માટેના વ્યવહારને જોઈએ:

ચાલો અમારી ચેનલ વિશેની વિગતો જોઈએ:

પરિણામે, અમને IBM ક્લાઉડમાં બ્લોકચેન નેટવર્કનો નીચેનો આકૃતિ મળે છે. આકૃતિ વર્ચ્યુઅલ સર્વર પર એમેઝોન ક્લાઉડમાં ચાલતો ડેમો પ્રોગ્રામ પણ બતાવે છે (આગળના વિભાગમાં તેના વિશે વધુ):

Hyperledger Fabric API કૉલ્સ માટે GUI બનાવવું

હાઇપરલેજર ફેબ્રિક પાસે એક API છે જેનો ઉપયોગ આ માટે કરી શકાય છે:

• ચેનલ બનાવો;
• કનેક્શન્સ પીઅર ટુ ચેનલ;
• ચેનલમાં સ્માર્ટ કોન્ટ્રેક્ટની સ્થાપના અને ઇન્સ્ટન્ટેશન;
• કૉલિંગ વ્યવહારો;
• બ્લોકચેન પર માહિતીની વિનંતી કરો.

એપ્લિકેશન વિકાસ

અમારા ડેમો પ્રોગ્રામમાં અમે API નો ઉપયોગ ફક્ત વ્યવહારોને કૉલ કરવા અને માહિતીની વિનંતી કરવા માટે કરીશું, કારણ કે અમે પહેલાથી જ IBM બ્લોકચેન પ્લેટફોર્મનો ઉપયોગ કરીને બાકીના પગલાં પૂર્ણ કરી લીધા છે. અમે માનક ટેકનોલોજી સ્ટેકનો ઉપયોગ કરીને GUI લખીએ છીએ: Express.js + Vue.js + Node.js. તમે આધુનિક વેબ એપ્લિકેશન્સ કેવી રીતે બનાવવાનું શરૂ કરવું તે અંગે એક અલગ લેખ લખી શકો છો. અહીં હું પ્રવચનોની શ્રેણીની એક લિંક મૂકીશ જે મને સૌથી વધુ ગમ્યું: Vue.js અને Express.js નો ઉપયોગ કરીને સંપૂર્ણ સ્ટેક વેબ એપ્લિકેશન. પરિણામ એ Google ની મટિરિયલ ડિઝાઇન શૈલીમાં પરિચિત ગ્રાફિકલ ઇન્ટરફેસ સાથે ક્લાયંટ-સર્વર એપ્લિકેશન છે. ક્લાયંટ અને સર્વર વચ્ચેના 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. હું સર્વરને થોડા સમય માટે ચાલુ રાખીશ, પછી તેને બંધ કરીશ, કારણ કે... ભાડા માટેના સેન્ટ ટપકતા હોય છે, અને સિટકોઈનના સિક્કા હજુ સુધી સ્ટોક એક્સચેન્જમાં સૂચિબદ્ધ નથી) હું લેખમાં ડેમોના સ્ક્રીનશૉટ્સનો સમાવેશ કરું છું જેથી કાર્યનો તર્ક સ્પષ્ટ થાય. ડેમો એપ્લિકેશન આ કરી શકે છે:

• બ્લોકચેન શરૂ કરો;
• એકાઉન્ટ બનાવો (પરંતુ હવે તમે નવું એકાઉન્ટ બનાવી શકતા નથી, કારણ કે બ્લોકચેનમાં સ્માર્ટ કોન્ટ્રાક્ટમાં ઉલ્લેખિત એકાઉન્ટ્સની મહત્તમ સંખ્યા પહોંચી ગઈ છે);
• એકાઉન્ટ્સની સૂચિ મેળવો;
• એલિસ, બોબ અને એલેક્સ વચ્ચે સિટકોઈન સિક્કા ટ્રાન્સફર કરો;
• ઇવેન્ટ્સ પ્રાપ્ત કરો (પરંતુ હવે ઇવેન્ટ્સ બતાવવાની કોઈ રીત નથી, તેથી સરળતા માટે, ઇન્ટરફેસ કહે છે કે ઇવેન્ટ્સ સપોર્ટેડ નથી);
• લોગ ક્રિયાઓ.

પ્રથમ આપણે બ્લોકચેન શરૂ કરીએ છીએ:

આગળ, અમે અમારું એકાઉન્ટ બનાવીએ છીએ, બેલેન્સ સાથે સમય બગાડો નહીં:

અમને બધા ઉપલબ્ધ એકાઉન્ટ્સની સૂચિ મળે છે:

અમે પ્રેષક અને પ્રાપ્તકર્તાને પસંદ કરીએ છીએ અને તેમના બેલેન્સ મેળવીએ છીએ. જો પ્રેષક અને પ્રાપ્તકર્તા સમાન હોય, તો તેનું એકાઉન્ટ ફરી ભરાઈ જશે:

લોગમાં અમે વ્યવહારોના અમલનું નિરીક્ષણ કરીએ છીએ:

ખરેખર, ડેમો પ્રોગ્રામ સાથે તે બધુ જ છે. નીચે તમે બ્લોકચેનમાં અમારો વ્યવહાર જોઈ શકો છો:

અને વ્યવહારોની સામાન્ય સૂચિ:

આ સાથે, અમે Citcoin નેટવર્ક બનાવવા માટે PoC ના અમલીકરણને સફળતાપૂર્વક પૂર્ણ કર્યું છે. સિક્કા ટ્રાન્સફર કરવા માટે સિટકોઇનને સંપૂર્ણ નેટવર્ક બનવા માટે બીજું શું કરવાની જરૂર છે? બહુ ઓછી:

• એકાઉન્ટ બનાવવાના તબક્કે, ખાનગી/સાર્વજનિક કીના જનરેશનનો અમલ કરો. ખાનગી કી એકાઉન્ટ વપરાશકર્તા પાસે સંગ્રહિત હોવી આવશ્યક છે, જાહેર કી બ્લોકચેનમાં સંગ્રહિત હોવી આવશ્યક છે.
• એક સિક્કો ટ્રાન્સફર કરો જેમાં વપરાશકર્તાને ઓળખવા માટે નામને બદલે સાર્વજનિક કીનો ઉપયોગ કરવામાં આવે છે.
• તેની ખાનગી કી વડે વપરાશકર્તાથી સર્વર પર જતા વ્યવહારોને એન્ક્રિપ્ટ કરો.

નિષ્કર્ષ

અમે નીચેના કાર્યો સાથે Citcoin નેટવર્કનો અમલ કર્યો છે: એક એકાઉન્ટ ઉમેરો, બેલેન્સ મેળવો, તમારું એકાઉન્ટ ટોપ અપ કરો, એક એકાઉન્ટમાંથી બીજા એકાઉન્ટમાં સિક્કા ટ્રાન્સફર કરો. તો, PoC બનાવવા માટે અમને શું ખર્ચ થયો?

• તમારે સામાન્ય રીતે બ્લોકચેન અને ખાસ કરીને હાઇપરલેજર ફેબ્રિકનો અભ્યાસ કરવાની જરૂર છે;
• IBM અથવા Amazon વાદળોનો ઉપયોગ કરવાનું શીખો;
• JS પ્રોગ્રામિંગ ભાષા અને અમુક વેબ ફ્રેમવર્ક શીખો;
• જો અમુક ડેટાને બ્લોકચેનમાં નહીં, પરંતુ અલગ ડેટાબેઝમાં સંગ્રહિત કરવાની જરૂર હોય, તો પછી એકીકરણ કરવાનું શીખો, ઉદાહરણ તરીકે, PostgreSQL સાથે;
• અને છેલ્લું પરંતુ ઓછામાં ઓછું નહીં - તમે Linux ના જ્ઞાન વિના આધુનિક વિશ્વમાં જીવી શકતા નથી!)

અલબત્ત, તે રોકેટ વિજ્ઞાન નથી, પરંતુ તમારે સખત મહેનત કરવી પડશે!

GitHub પર સ્ત્રોતો

સૂત્રોએ જણાવ્યું હતું GitHub. રીપોઝીટરીનું સંક્ષિપ્ત વર્ણન:
કેટલોગ «સર્વર» — Node.js સર્વર
કેટલોગ «ક્લાઈન્ટ» — Node.js ક્લાયન્ટ
કેટલોગ «blockchain"(પેરામીટર મૂલ્યો અને કીઓ, અલબત્ત, બિન-કાર્યકારી છે અને માત્ર એક ઉદાહરણ તરીકે આપવામાં આવી છે):

• કરાર — સ્માર્ટ કોન્ટ્રેક્ટ સોર્સ કોડ
• વૉલેટ — હાયપરલેજર ફેબ્રિક API નો ઉપયોગ કરવા માટેની વપરાશકર્તા કી.
• *.cds - સ્માર્ટ કોન્ટ્રાક્ટની સંકલિત આવૃત્તિઓ
• *.json ફાઇલો - Hyperledger Fabric API નો ઉપયોગ કરવા માટે રૂપરેખાંકન ફાઇલોના ઉદાહરણો

તે માત્ર શરૂઆત છે!

સોર્સ: www.habr.com