ഒന്റോളജി നെറ്റ്‌വർക്കിൽ പൈത്തണിൽ എങ്ങനെ ഒരു സ്‌മാർട്ട് കരാർ എഴുതാം. ഭാഗം 3: റൺടൈം API

ഒന്റോളജി ബ്ലോക്ക്‌ചെയിൻ നെറ്റ്‌വർക്കിൽ പൈത്തണിൽ സ്‌മാർട്ട് കരാറുകൾ സൃഷ്‌ടിക്കുന്നതിനെക്കുറിച്ചുള്ള വിദ്യാഭ്യാസ ലേഖനങ്ങളുടെ ഒരു പരമ്പരയിലെ മൂന്നാം ഭാഗമാണിത്. മുൻ ലേഖനങ്ങളിൽ ഞങ്ങൾ പരിചയപ്പെട്ടു

1. ബ്ലോക്ക്ചെയിൻ & ബ്ലോക്ക് API
2. സ്റ്റോറേജ് API.

ഓന്റോളജി നെറ്റ്‌വർക്കിൽ പൈത്തൺ ഉപയോഗിച്ച് ഒരു സ്‌മാർട്ട് കോൺട്രാക്‌റ്റ് വികസിപ്പിക്കുമ്പോൾ ഉചിതമായ പെർസിസ്റ്റന്റ് സ്‌റ്റോറേജ് എപിഐയെ എങ്ങനെ വിളിക്കാം എന്നതിനെക്കുറിച്ച് ഇപ്പോൾ നിങ്ങൾക്ക് ഒരു ധാരണയുണ്ട്, എങ്ങനെ ഉപയോഗിക്കണമെന്ന് പഠിക്കാൻ നമുക്ക് പോകാം റൺടൈം API (കരാർ നിർവ്വഹണ API). റൺടൈം API-ന് 8 അനുബന്ധ API-കൾ ഉണ്ട്, അത് കരാർ നിർവ്വഹണത്തിനായി പൊതുവായ ഇന്റർഫേസുകൾ നൽകുകയും ഡാറ്റ വീണ്ടെടുക്കാനും രൂപാന്തരപ്പെടുത്താനും സാധൂകരിക്കാനും ഡെവലപ്പർമാരെ സഹായിക്കുന്നു.

8 API ഡാറ്റയുടെ ഒരു ഹ്രസ്വ വിവരണം ചുവടെയുണ്ട്:

8 API ഡാറ്റ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നമുക്ക് സൂക്ഷ്മമായി പരിശോധിക്കാം. ഇതിന് മുമ്പ്, നിങ്ങൾക്ക് ഒന്റോളജി സ്മാർട്ട് കരാർ വികസന ടൂളിൽ ഒരു പുതിയ കരാർ സൃഷ്ടിക്കാൻ കഴിയും SmartX കൂടാതെ താഴെയുള്ള നിർദ്ദേശങ്ങൾ പാലിക്കുക.

റൺടൈം API എങ്ങനെ ഉപയോഗിക്കാം

ഇറക്കുമതി ചെയ്യാൻ രണ്ട് വഴികളുണ്ട് റൺടൈം API: ontology.interop.System.Runtime и ontology.interop.Ontology.Runtime. ഒന്റോളജി പാഥിൽ പുതുതായി ചേർത്ത API-കൾ അടങ്ങിയിരിക്കുന്നു. താഴെയുള്ള വരികൾ API ഡാറ്റ ഇറക്കുമതി ചെയ്യുന്നു.

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

API അറിയിക്കുക

നോട്ടിഫൈ ഫംഗ്‌ഷൻ നെറ്റ്‌വർക്കിലുടനീളം ഇവന്റ് പ്രക്ഷേപണം ചെയ്യുന്നു. ചുവടെയുള്ള ഉദാഹരണത്തിൽ, അറിയിപ്പ് ഫംഗ്ഷൻ ഹെക്സ് സ്ട്രിംഗ് "ഹലോ വേഡ്" തിരികെ നൽകുകയും നെറ്റ്‌വർക്കിലുടനീളം പ്രക്ഷേപണം ചെയ്യുകയും ചെയ്യും.

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

