🥇ഓന്റോളജി നെറ്റ്‌വർക്കിൽ പൈത്തണിൽ ഒരു സ്മാർട്ട് കോൺട്രാക്റ്റ് എങ്ങനെ എഴുതാം. ഭാഗം 1: ബ്ലോക്ക്‌ചെയിൻ & ബ്ലോക്ക് API

സ്‌മാർട്ട് കോൺട്രാക്‌ട് ഡെവലപ്‌മെന്റ് ടൂൾ ഉപയോഗിച്ച് ഒന്റോളജി ബ്ലോക്ക്‌ചെയിൻ നെറ്റ്‌വർക്കിൽ പൈത്തൺ സ്‌മാർട്ട് കരാറുകൾ സൃഷ്‌ടിക്കുന്നതിനെക്കുറിച്ചുള്ള ട്യൂട്ടോറിയലുകളുടെ ഒരു പരമ്പരയിലെ ആദ്യ ഭാഗമാണിത്. SmartX.

ഈ ലേഖനത്തിൽ, ഒന്റോളജി സ്മാർട്ട് കരാർ API-യുമായി ഞങ്ങൾ പരിചയപ്പെടാൻ തുടങ്ങും. ഒന്റോളജി സ്മാർട്ട് കരാർ API 7 മൊഡ്യൂളുകളായി തിരിച്ചിരിക്കുന്നു:

ബ്ലോക്ക്ചെയിൻ & ബ്ലോക്ക് API,
റൺടൈം API,
സംഭരണ API,
നേറ്റീവ് API,
API നവീകരിക്കുക,
എക്സിക്യൂഷൻ എഞ്ചിൻ API ഒപ്പം
സ്റ്റാറ്റിക് & ഡൈനാമിക് കോൾ API.

ഒന്റോളജി സ്മാർട്ട് കോൺട്രാക്ട് സിസ്റ്റത്തിന്റെ പ്രധാന ഭാഗമാണ് ബ്ലോക്ക്ചെയിൻ & ബ്ലോക്ക് API. ബ്ലോക്ക്‌ചെയിൻ API നിലവിലെ ബ്ലോക്ക് ഉയരം ലഭിക്കുന്നത് പോലുള്ള അടിസ്ഥാന ബ്ലോക്ക്‌ചെയിൻ അന്വേഷണ പ്രവർത്തനങ്ങളെ പിന്തുണയ്ക്കുന്നു, അതേസമയം ബ്ലോക്ക് API അടിസ്ഥാന ബ്ലോക്ക് അന്വേഷണ പ്രവർത്തനങ്ങളെ പിന്തുണയ്ക്കുന്നു, അതായത് തന്നിരിക്കുന്ന ബ്ലോക്കിനായുള്ള ഇടപാടുകളുടെ എണ്ണം അന്വേഷിക്കുന്നത്.

നമുക്ക് തുടങ്ങാം!

ആദ്യം, ഒരു പുതിയ കരാർ ഉണ്ടാക്കുക SmartXതുടർന്ന് ചുവടെയുള്ള നിർദ്ദേശങ്ങൾ പാലിക്കുക.

1. ബ്ലോക്ക്‌ചെയിൻ 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 നൽകുന്ന ഹെക്‌സ് നമ്പർ (ലിറ്റിൽ എൻഡിയൻ) നമ്പർ കൺവേർഷൻ ടൂൾ ഉപയോഗിച്ച് ഡെവലപ്പർമാർക്ക് ഈ ഘട്ടം പൂർത്തിയാക്കാനാകും.

തുടർന്ന് ഫലം bytearray ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുക:

{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 നൽകുന്ന സ്ട്രിംഗ് ബൈറ്റ് അറേ കൺവേർഷൻ ടൂൾ ഉപയോഗിച്ച് ഇത് ചെയ്യാം. അവസാനമായി, തത്ഫലമായുണ്ടാകുന്ന bytearray സമാനമായ ഒരു സ്ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യുക:

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

ഇടപാട് ഹാഷ് വഴി ഇടപാട് ഉയരം ലഭിക്കാൻ 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

GetBlock

ഒരു ബ്ലോക്ക് ലഭിക്കാൻ GetBlock ഉപയോഗിക്കുന്നു. ഒരു പ്രത്യേക ബ്ലോക്ക് ലഭിക്കാൻ രണ്ട് വഴികളുണ്ട്.

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

ഒരു പൂർണ്ണമായ ഗൈഡ് ഞങ്ങളുടെ കണ്ടെത്താനാകും സാമൂഹികം.

Afterword

ബ്ലോക്ക്‌ചെയിൻ & ബ്ലോക്ക് API എന്നത് സ്‌മാർട്ട് കരാറുകളുടെ ഒഴിച്ചുകൂടാനാവാത്ത ഭാഗമാണ്, കാരണം നിങ്ങൾക്ക് ബ്ലോക്ക്‌ചെയിൻ ഡാറ്റ അഭ്യർത്ഥിക്കാനും സ്‌മാർട്ട് കരാറുകളിൽ ഡാറ്റ ബ്ലോക്ക് ചെയ്യാനും അവ ഉപയോഗിക്കാനാകും. ഭാവിയിലെ ലേഖനങ്ങളിൽ, ബാക്കി API-കൾ എങ്ങനെ ഉപയോഗിക്കാമെന്നും അവ ഓന്റോളജി ബ്ലോക്ക്ചെയിനുമായി എങ്ങനെ ഇടപഴകുന്നുവെന്നും ഞങ്ങൾ ചർച്ച ചെയ്യും.

ഹഷ്‌റേറ്റ് ആൻഡ് ഷെയേഴ്‌സിന്റെ എഡിറ്റർമാരാണ് ലേഖനം വിവർത്തനം ചെയ്തത്, പ്രത്യേകിച്ച് ഒന്റോളജി റഷ്യയ്ക്ക് വേണ്ടി. കരയുക

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