ઓન્ટોલોજી નેટવર્ક પર પાયથોનમાં સ્માર્ટ કોન્ટ્રાક્ટ કેવી રીતે લખવો. ભાગ 1: બ્લોકચેન અને બ્લોક API

સ્માર્ટ કોન્ટ્રાક્ટ ડેવલપમેન્ટ ટૂલનો ઉપયોગ કરીને ઑન્ટોલોજી બ્લોકચેન નેટવર્ક પર પાયથોન સ્માર્ટ કોન્ટ્રાક્ટ બનાવવા પરના ટ્યુટોરિયલ્સની શ્રેણીનો આ પહેલો ભાગ છે. સ્માર્ટએક્સ.

આ લેખમાં, અમે ઑન્ટોલોજી સ્માર્ટ કોન્ટ્રાક્ટ API સાથે અમારી ઓળખાણ શરૂ કરીશું. ઓન્ટોલોજી સ્માર્ટ કોન્ટ્રાક્ટ API 7 મોડ્યુલમાં વિભાજિત થયેલ છે:

1. બ્લોકચેન અને બ્લોક API,
2. રનટાઇમ API,
3. સ્ટોરેજ API,
4. મૂળ API,
5. API અપગ્રેડ કરો,
6. એક્ઝેક્યુશન એન્જિન API અને
7. સ્ટેટિક અને ડાયનેમિક કૉલ API.

બ્લોકચેન અને બ્લોક API એ ઓન્ટોલોજી સ્માર્ટ કોન્ટ્રાક્ટ સિસ્ટમનો મુખ્ય ભાગ છે. બ્લોકચેન API મૂળભૂત બ્લોકચેન ક્વેરી ઓપરેશન્સને સપોર્ટ કરે છે, જેમ કે વર્તમાન બ્લોકની ઊંચાઈ મેળવવી, જ્યારે બ્લોક API મૂળભૂત બ્લોક ક્વેરી કામગીરીને સપોર્ટ કરે છે, જેમ કે આપેલ બ્લોક માટે વ્યવહારોની સંખ્યાની ક્વેરી કરવી.

ચાલો, શરુ કરીએ!

પ્રથમ, માં એક નવો કરાર બનાવો સ્માર્ટએક્સઅને પછી નીચેની સૂચનાઓને અનુસરો.

1. Blockchain API નો ઉપયોગ કેવી રીતે કરવો

સ્માર્ટ કોન્ટ્રાક્ટ ફંક્શન્સની લિંક્સ પાયથોન લિંક્સ જેવી જ છે. તમે જરૂર મુજબ અનુરૂપ કાર્યો દાખલ કરી શકો છો. ઉદાહરણ તરીકે, નીચેનું નિવેદન વર્તમાન બ્લોકની ઊંચાઈ મેળવવા માટે GetHeight ફંક્શન અને બ્લોકનું હેડર મેળવવા માટે GetHeader ફંક્શન રજૂ કરે છે.

from ontology.interop.System.Blockchain import GetHeight, GetHeader

GetHeight

નીચેના ઉદાહરણમાં બતાવ્યા પ્રમાણે, બ્લોકચેનમાં છેલ્લો બ્લોક સિક્વન્સ નંબર મેળવવા માટે GetHeight નો ઉપયોગ થાય છે. છેલ્લા ઉદાહરણમાં, અમે સુવિધા માટે મુખ્ય કાર્યને છોડી દઈશું, પરંતુ જો જરૂરી હોય તો તમે તેને ઉમેરી શકો છો.

from ontology.interop.System.Runtime import Notify
from ontology.interop.System.Blockchain import GetHeight
def Main(operation):
    if operation == 'demo':
        return demo()
    return False

def demo():
    height=GetHeight()
    Notify(height) # print height
    return height #return height after running the function

GetHeader

ગેટહેડરનો ઉપયોગ બ્લોક હેડર મેળવવા માટે થાય છે, પેરામીટર એ બ્લોકચેનમાં બ્લોકનો સીરીયલ નંબર છે. ઉદાહરણ:

from ontology.interop.System.Runtime import Notify
from ontology.interop.System.Blockchain import GetHeader
def demo():
    block_height=10
    header=GetHeader(block_height) 
    Notify(header)
return header

