🥇ಆಂಟಾಲಜಿ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಪೈಥಾನ್‌ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಬರೆಯುವುದು ಹೇಗೆ. ಭಾಗ 3: ರನ್ಟೈಮ್ API

ಒಂಟಾಲಜಿ ಬ್ಲಾಕ್‌ಚೈನ್ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಪೈಥಾನ್‌ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳನ್ನು ರಚಿಸುವ ಕುರಿತು ಶೈಕ್ಷಣಿಕ ಲೇಖನಗಳ ಸರಣಿಯಲ್ಲಿ ಇದು 3 ನೇ ಭಾಗವಾಗಿದೆ. ಹಿಂದಿನ ಲೇಖನಗಳಲ್ಲಿ ನಾವು ಪರಿಚಯವಾಯಿತು

ಒಂಟಾಲಜಿ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಪೈಥಾನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ ಸೂಕ್ತವಾದ ನಿರಂತರ ಸಂಗ್ರಹಣೆ 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 ಫಂಕ್ಷನ್ ಪ್ರಸ್ತುತ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು ಯುನಿಕ್ಸ್ ಸಮಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಅಳತೆಯ ಘಟಕವು ಎರಡನೆಯದು.

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 ವಿಳಾಸವನ್ನು base58 ಎನ್‌ಕೋಡ್ ಮಾಡಿದ ವಿಳಾಸಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.

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)

ಸಾಕ್ಷಿಯನ್ನು ಪರಿಶೀಲಿಸಿ

ಚೆಕ್‌ವಿಟ್ನೆಸ್ (FromAcct) ಕಾರ್ಯವು ಎರಡು ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ:

ಪ್ರಸ್ತುತ ಫಂಕ್ಷನ್‌ನ ಕರೆ ಮಾಡುವವರು ಆಕ್ಟ್‌ನಿಂದ ಬಂದಿದ್ದಾರೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ. ಹೌದು ಎಂದಾದರೆ (ಅಂದರೆ, ಸಹಿ ಪರಿಶೀಲನೆಯನ್ನು ಅಂಗೀಕರಿಸಲಾಗಿದೆ), ಕಾರ್ಯವು ಹಿಂತಿರುಗುತ್ತದೆ.
ಪ್ರಸ್ತುತ ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ವಸ್ತುವು ಒಪ್ಪಂದವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ. ಇದು ಒಪ್ಪಂದವಾಗಿದ್ದರೆ ಮತ್ತು ಒಪ್ಪಂದದಿಂದ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ, ನಂತರ ಪರಿಶೀಲನೆಯನ್ನು ರವಾನಿಸಲಾಗುತ್ತದೆ. ಅಂದರೆ, 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ಒಂಟಾಲಜಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳಲ್ಲಿ ಸ್ವತ್ತುಗಳನ್ನು ಹೇಗೆ ವರ್ಗಾಯಿಸುವುದು ಎಂದು ತಿಳಿಯಲು.

ಲೇಖನವನ್ನು ಸಂಪಾದಕರು ಅನುವಾದಿಸಿದ್ದಾರೆ Hashrate&Shares ವಿಶೇಷವಾಗಿ ಒಂಟಾಲಜಿ ರಷ್ಯಾಕ್ಕೆ.

ನೀವು ಡೆವಲಪರ್ ಆಗಿದ್ದೀರಾ? ನಲ್ಲಿ ನಮ್ಮ ತಾಂತ್ರಿಕ ಸಮುದಾಯವನ್ನು ಸೇರಿ ಅಪವಾದ. ಅಲ್ಲದೆ, ಒಮ್ಮೆ ನೋಡಿ ಡೆವಲಪರ್ ಸೆಂಟರ್ ಹೆಚ್ಚಿನ ಪರಿಕರಗಳು, ದಾಖಲಾತಿಗಳು ಮತ್ತು ಹೆಚ್ಚಿನವುಗಳಿಗಾಗಿ ಆಂಟಾಲಜಿ.

ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಕಾರ್ಯಗಳನ್ನು ತೆರೆಯಿರಿ. ಕಾರ್ಯವನ್ನು ಮುಚ್ಚಿ - ಬಹುಮಾನವನ್ನು ಪಡೆಯಿರಿ.

ಅನ್ವಯಿಸು ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಒಂಟಾಲಜಿ ಪ್ರತಿಭಾ ಕಾರ್ಯಕ್ರಮಕ್ಕಾಗಿ

ಒಂಟಾಲಜಿ

ಆಂಟಾಲಜಿ ವೆಬ್‌ಸೈಟ್ - GitHub - ಅಪವಾದ - ಟೆಲಿಗ್ರಾಮ್ ರಷ್ಯನ್ - ಟ್ವಿಟರ್ - ರೆಡ್ಡಿಟ್

ಮೂಲ: www.habr.com

ಒಂಟಾಲಜಿ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಪೈಥಾನ್‌ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಹೇಗೆ ಬರೆಯುವುದು. ಭಾಗ 3: ರನ್ಟೈಮ್ API