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

ઑન્ટોલોજી બ્લોકચેન નેટવર્ક પર પાયથોનમાં સ્માર્ટ કોન્ટ્રાક્ટ બનાવવા પર શૈક્ષણિક લેખોની શ્રેણીમાં આ ત્રીજો ભાગ છે. અગાઉના લેખોમાં આપણે પરિચિત થયા

1. બ્લોકચેન અને બ્લોક API
2. સ્ટોરેજ API.

હવે જ્યારે તમને ઑન્ટોલોજી નેટવર્ક પર પાયથોનનો ઉપયોગ કરીને સ્માર્ટ કોન્ટ્રાક્ટ ડેવલપ કરતી વખતે યોગ્ય પર્સિસ્ટન્ટ સ્ટોરેજ API ને કેવી રીતે કૉલ કરવો તેનો ખ્યાલ છે, ચાલો તેનો ઉપયોગ કેવી રીતે કરવો તે શીખવા માટે આગળ વધીએ. રનટાઇમ API (કોન્ટ્રાક્ટ એક્ઝેક્યુશન API). રનટાઈમ API પાસે 8 સંબંધિત API છે જે કોન્ટ્રાક્ટ એક્ઝેક્યુશન માટે સામાન્ય ઈન્ટરફેસ પૂરા પાડે છે અને ડેવલપર્સને ડેટા પુનઃપ્રાપ્ત, રૂપાંતરિત અને માન્ય કરવામાં મદદ કરે છે.

નીચે 8 API ડેટાનું સંક્ષિપ્ત વર્ણન છે:

ચાલો 8 API ડેટાનો ઉપયોગ કેવી રીતે કરવો તેના પર નજીકથી નજર કરીએ. આ પહેલા, તમે ઓન્ટોલોજી સ્માર્ટ કોન્ટ્રાક્ટ ડેવલપમેન્ટ ટૂલમાં નવો કોન્ટ્રાક્ટ બનાવી શકો છો સ્માર્ટએક્સ અને નીચેની સૂચનાઓને અનુસરો.

રનટાઇમ API નો ઉપયોગ કેવી રીતે કરવો

આયાત કરવાની બે રીત છે રનટાઇમ API: ontology.interop.System.Runtime и ontology.interop.Ontology.Runtime. ઑન્ટોલોજી પાથમાં નવા ઉમેરાયેલા APIs છે. નીચેની લીટીઓ API ડેટાને આયાત કરે છે.

from ontology.interop.System.Runtime import GetTime, CheckWitness, Log, Notify, Serialize, Deserialize
from ontology.interop.Ontology.Runtime import Base58ToAddress, AddressToBase58, GetCurrentBlockHash

API ને સૂચિત કરો

Notify ફંક્શન સમગ્ર નેટવર્કમાં ઇવેન્ટનું પ્રસારણ કરે છે. નીચેના ઉદાહરણમાં, Notify ફંક્શન હેક્સ સ્ટ્રિંગ "હેલો વર્ડ" પરત કરશે અને તેને સમગ્ર નેટવર્કમાં બ્રોડકાસ્ટ કરશે.

from ontology.interop.System.Runtime import Notify
def demo():
    Notify("hello world")

તમે આને લોગમાં જોઈ શકો છો:

GetTime API

GetTime ફંક્શન વર્તમાન ટાઇમસ્ટેમ્પ પરત કરે છે, જે યુનિક્સ સમય પરત કરે છે કે જેના પર ફંક્શનને કૉલ કરવામાં આવ્યો હતો. માપનનું એકમ બીજું છે.

from ontology.interop.System.Runtime import GetTime
def demo():
    time=GetTime()
    return time # return a uint num

GetCurrentBlockHash API

GetCurrentBlockHash ફંક્શન વર્તમાન બ્લોકનું હેશ પરત કરે છે.

from ontology.interop.Ontology.Runtime import GetCurrentBlockHash
def demo():
    block_hash = GetCurrentBlockHash()
    return block_hash

સીરીયલાઇઝ અને ડીસીરીયલાઇઝ કરો

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

from ontology.interop.System.Runtime import GetTime, CheckWitness, Log, Notify, Serialize, Deserialize
from ontology.interop.System.Storage import Put, Get, GetContext

def Main(operation, args):
    if operation == 'serialize_to_bytearray':
        data = args[0]
        return serialize_to_bytearray(data)
    if operation == 'deserialize_from_bytearray':
        key = args[0]
        return deserialize_from_bytearray(key)
    return False


def serialize_to_bytearray(data):
    sc = GetContext()
    key = "1"
    byte_data = Serialize(data)
    Put(sc, key, byte_data)


def deserialize_from_bytearray(key):
    sc = GetContext()
    byte_data = Get(sc, key)
    data = Deserialize(byte_data)
    return data

Base58ToAddress અને AddressToBase58

સરનામાં અનુવાદ કાર્યોની આ જોડી. Base58ToAddress ફંક્શન એ base58 એન્કોડેડ એડ્રેસને બાયટિયર એડ્રેસમાં કન્વર્ટ કરે છે, અને AddressToBase58 બાયટિયર એડ્રેસને બેઝ58 એન્કોડેડ એડ્રેસમાં કન્વર્ટ કરે છે.

from ontology.interop.Ontology.Runtime import Base58ToAddress, AddressToBase58
def demo():
    base58_addr="AV1GLfVzw28vtK3d1kVGxv5xuWU59P6Sgn"
    addr=Base58ToAddress(base58_addr)
    Log(addr)
    base58_addr=AddressToBase58(addr)
    Log(base58_addr)

સાક્ષી તપાસો

CheckWitness(fromActt) ફંક્શનમાં બે કાર્યક્ષમતા છે:

• ચકાસો કે શું વર્તમાન ફંક્શનનો કોલર એક્ક્ટમાંથી છે. જો હા (એટલે ​​કે, હસ્તાક્ષર ચકાસણી પાસ થઈ ગઈ), તો ફંક્શન પરત કરે છે.
• વર્તમાન કાર્યને કૉલ કરતી ઑબ્જેક્ટ કરાર છે કે કેમ તે તપાસો. જો તે કરાર છે અને કાર્ય કરારમાંથી ચલાવવામાં આવે છે, તો ચકાસણી પસાર થાય છે. એટલે કે, જો fromActt એ GetCallingScriptHash() નું વળતર મૂલ્ય છે કે કેમ તે ચકાસો. GetCallingScriptHash() ફંક્શન વર્તમાન સ્માર્ટ કોન્ટ્રાક્ટની કોન્ટ્રાક્ટ હેશ વેલ્યુ લઈ શકે છે.

GetCallingScriptHash():

આગળ વાંચો ગુથબ

from ontology.interop.System.Runtime import CheckWitness
from ontology.interop.Ontology.Runtime import Base58ToAddress
def demo():
    addr=Base58ToAddress("AW8hN1KhHE3fLDoPAwrhtjD1P7vfad3v8z")
    res=CheckWitness(addr)
    return res

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

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

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

વિકાસકર્તાઓ માટે કાર્યો ખોલો. કાર્ય પૂર્ણ કરો અને ઈનામ મેળવો.

હવે અરજી કરો વિદ્યાર્થીઓ માટે ઓન્ટોલોજી ટેલેન્ટ પ્રોગ્રામ માટે

ઑન્ટોલોજી

ઓન્ટોલોજી વેબસાઇટ - GitHub - વિરામ - ટેલિગ્રામ રશિયન - Twitter - Reddit

સોર્સ: www.habr.com