ProHoster > බ්ලොග් > පරිපාලනය > ඔන්ටොලොජි ජාලයේ පයිතන් හි ස්මාර්ට් කොන්ත්‍රාත්තුවක් ලියන්නේ කෙසේද. 1 කොටස: Blockchain සහ Block API

ඔන්ටොලොජි ජාලයේ පයිතන් හි ස්මාර්ට් කොන්ත්‍රාත්තුවක් ලියන්නේ කෙසේද. 1 කොටස: Blockchain සහ Block API

ඔන්ටොලොජි ජාලයේ පයිතන් හි ස්මාර්ට් කොන්ත්‍රාත්තුවක් ලියන්නේ කෙසේද. 1 කොටස: Blockchain සහ Block API

මෙය ස්මාර්ට් කොන්ත්‍රාත්තු සංවර්ධන මෙවලම භාවිතයෙන් Ontology blockchain ජාලයේ Python ස්මාර්ට් කොන්ත්‍රාත්තු නිර්මාණය කිරීම පිළිබඳ නිබන්ධන මාලාවක පළමු කොටසයි. SmartX.

මෙම ලිපියෙන් අපි ඔන්ටොලොජි ස්මාර්ට් කොන්ත්‍රාත්තු API සමඟ අපගේ දැන හඳුනා ගැනීම ආරම්භ කරමු. ඔන්ටොලොජි ස්මාර්ට් කොන්ත්‍රාත් API මොඩියුල 7 කට බෙදා ඇත:

  1. Blockchain සහ Block API,
  2. ධාවන කාල API,
  3. ගබඩා API,
  4. දේශීය API,
  5. API උත්ශ්‍රේණි කරන්න,
  6. Execution Engine API සහ
  7. ස්ථිතික සහ ගතික ඇමතුම් API.

Blockchain & Block API යනු Ontology ස්මාර්ට් කොන්ත්‍රාත් පද්ධතියේ ප්‍රධාන කොටසයි. Blockchain API වත්මන් වාරණ උස ලබා ගැනීම වැනි මූලික blockchain විමසුම් මෙහෙයුම් සඳහා සහය දක්වයි, Block API මඟින් ලබා දී ඇති වාරණ සඳහා ගනුදෙනු ගණන විමසීම වැනි මූලික වාරණ විමසුම් මෙහෙයුම් සඳහා සහය දක්වයි.

අපි පටන් ගනිමු!

පළමුව, නව ගිවිසුමක් සාදන්න SmartXඉන්පසු පහත උපදෙස් අනුගමනය කරන්න.

1. Blockchain API භාවිතා කරන්නේ කෙසේද

ස්මාර්ට් කොන්ත්‍රාත් කාර්යයන් සඳහා සබැඳි පයිතන් සබැඳිවලට සමාන වේ. ඔබට අවශ්‍ය පරිදි අදාළ කාර්යයන් ඇතුළත් කළ හැකිය. උදාහරණයක් ලෙස, පහත ප්‍රකාශය වත්මන් බ්ලොක් උස ලබා ගැනීමට GetHeight ශ්‍රිතයක් සහ බ්ලොක් ශීර්ෂය ලබා ගැනීමට GetHeader ශ්‍රිතයක් හඳුන්වා දෙයි.

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

GetHeight

GetHeight පහත උදාහරණයේ පෙන්වා ඇති පරිදි blockchain හි අවසාන වාරණ අනුක්‍රමික අංකය ලබා ගැනීමට භාවිතා කරයි. අවසාන උදාහරණයේ දී, අපි පහසුව සඳහා ප්රධාන කාර්යය ඉවත් කරමු, නමුත් අවශ්ය නම් ඔබට එය එකතු කළ හැකිය.

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 බ්ලොක් ශීර්ෂය ලබා ගැනීමට භාවිතා කරයි, පරාමිතිය යනු blockchain හි ඇති වාරණ අනුක්‍රමික අංකයයි. උදාහරණයක්:

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 ආකෘතියට පරිවර්තනය කිරීම සඳහා අපි උදාහරණයක් ලෙස hex ආකෘතියේ ගනුදෙනු හෑෂ් ගනිමු. උදාහරණයක් මේ වගේ පෙනේ:

9f270aa3a4c13c46891ff0e1a2bdb3ea0525669d414994aadf2606734d0c89c1

පළමුව, ගනුදෙනු හැෂ් ආපසු හරවන්න:

c1890c4d730626dfaa9449419d662505eab3bda2e1f01f89463cc1a4a30a279

SmartX විසින් සපයන ලද Hex Number(little endian)Number පරිවර්තන මෙවලම භාවිතයෙන් සංවර්ධකයින්ට මෙම පියවර සිදු කළ හැක.

ඉන්පසු ප්‍රතිඵලය 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 විසින් සපයන ලද String Byte Array පරිවර්තන මෙවලම භාවිතයෙන් මෙය සිදු කළ හැක. අවසාන වශයෙන්, ලැබෙන 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. Block API භාවිතා කරන්නේ කෙසේද

Block 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 භාවිතා කරන්නේ කෙසේද සහ ඒවා Ontology blockchain සමඟ අන්තර්ක්‍රියා කරන්නේ කෙසේදැයි සොයා බලමු.

විශේෂයෙන්ම OntologyRussia සඳහා Hashrate&Shares හි සංස්කාරකවරුන් විසින් ලිපිය පරිවර්තනය කරන ලදී. අඬනවා

ඔබ සංවර්ධකයෙක්ද? අපගේ තාක්ෂණික ප්‍රජාවට සම්බන්ධ වන්න විකාරයක්. එසේම, බලන්න සංවර්ධක මධ්යස්ථානය අපගේ වෙබ් අඩවියේ, ඔබට සංවර්ධක මෙවලම්, ලියකියවිලි සහ තවත් දේ සොයා ගත හැක.

ඕටොවිද්යාව

මූලාශ්රය: www.habr.com

අදහස් එක් කරන්න