ਓਨਟੋਲੋਜੀ ਨੈਟਵਰਕ ਤੇ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ। ਭਾਗ 1: ਬਲਾਕਚੈਨ ਅਤੇ ਬਲਾਕ API

ਇਹ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਡਿਵੈਲਪਮੈਂਟ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਓਨਟੋਲੋਜੀ ਬਲਾਕਚੈਨ ਨੈੱਟਵਰਕ 'ਤੇ ਪਾਈਥਨ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਬਣਾਉਣ ਬਾਰੇ ਟਿਊਟੋਰਿਅਲਸ ਦੀ ਲੜੀ ਦਾ ਪਹਿਲਾ ਹਿੱਸਾ ਹੈ। ਸਮਾਰਟਐਕਸ.

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਓਨਟੋਲੋਜੀ ਸਮਾਰਟ ਕੰਟਰੈਕਟ API ਨਾਲ ਆਪਣੀ ਜਾਣ-ਪਛਾਣ ਸ਼ੁਰੂ ਕਰਾਂਗੇ। ਓਨਟੋਲੋਜੀ ਸਮਾਰਟ ਕੰਟਰੈਕਟ API ਨੂੰ 7 ਮੋਡੀਊਲਾਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ:

1. ਬਲਾਕਚੈਨ ਅਤੇ ਬਲਾਕ API,
2. ਰਨਟਾਈਮ API,
3. ਸਟੋਰੇਜ API,
4. ਮੂਲ API,
5. ਅੱਪਗ੍ਰੇਡ API,
6. ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਇੰਜਣ API ਅਤੇ
7. ਸਥਿਰ ਅਤੇ ਡਾਇਨਾਮਿਕ ਕਾਲ API।

ਬਲਾਕਚੈਨ ਅਤੇ ਬਲਾਕ API ਓਨਟੋਲੋਜੀ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਿਸਟਮ ਦਾ ਮੁੱਖ ਹਿੱਸਾ ਹੈ। ਬਲਾਕਚੈਨ ਏਪੀਆਈ ਮੂਲ ਬਲਾਕਚੈਨ ਕਿਊਰੀ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਮੌਜੂਦਾ ਬਲਾਕ ਦੀ ਉਚਾਈ ਪ੍ਰਾਪਤ ਕਰਨਾ, ਜਦੋਂ ਕਿ ਬਲਾਕ ਏਪੀਆਈ ਮੂਲ ਬਲਾਕ ਕਿਊਰੀ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਦਿੱਤੇ ਗਏ ਬਲਾਕ ਲਈ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਪੁੱਛਗਿੱਛ ਕਰਨਾ।

ਆਓ ਸ਼ੁਰੂ ਕਰੀਏ!

ਪਹਿਲਾਂ, ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਇਕਰਾਰਨਾਮਾ ਬਣਾਓ ਸਮਾਰਟਐਕਸਅਤੇ ਫਿਰ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਹਿਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ।

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

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 ਦੀ ਵਰਤੋਂ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਹੈਸ਼ ਰਾਹੀਂ ਲੈਣ-ਦੇਣ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਲੈਣ-ਦੇਣ ਹੈਸ਼ ਨੂੰ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਦੁਆਰਾ ਹੈਸ਼ ਪ੍ਰਾਪਤ ਕਰੋ ਬਾਈਟੀਅਰੇ ਫਾਰਮੈਟ ਵਿੱਚ ਪੈਰਾਮੀਟਰਾਂ ਦੇ ਰੂਪ ਵਿੱਚ। ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਕੁੰਜੀ ਹੈਕਸਾ ਫਾਰਮੈਟ ਵਿੱਚ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਹੈਸ਼ ਨੂੰ ਬਾਈਟੀਅਰੇ ਫਾਰਮੈਟ ਵਿੱਚ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਹੈਸ਼ ਵਿੱਚ ਬਦਲਣਾ ਹੈ। ਇਹ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਦਮ ਹੈ। ਨਹੀਂ ਤਾਂ, ਤੁਹਾਨੂੰ ਇੱਕ ਗਲਤੀ ਮਿਲੇਗੀ ਜੋ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਉਸ ਬਲਾਕ ਹੈਸ਼ ਨਾਲ ਕੋਈ ਬਲਾਕ ਨਹੀਂ ਹੈ। ਆਉ ਇਸ ਨੂੰ ਬਾਈਟੀਅਰੇ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣ ਲਈ ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ ਹੈਕਸਾ ਫਾਰਮੈਟ ਵਿੱਚ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਹੈਸ਼ ਨੂੰ ਲੈਂਦੇ ਹਾਂ। ਇੱਕ ਉਦਾਹਰਨ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ:

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