നിങ്ങൾക്ക് ഇത് ലോഗുകളിൽ കാണാൻ കഴിയും:

GetTime API

GetTime ഫംഗ്‌ഷൻ നിലവിലെ ടൈംസ്റ്റാമ്പ് നൽകുന്നു, അത് ഫംഗ്‌ഷൻ വിളിച്ചിരുന്ന Unix സമയം നൽകുന്നു. അളവിന്റെ യൂണിറ്റ് രണ്ടാമത്തേതാണ്.

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 എൻകോഡ് ചെയ്‌ത വിലാസത്തെ ഒരു bytearray വിലാസത്തിലേക്കും AddressToBase58 ഒരു bytearray വിലാസത്തെ അടിസ്ഥാന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(fromAcct) ഫംഗ്‌ഷന് രണ്ട് പ്രവർത്തനങ്ങളുണ്ട്:

• നിലവിലെ ഫംഗ്‌ഷന്റെ കോളർ ആക്‌റ്റിൽ നിന്നാണോ എന്ന് പരിശോധിക്കുക. അതെ എങ്കിൽ (അതായത്, ഒപ്പ് പരിശോധന പാസായി), ഫംഗ്ഷൻ തിരികെ നൽകുന്നു.
• നിലവിലെ പ്രവർത്തനത്തെ വിളിക്കുന്ന ഒബ്‌ജക്റ്റ് ഒരു കരാറാണോയെന്ന് പരിശോധിക്കുക. ഇത് ഒരു കരാർ ആണെങ്കിൽ, കരാറിൽ നിന്ന് ഫംഗ്ഷൻ നിർവ്വഹിച്ചാൽ, സ്ഥിരീകരണം കടന്നുപോകും. അതായത്, GetCallingScriptHash() ന്റെ റിട്ടേൺ മൂല്യമാണ് fromAcct എന്ന് പരിശോധിക്കുക. 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ഒന്റോളജി സ്മാർട്ട് കരാറുകളിൽ ആസ്തികൾ കൈമാറുന്നത് എങ്ങനെയെന്ന് അറിയാൻ.

പത്രാധിപർ ലേഖനം പരിഭാഷപ്പെടുത്തി ഹാഷ്റേറ്റ്&ഷെയറുകൾ പ്രത്യേകിച്ച് ഒന്റോളജി റഷ്യയ്ക്ക്.

നിങ്ങൾ ഒരു ഡെവലപ്പർ ആണോ? ഞങ്ങളുടെ ടെക് കമ്മ്യൂണിറ്റിയിൽ ചേരുക നിരസിക്കുക. കൂടാതെ, ഒന്നു നോക്കൂ ഡെവലപ്പർ സെന്റർ ഒന്റോളജി, നിങ്ങൾക്ക് അവിടെ കൂടുതൽ ഉപകരണങ്ങളും ഡോക്യുമെന്റേഷനും മറ്റും കണ്ടെത്താനാകും.

ഡെവലപ്പർമാർക്കായി ടാസ്‌ക്കുകൾ തുറക്കുക. ചുമതല പൂർത്തിയാക്കി ഒരു പ്രതിഫലം നേടുക.

അപേക്ഷിക്കുക വിദ്യാർത്ഥികൾക്കുള്ള ഒന്റോളജി ടാലന്റ് പ്രോഗ്രാമിനായി

ഓണ്ടിളജി

ഒന്റോളജി വെബ്സൈറ്റ് - സാമൂഹികം - നിരസിക്കുക - ടെലിഗ്രാം റഷ്യൻ - ട്വിറ്റർ - റെഡ്ഡിറ്റ്

അവലംബം: www.habr.com