GetTransactionByHash

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

9f270aa3a4c13c46891ff0e1a2bdb3ea0525669d414994aadf2606734d0c89c1

પ્રથમ, ટ્રાન્ઝેક્શન હેશને રિવર્સ કરો:

c1890c4d730626dfaa9449419d662505eab3bda2e1f01f89463cc1a4a30a279

ડેવલપર્સ SmartX દ્વારા પ્રદાન કરવામાં આવેલ હેક્સ નંબર (લિટલ એન્ડિયન) નંબર કન્વર્ઝન ટૂલનો ઉપયોગ કરીને આ પગલું પૂર્ણ કરી શકે છે.

પછી પરિણામને બાયટેરે ફોર્મેટમાં કન્વર્ટ કરો:

{0xc1,0x89,0x0c,0x4d,0x73,0x06,0x26,0xdf,0xaa,0x94,0x49,0x41,0x9d,0x66,0x25,0x05,0xea,0xb3,0xbd,0xa2,0xe1,0xf0,0x1f,0x89,0x46,0x3c,0xc1,0xa4,0xa3,0x0a,0x27,0x9f}

આ SmartX દ્વારા પૂરા પાડવામાં આવેલ સ્ટ્રિંગ બાઈટ એરે કન્વર્ઝન ટૂલનો ઉપયોગ કરીને કરી શકાય છે. છેલ્લે, પરિણામી બાયટેરેને સમાન સ્ટ્રિંગમાં કન્વર્ટ કરો:

xc1x89x0cx4dx73x06x26xdfxaax94x49x41x9dx66x25x05xeaxb3xbdxa2xe1xf0x1fx89x46x3cxc1xa4xa3x0ax27x9f

નીચે એક GetTransactionByHash ફંક્શનનું ઉદાહરણ છે જે ટ્રાન્ઝેક્શનના હેશનો ઉપયોગ કરીને ટ્રાન્ઝેક્શન લે છે:

from ontology.interop.System.Blockchain import GetTransactionByHash
def demo():
    # tx_hash="9f270aa3a4c13c46891ff0e1a2bdb3ea0525669d414994aadf2606734d0c89c1"    
    tx_hash=bytearray(b"xc1x89x0cx4dx73x06x26xdfxaax94x49x41x9dx66x25x05xeaxb3xbdxa2xe1xf0x1fx89x46x3cxc1xa4xa3x0ax27x9f")
    tx=GetTransactionByHash(tx_hash)
    return tx

ટ્રાન્ઝેક્શન ઊંચાઈ મેળવો

GetTransactionHeight નો ઉપયોગ ટ્રાન્ઝેક્શન હેશ દ્વારા વ્યવહારની ઊંચાઈ મેળવવા માટે થાય છે. ચાલો ઉપરના ઉદાહરણમાંથી હેશ લઈએ:

from ontology.interop.System.Blockchain import  GetTransactionHeight
def demo():
    #   tx_hash="9f270aa3a4c13c46891ff0e1a2bdb3ea0525669d414994aadf2606734d0c89c1"    
    tx_hash=bytearray(b"xc1x89x0cx4dx73x06x26xdfxaax94x49x41x9dx66x25x05xeaxb3xbdxa2xe1xf0x1fx89x46x3cxc1xa4xa3x0ax27x9f")
    height=GetTransactionHeight(tx_hash)
    return height

ગેટ કોન્ટ્રાક્ટ

ડેવલપર્સ કોન્ટ્રાક્ટના હેશ દ્વારા કોન્ટ્રાક્ટ મેળવવા માટે GetContract ફંક્શનનો ઉપયોગ કરી શકે છે. કોન્ટ્રાક્ટ હેશ કન્વર્ઝન પ્રક્રિયા ઉપર દર્શાવેલ ટ્રાન્ઝેક્શન હેશ કન્વર્ઝન પ્રક્રિયા જેવી જ છે.

from ontology.interop.System.Blockchain import GetContract
def demo():
    # contract_hash="d81a75a5ff9b95effa91239ff0bb3232219698fa"    
    contract_hash=bytearray(b"xfax98x96x21x32x32xbbxf0x9fx23x91xfaxefx95x9bxffxa5x75x1axd8")
    contract=GetContract(contract_hash)
    return contract