Get Contract

ਡਿਵੈਲਪਰ ਇਕਰਾਰਨਾਮੇ ਦੇ ਹੈਸ਼ ਦੁਆਰਾ ਇਕਰਾਰਨਾਮਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ 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 ਦੀ ਵਰਤੋਂ ਇੱਕ ਬਲਾਕ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਖਾਸ ਬਲਾਕ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ.

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 ਵਿੱਚ ਤਿੰਨ ਉਪਲਬਧ ਫੰਕਸ਼ਨ ਹਨ: ਲੈਣ-ਦੇਣ ਪ੍ਰਾਪਤ ਕਰੋ, ਲੈਣ-ਦੇਣ ਗਿਣਤੀ ਪ੍ਰਾਪਤ ਕਰੋਅਤੇ TransactionByIndex ਪ੍ਰਾਪਤ ਕਰੋ. ਅਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਇਕ-ਇਕ ਕਰਕੇ ਤੋੜ ਦੇਵਾਂਗੇ।

ਲੈਣ-ਦੇਣ ਗਿਣਤੀ ਪ੍ਰਾਪਤ ਕਰੋ

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

TransactionByIndex ਪ੍ਰਾਪਤ ਕਰੋ

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 ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਦਾ ਇੱਕ ਲਾਜ਼ਮੀ ਹਿੱਸਾ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਇਹਨਾਂ ਦੀ ਵਰਤੋਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਵਿੱਚ ਬਲਾਕਚੈਨ ਡੇਟਾ ਅਤੇ ਬਲਾਕ ਡੇਟਾ ਦੀ ਬੇਨਤੀ ਕਰਨ ਲਈ ਕਰ ਸਕਦੇ ਹੋ। ਅਗਲੇ ਲੇਖਾਂ ਵਿੱਚ, ਅਸੀਂ ਚਰਚਾ ਕਰਾਂਗੇ ਕਿ ਬਾਕੀ APIs ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰੀਏ ਅਤੇ ਇਹ ਪਤਾ ਲਗਾਵਾਂਗੇ ਕਿ ਉਹ ਓਨਟੋਲੋਜੀ ਬਲਾਕਚੈਨ ਨਾਲ ਕਿਵੇਂ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਪਾਉਂਦੇ ਹਨ।

ਲੇਖ ਦਾ ਅਨੁਵਾਦ ਹਸ਼ਰਤੇ ਐਂਡ ਸ਼ੇਅਰਸ ਦੇ ਸੰਪਾਦਕਾਂ ਦੁਆਰਾ ਖਾਸ ਤੌਰ 'ਤੇ ਓਨਟੋਲੋਜੀ ਰੂਸ ਲਈ ਕੀਤਾ ਗਿਆ ਸੀ। ਰੋਣਾ

ਕੀ ਤੁਸੀਂ ਇੱਕ ਡਿਵੈਲਪਰ ਹੋ? 'ਤੇ ਸਾਡੇ ਤਕਨੀਕੀ ਭਾਈਚਾਰੇ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਵੋ ਵਿਵਾਦ. ਨਾਲ ਹੀ, 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੋ ਵਿਕਾਸਕਾਰ ਕੇਂਦਰ ਸਾਡੀ ਵੈੱਬਸਾਈਟ 'ਤੇ, ਜਿੱਥੇ ਤੁਸੀਂ ਡਿਵੈਲਪਰ ਟੂਲ, ਦਸਤਾਵੇਜ਼, ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਲੱਭ ਸਕਦੇ ਹੋ।

ਓਨਟੋਲਾਜੀ

• ਓਨਟੋਲੋਜੀ ਵੈਬਸਾਈਟ
• GitHub / ਵਿਵਾਦ
• ਤਾਰ ਅੰਗਰੇਜ਼ੀ ਵਿਚ / ਰੂਸੀ
• ਟਵਿੱਟਰ / Reddit

ਸਰੋਤ: www.habr.com