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

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

ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು ಒಂಟಾಲಜಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ API ಯೊಂದಿಗೆ ನಮ್ಮ ಪರಿಚಯವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ. ಒಂಟಾಲಜಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ API ಅನ್ನು 7 ಮಾಡ್ಯೂಲ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ:

ಬ್ಲಾಕ್‌ಚೈನ್ ಮತ್ತು ಬ್ಲಾಕ್ API,
ರನ್ಟೈಮ್ API
ಶೇಖರಣಾ API
ಸ್ಥಳೀಯ API
API ಅನ್ನು ನವೀಕರಿಸಿ,
ಎಕ್ಸಿಕ್ಯೂಶನ್ ಇಂಜಿನ್ API ಮತ್ತು
ಸ್ಥಿರ ಮತ್ತು ಡೈನಾಮಿಕ್ ಕರೆ API.

ಬ್ಲಾಕ್‌ಚೈನ್ ಮತ್ತು ಬ್ಲಾಕ್ API ಒಂಟಾಲಜಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ ವ್ಯವಸ್ಥೆಯ ಪ್ರಮುಖ ಭಾಗವಾಗಿದೆ. ಬ್ಲಾಕ್‌ಚೈನ್ ಎಪಿಐ ಮೂಲಭೂತ ಬ್ಲಾಕ್‌ಚೈನ್ ಪ್ರಶ್ನೆ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಬ್ಲಾಕ್‌ನ ಪ್ರಸ್ತುತ ಎತ್ತರವನ್ನು ಪಡೆಯುವುದು, ಆದರೆ ಬ್ಲಾಕ್ ಎಪಿಐ ಮೂಲಭೂತ ಬ್ಲಾಕ್ ಪ್ರಶ್ನೆ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ನಿರ್ದಿಷ್ಟ ಬ್ಲಾಕ್‌ಗಾಗಿ ವಹಿವಾಟುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರಶ್ನಿಸುವುದು.

ನಾವೀಗ ಆರಂಭಿಸೋಣ!

ಪ್ರಾರಂಭಿಸಲು, ಹೊಸ ಒಪ್ಪಂದವನ್ನು ರಚಿಸಿ SmartX, ತದನಂತರ ಕೆಳಗಿನ ಸೂಚನೆಗಳನ್ನು ಅನುಸರಿಸಿ.

1. Blockchain API ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ ಕಾರ್ಯದ ಉಲ್ಲೇಖಗಳು ಪೈಥಾನ್ ಉಲ್ಲೇಖಗಳಿಗೆ ಹೋಲುತ್ತವೆ. ಅಗತ್ಯವಿರುವಂತೆ ನೀವು ಸಂಬಂಧಿತ ಕಾರ್ಯಗಳನ್ನು ನಮೂದಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಹೇಳಿಕೆಯು ಬ್ಲಾಕ್‌ನ ಪ್ರಸ್ತುತ ಎತ್ತರವನ್ನು ಪಡೆಯುವ ಕಾರ್ಯವಾದ GetHeight ಅನ್ನು ಮತ್ತು ಬ್ಲಾಕ್‌ನ ಶೀರ್ಷಿಕೆಯನ್ನು ಪಡೆಯುವ ಕಾರ್ಯವಾದ GetHeader ಅನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ.

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

ಗೆಟ್‌ಹೈಟ್

ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಬ್ಲಾಕ್‌ಚೈನ್‌ನಲ್ಲಿ ಕೊನೆಯ ಬ್ಲಾಕ್ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲು 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 ಸ್ವರೂಪದಲ್ಲಿ ನಿಯತಾಂಕಗಳಾಗಿ. ಈ ಕಾರ್ಯದ ಕೀಲಿಯು ವ್ಯವಹಾರ ಹ್ಯಾಶ್ ಅನ್ನು ಹೆಕ್ಸ್ ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ವಹಿವಾಟು ಹ್ಯಾಶ್‌ಗೆ ಬೈಟರ್‌ರೇ ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಪರಿವರ್ತಿಸುವುದು. ಇದು ಒಂದು ಪ್ರಮುಖ ಹಂತವಾಗಿದೆ. ಇಲ್ಲದಿದ್ದರೆ ಆ ಬ್ಲಾಕ್ ಹ್ಯಾಶ್‌ನೊಂದಿಗೆ ಯಾವುದೇ ಬ್ಲಾಕ್ ಇಲ್ಲ ಎಂದು ಸೂಚಿಸುವ ದೋಷವನ್ನು ನೀವು ಪಡೆಯುತ್ತೀರಿ. ಅದನ್ನು bytearray ಫಾರ್ಮ್ಯಾಟ್‌ಗೆ ಪರಿವರ್ತಿಸಲು ಉದಾಹರಣೆಯಾಗಿ ಹೆಕ್ಸ್ ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ವಹಿವಾಟು ಹ್ಯಾಶ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ. ಉದಾಹರಣೆ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

9f270aa3a4c13c46891ff0e1a2bdb3ea0525669d414994aadf2606734d0c89c1

ಮೊದಲು ವಹಿವಾಟು ಹ್ಯಾಶ್ ಅನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಿ:

c1890c4d730626dfaa9449419d662505eab3bda2e1f01f89463cc1a4a30a279

ಡೆವಲಪರ್‌ಗಳು ಸ್ಮಾರ್ಟ್‌ಎಕ್ಸ್ ಒದಗಿಸಿದ ಹೆಕ್ಸ್ ಸಂಖ್ಯೆ(ಲಿಟಲ್ ಎಂಡಿಯನ್)ಸಂಖ್ಯೆ ಪರಿವರ್ತನೆ ಉಪಕರಣವನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಹಂತವನ್ನು ಸಾಧಿಸಬಹುದು.

ನಂತರ ಫಲಿತಾಂಶವನ್ನು ಬೈಟರ್ರೇ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಿ:

{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 ನಲ್ಲಿ ಮೂರು ಲಭ್ಯವಿರುವ ಕಾರ್ಯಗಳಿವೆ: ಗೆಟ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ಸ್, GetTransactioncountಮತ್ತು GetTransactionByIndex. ನಾವು ಅವುಗಳನ್ನು ಒಂದೊಂದಾಗಿ ವಿಂಗಡಿಸುತ್ತೇವೆ.

GetTransactioncount

ಕೊಟ್ಟಿರುವ ಬ್ಲಾಕ್‌ಗಾಗಿ ವಹಿವಾಟುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲು 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 ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಮತ್ತು ಅವು ಆಂಟಾಲಜಿ ಬ್ಲಾಕ್‌ಚೈನ್‌ನೊಂದಿಗೆ ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ ಎಂಬುದನ್ನು ನಾವು ಚರ್ಚಿಸುತ್ತೇವೆ.

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

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

ಒಂಟಾಲಜಿ

ಮೂಲ: www.habr.com

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