ગેટબ્લોક

ગેટબ્લોકનો ઉપયોગ બ્લોક મેળવવા માટે થાય છે. ચોક્કસ બ્લોક મેળવવાની બે રીત છે.

1. બ્લોકની ઊંચાઈ દ્વારા બ્લોક મેળવો:

from ontology.interop.System.Blockchain import GetBlock
def demo():
    block=GetBlock(1408)
    return block

2. બ્લોક હેશ દ્વારા બ્લોક મેળવો:

from ontology.interop.System.Blockchain import GetBlock
def demo():    
    block_hash=bytearray(b'x16xe0xc5x40x82x79x77x30x44xeax66xc8xc4x5dx17xf7x17x73x92x33x6dx54xe3x48x46x0bxc3x2fxe2x15x03xe4')
    block=GetBlock(block_hash)

2. બ્લોક API નો ઉપયોગ કેવી રીતે કરવો

બ્લોક API માં ત્રણ ઉપલબ્ધ કાર્યો છે: વ્યવહારો મેળવો, ટ્રાન્ઝેક્શનકાઉન્ટ મેળવોઅને GetTransactionByIndex. અમે તેમને એક પછી એક તોડી નાખીશું.

ટ્રાન્ઝેક્શનકાઉન્ટ મેળવો

GetTransactionCount નો ઉપયોગ આપેલ બ્લોક માટેના વ્યવહારોની સંખ્યા મેળવવા માટે થાય છે.

from ontology.interop.System.Blockchain import GetBlock
from ontology.interop.System.Block import GetTransactionCount
def demo():
    block=GetBlock(1408)
    count=GetTransactionCount(block)
    return count

વ્યવહારો મેળવો

ડેવલપર્સ આપેલ બ્લોકમાં તમામ વ્યવહારો મેળવવા માટે GetTransactions ફંક્શનનો ઉપયોગ કરી શકે છે.

from ontology.interop.System.Blockchain import GetBlock
from ontology.interop.System.Block import GetTransactions 
def demo():
    block=GetBlock(1408)
    txs=GetTransactions(block)
    return txs

GetTransactionByIndex

GetTransactionByIndex નો ઉપયોગ આપેલ બ્લોકમાં ચોક્કસ વ્યવહાર મેળવવા માટે થાય છે.

from ontology.interop.System.Blockchain import GetBlock
from ontology.interop.System.Block import GetTransactionByIndex
def demo():
    block=GetBlock(1408)
    tx=GetTransactionByIndex(block,0) # index starts from 0.
    return tx

સંપૂર્ણ માર્ગદર્શિકા અમારા પર મળી શકે છે GitHub.

ઉચ્ચારણ

બ્લોકચેન અને બ્લોક API એ સ્માર્ટ કોન્ટ્રાક્ટનો અનિવાર્ય ભાગ છે કારણ કે તમે તેનો ઉપયોગ બ્લોકચેન ડેટાની વિનંતી કરવા અને સ્માર્ટ કોન્ટ્રાક્ટમાં ડેટાને બ્લોક કરવા માટે કરી શકો છો. નીચેના લેખોમાં, અમે બાકીના API નો ઉપયોગ કેવી રીતે કરવો અને તેઓ ઑન્ટોલોજી બ્લોકચેન સાથે કેવી રીતે ક્રિયાપ્રતિક્રિયા કરે છે તે વિશે ચર્ચા કરીશું.

લેખનો અનુવાદ હશરતે એન્ડ શેર્સના સંપાદકો દ્વારા ખાસ કરીને ઑન્ટોલોજી રશિયા માટે કરવામાં આવ્યો હતો. રડવું

શું તમે વિકાસકર્તા છો? પર અમારા ટેક સમુદાયમાં જોડાઓ વિરામ. પણ, પર એક નજર વિકાસકર્તા કેન્દ્ર અમારી વેબસાઇટ પર, જ્યાં તમે વિકાસકર્તા સાધનો, દસ્તાવેજીકરણ અને વધુ શોધી શકો છો.

ઑન્ટોલોજી

• ઓન્ટોલોજી વેબસાઇટ
• GitHub / વિરામ
• Telegram અંગ્રેજી / રશિયન
• Twitter / Reddit

સોર્સ: www.habr.com