විධිමත් සත්‍යාපනය යනු එක් වැඩසටහනක් හෝ ඇල්ගොරිතමයක් තවත් එකක් භාවිතයෙන් සත්‍යාපනය කිරීමයි.
මෙය වැඩසටහනක ඇති සියලුම දුර්වලතා සොයා ගැනීමට හෝ ඒවා නොපවතින බව ඔප්පු කිරීමට ඔබට ඉඩ සලසන බලවත්ම ක්‍රමයකි.
විධිමත් සත්‍යාපනය පිළිබඳ වඩාත් සවිස්තරාත්මක විස්තරයක් ගැටළුව විසඳීමේ උදාහරණයෙන් දැකිය හැකිය මගේ පෙර ලිපියේ.
මෙම ලිපියෙන් මම ගැටළු පිළිබඳ විධිමත් සත්‍යාපනයේ සිට වැඩසටහන් වෙත මාරු වන අතර කෙසේද යන්න විස්තර කරමි
ඒවා ස්වයංක්‍රීයව විධිමත් රීති පද්ධති බවට පරිවර්තනය කරන්නේ කෙසේද.
මෙය සිදු කිරීම සඳහා, මම සංකේතාත්මක මූලධර්ම භාවිතා කරමින් අතථ්‍ය යන්ත්‍රයක මගේම ප්‍රතිසමයක් ලිවීය.
එය වැඩසටහන් කේතය විග්‍රහ කර එය සමීකරණ පද්ධතියකට (SMT) පරිවර්තනය කරයි, එය දැනටමත් ක්‍රමලේඛනාත්මකව විසඳිය හැකිය.
සංකේතාත්මක ගණනය කිරීම් පිළිබඳ තොරතුරු අන්තර්ජාලයේ තරමක් ඛණ්ඩනය ලෙස ඉදිරිපත් කර ඇති බැවින්,
එය කුමක්දැයි මම කෙටියෙන් විස්තර කරමි.
සංකේතාත්මක ගණනය කිරීම යනු පුළුල් පරාසයක දත්ත මත වැඩසටහනක් එකවර ක්‍රියාත්මක කිරීමේ ක්‍රමයක් වන අතර විධිමත් වැඩසටහන් සත්‍යාපනය සඳහා වන ප්රධාන මෙවලම වේ.
උදාහරණයක් ලෙස, අපට පළමු තර්කයට ඕනෑම ධනාත්මක අගයක් ගත හැකි ආදාන කොන්දේසි, දෙවන සෘණ, තුන්වන ශුන්‍ය සහ ප්රතිදාන තර්කය, උදාහරණයක් ලෙස, 42 සැකසිය හැක.
එක් ධාවනයකදී සංකේතාත්මක ගණනය කිරීම් අපට අපේක්ෂිත ප්රතිඵලය ලබා ගත හැකිද යන්නට පිළිතුර සහ එවැනි ආදාන පරාමිති සමූහයක උදාහරණයක් ලබා දෙනු ඇත. නැතහොත් එවැනි පරාමිතීන් නොමැති බවට සාක්ෂි.
එපමනක් නොව, අපට හැකි සියලුම ඒවාට ආදාන තර්ක සැකසිය හැක, සහ ප්රතිදාන ඒවා පමණක් තෝරන්න, උදාහරණයක් ලෙස, පරිපාලක මුරපදය.
මෙම අවස්ථාවේදී, අපි වැඩසටහනේ සියලුම දුර්වලතා සොයා ගැනීමට හෝ පරිපාලකගේ මුරපදය ආරක්ෂිත බවට සාක්ෂි ලබා ගනිමු.
විශේෂිත ආදාන දත්ත සහිත වැඩසටහනක් සම්භාව්‍ය ලෙස ක්‍රියාත්මක කිරීම සංකේතාත්මක ක්‍රියාත්මක කිරීමේ විශේෂ අවස්ථාවක් බව සටහන් කළ හැකිය.
එබැවින්, මගේ චරිතය VM ද සම්මත අථත්‍ය යන්ත්‍රයක අනුකරණ මාදිලියේ ක්‍රියා කළ හැකිය.
පෙර ලිපියට අදහස් දැක්වීමේදී එහි දුර්වලතා පිළිබඳ සාකච්ඡාවක් සමඟ විධිමත් සත්‍යාපනය පිළිබඳ සාධාරණ විවේචන සොයාගත හැකිය.
ප්රධාන ගැටළු වන්නේ:
- විධිමත් සත්‍යාපනය අවසානයේ P=NP දක්වා පහළට එන බැවින් සංයුක්ත පිපිරීම
- ගොනු පද්ධතිය, ජාල සහ වෙනත් බාහිර ගබඩා වෙත ඇමතුම් සැකසීම සත්‍යාපනය කිරීම වඩාත් අපහසු වේ
- පිරිවිතරයේ දෝෂ, පාරිභෝගිකයා හෝ ක්‍රමලේඛකයා එක් දෙයක් අදහස් කරන විට, නමුත් තාක්ෂණික පිරිවිතරයේ එය ප්‍රමාණවත් ලෙස විස්තර කර නැත.
එහි ප්‍රතිඵලයක් වශයෙන්, වැඩසටහන සත්‍යාපනය කර පිරිවිතරයන්ට අනුකූල වනු ඇත, නමුත් නිර්මාණකරුවන් එයින් බලාපොරොත්තු වූ දෙයට වඩා සම්පූර්ණයෙන්ම වෙනස් දෙයක් කරනු ඇත.
මෙම ලිපියෙන් මම ප්‍රායෝගිකව විධිමත් සත්‍යාපනය භාවිතා කිරීම ප්රධාන වශයෙන් සලකා බලන බැවින්, මම දැනට මගේ හිස බිත්තියට නොගසන අතර ඇල්ගොරිතම සංකීර්ණත්වය සහ බාහිර ඇමතුම් ගණන අවම වන පද්ධතියක් තෝරා ගන්නෙමි.
ස්මාර්ට් කොන්ත්රාත්තු මෙම අවශ්‍යතා සඳහා වඩාත් ගැලපෙන බැවින්, තේරීම Waves වේදිකාවෙන් RIDE කොන්ත්රාත්තු මත වැටුණි: ඒවා Turing සම්පූර්ණ නොවේ, සහ ඒවායේ උපරිම සංකීර්ණත්වය කෘතිමව සීමා වේ.
නමුත් අපි ඒවා තාක්ෂණික පැත්තෙන් පමණක් සලකා බලමු.
සෑම දෙයකටම අමතරව, විධිමත් සත්‍යාපනය විශේෂයෙන් ඕනෑම කොන්ත්රාත්තුවක් සඳහා ඉල්ලුමක් පවතිනු ඇත: එය දියත් කිරීමෙන් පසු කොන්ත්රාත්තු දෝෂයක් නිවැරදි කිරීමට සාමාන්‍යයෙන් කළ නොහැක.
බොහෝ විට අරමුදල් විශාල ප්‍රමාණයක් ස්මාර්ට් කොන්ත්රාත්තු මත ගබඩා කර ඇති බැවින් එවැනි දෝෂ වල පිරිවැය ඉතා ඉහළ විය හැකිය.
මගේ සංකේතාත්මක අතථ්‍ය යන්ත්‍රය PHP සහ Python වලින් ලියා ඇති අතර, ලැබෙන SMT සූත්‍ර විසඳීමට Microsoft Research වෙතින් Z3Prover භාවිතා කරයි.
එහි හරය වන්නේ බලවත් බහු-ගනුදෙනු සෙවීමකි
බොහෝ ගනුදෙනු අවශ්‍ය වුවද, විසඳුම් හෝ දුර්වලතා සොයා ගැනීමට ඔබට ඉඩ සලසයි.
පවා , Ethereum දුර්වලතා සොයා ගැනීම සඳහා වඩාත්ම බලගතු සංකේතාත්මක රාමුවක්, මෙම හැකියාව එක් කළේ මාස කිහිපයකට පෙර පමණි.
නමුත් ඊතර් ගිවිසුම් වඩාත් සංකීර්ණ වන අතර ටියුරින් සම්පූර්ණ බව සඳහන් කිරීම වටී.
PHP විසින් RIDE ස්මාර්ට් කොන්ත්‍රාත්තුවේ ප්‍රභව කේතය python ස්ක්‍රිප්ට් එකක් බවට පරිවර්තනය කරයි, එහිදී වැඩසටහන Z3 SMT-අනුකූල කොන්ත්රාත්තු පද්ධතියක් ලෙස ඉදිරිපත් කර ඒවායේ සංක්‍රාන්ති සඳහා කොන්දේසි:
දැන් මම ඇතුළත සිදුවන දේ වඩාත් විස්තරාත්මකව විස්තර කරමි.
නමුත් පළමුව, RIDE ස්මාර්ට් ගිවිසුම් භාෂාව ගැන වචන කිහිපයක්.
එය ක්‍රියාකාරී සහ ප්‍රකාශන පදනම් කරගත් ක්‍රමලේඛන භාෂාවක් වන අතර එය නිර්මාණයෙන් කම්මැලි වේ.
RIDE බ්ලොක්චේන් තුළ හුදකලාව ක්‍රියාත්මක වන අතර පරිශීලකයාගේ මුදල් පසුම්බියට සම්බන්ධ ගබඩාවෙන් තොරතුරු ලබා ගැනීමට සහ ලිවීමට හැකිය.
ඔබට එක් එක් මුදල් පසුම්බියට RIDE ගිවිසුමක් ඇමිණිය හැකි අතර, ක්‍රියාත්මක කිරීමේ ප්රතිඵලය සත්‍ය හෝ අසත්‍ය වේ.
සත්‍ය යන්නෙන් අදහස් කරන්නේ ස්මාර්ට් කොන්ත්‍රාත්තුවෙන් ගනුදෙනුවට ඉඩ දෙන බවත්, FALSE යන්නෙන් එය තහනම් කරන බවත් ය.
සරල උදාහරණයක්: පසුම්බි ශේෂය 100ට වඩා අඩු නම් ස්ක්‍රිප්ට් එකකට මාරු කිරීම තහනම් කළ හැක.
උදාහරණයක් ලෙස, මම එකම වුල්ෆ්, එළුවා සහ ගෝවා ගන්නෙමි, නමුත් දැනටමත් ස්මාර්ට් කොන්ත්රාත්තුවක් ආකාරයෙන් ඉදිරිපත් කර ඇත.
පරිශීලකයා සියලු දෙනා අනෙක් පැත්තට යවන තුරු කොන්ත්රාත්තුව යොදවා ඇති මුදල් පසුම්බියෙන් මුදල් ආපසු ගැනීමට නොහැකි වනු ඇත.
#Извлекаем положение всех объектов из блокчейна
let contract = tx.sender
let human= extract(getInteger(contract,"human"))
let wolf= extract(getInteger(contract,"wolf"))
let goat= extract(getInteger(contract,"goat"))
let cabbage= extract(getInteger(contract,"cabbage"))
#Это так называемая дата-транзакция, в которой пользователь присылает новые 4 переменные.
#Контракт разрешит её только в случае если все объекты останутся в сохранности.
match tx {
case t:DataTransaction =>
#Извлекаем будущее положение всех объектов из транзакции
let newHuman= extract(getInteger(t.data,"human"))
let newWolf= extract(getInteger(t.data,"wolf"))
let newGoat= extract(getInteger(t.data,"goat"))
let newCabbage= extract(getInteger(t.data,"cabbage"))
#0 обозначает, что объект на левом берегу, а 1 что на правом
let humanSide= human == 0 || human == 1
let wolfSide= wolf == 0 || wolf == 1
let goatSide= goat == 0 || goat == 1
let cabbageSide= cabbage == 0 || cabbage == 1
let side= humanSide && wolfSide && goatSide && cabbageSide
#Будут разрешены только те транзакции, где с козой никого нет в отсутствии фермера.
let safeAlone= newGoat != newWolf && newGoat != newCabbage
let safe= safeAlone || newGoat == newHuman
let humanTravel= human != newHuman
#Способы путешествия фермера туда и обратно, с кем-то либо в одиночку.
let t1= humanTravel && newWolf == wolf + 1 && newGoat == goat && newCabbage == cabbage
let t2= humanTravel && newWolf == wolf && newGoat == goat + 1 && newCabbage == cabbage
let t3= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage + 1
let t4= humanTravel && newWolf == wolf - 1 && newGoat == goat && newCabbage == cabbage
let t5= humanTravel && newWolf == wolf && newGoat == goat - 1 && newCabbage == cabbage
let t6= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage - 1
let t7= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage
let objectTravel = t1 || t2 || t3 || t4 || t5 || t6 || t7
#Последняя строка в разделе транзакции описывает разрешающее транзакцию условие.
#Переменные транзакции должны иметь значения 1 или 0, все объекты должны
#быть в безопасности, а фермер должен переплывать реку в одиночку
#или с кем-то на каждом шагу
side && safe && humanTravel && objectTravel
case s:TransferTransaction =>
#Транзакция вывода средств разрешена только в случае если все переплыли на другой берег
human == 1 && wolf == 1 && goat == 1 && cabbage == 1
#Все прочие типы транзакций запрещены
case _ => false
}
PHP මුලින්ම ස්මාර්ට් කොන්ත්‍රාත්තුවෙන් සියලුම විචල්‍යයන් ඒවායේ යතුරු ආකාරයෙන් සහ ඊට අනුරූප බූලියන් ප්‍රකාශන විචල්‍යය උපුටා ගනී.
cabbage: extract ( getInteger ( contract , "cabbage" ) )
goat: extract ( getInteger ( contract , "goat" ) )
human: extract ( getInteger ( contract , "human" ) )
wolf: extract ( getInteger ( contract , "wolf" ) )
fState: human== 1 && wolf== 1 && goat== 1 && cabbage== 1
fState:
wolf:
goat:
cabbage:
cabbageSide: cabbage== 0 || cabbage== 1
human: extract ( getInteger ( contract , "human" ) )
newGoat: extract ( getInteger ( t.data , "goat" ) )
newHuman: extract ( getInteger ( t.data , "human" ) )
goatSide: goat== 0 || goat== 1
humanSide: human== 0 || human== 1
t7: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage
t3: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage + 1
t6: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage - 1
t2: humanTravel && newWolf== wolf && newGoat== goat + 1 && newCabbage== cabbage
t5: humanTravel && newWolf== wolf && newGoat== goat - 1 && newCabbage== cabbage
t1: humanTravel && newWolf== wolf + 1 && newGoat== goat && newCabbage== cabbage
t4: humanTravel && newWolf== wolf - 1 && newGoat== goat && newCabbage== cabbage
safeAlone: newGoat != newWolf && newGoat != newCabbage
wolfSide: wolf== 0 || wolf== 1
humanTravel: human != newHuman
side: humanSide && wolfSide && goatSide && cabbageSide
safe: safeAlone || newGoat== newHuman
objectTravel: t1 || t2 || t3 || t4 || t5 || t6 || t7
PHP පසුව ඒවා Python හි Z3Prover SMT-අනුකූල පද්ධති විස්තරයක් බවට පරිවර්තනය කරයි.
දත්ත ලූපයකින් ඔතා ඇති අතර, එහිදී ගබඩා විචල්‍යයන් දර්ශක i, ගනුදෙනු විචල්‍ය දර්ශක i + 1 සහ ප්‍රකාශන සහිත විචල්‍යයන් පෙර තත්වයේ සිට ඊළඟට සංක්‍රමණය වීම සඳහා නීති සකසයි.
බහු ගනුදෙනු සෙවුම් යන්ත්‍රයක් සපයන අපගේ අතථ්‍ය යන්ත්‍රයේ හදවත මෙයයි.
fState: And( And( And( human[Steps] == 1 , wolf[Steps] == 1 ) , goat[Steps] == 1 ) , cabbage[Steps] == 1 )
final: fState[Steps]
fState:
wolf:
goat:
cabbage:
cabbageSide: Or( cabbage[i] == 0 , cabbage[i] == 1 )
goatSide: Or( goat[i] == 0 , goat[i] == 1 )
humanSide: Or( human[i] == 0 , human[i] == 1 )
t7: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
t3: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] + 1 )
t6: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] - 1 )
t2: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] + 1 ) , cabbage == cabbage[i] )
t5: And( And( And( humanTravel[i] , wolf == wolf[i] ) , goat[i+1] == goat[i] - 1 ) , cabbage == cabbage[i] )
t1: And( And( And( humanTravel[i] , wolf == wolf[i] + 1 ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
t4: And( And( And( humanTravel[i] , wolf == wolf[i] - 1 ) , goat[i+1] == goat[i] ) , cabbage == cabbage[i] )
safeAlone: And( goat[i+1] != wolf , goat[i+1] != cabbage )
wolfSide: Or( wolf[i] == 0 , wolf[i] == 1 )
humanTravel: human[i] != human[i+1]
side: And( And( And( humanSide[i] , wolfSide[i] ) , goatSide[i] ) , cabbageSide[i] )
safe: Or( safeAlone[i] , goat[i+1] == human[i+1] )
objectTravel: Or( Or( Or( Or( Or( Or( t1[i] , t2[i] ) , t3[i] ) , t4[i] ) , t5[i] ) , t6[i] ) , t7[i] )
data: And( And( And( side[i] , safe[i] ) , humanTravel[i] ) , objectTravel[i] )
කොන්දේසි වර්ග කර Python හි SMT පද්ධතිය විස්තර කිරීමට නිර්මාණය කර ඇති ස්ක්‍රිප්ට් අච්චුවකට ඇතුල් කරනු ලැබේ.
හිස් අච්චුව
import json
from z3 import *
s = Solver()
Steps=7
Num= Steps+1
$code$
#template, only start rest
s.add(data + start)
#template
s.add(final)
ind = 0
f = open("/var/www/html/all/bin/python/log.txt", "a")
while s.check() == sat:
ind = ind +1
print ind
m = s.model()
print m
print "traversing model..."
#for d in m.decls():
#print "%s = %s" % (d.name(), m[d])
f.write(str(m))
f.write("nn")
exit()
#s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model
print "Total solution number: "
print ind
f.close()
සම්පූර්ණ දාමයේ අවසාන තත්වය සඳහා, හුවමාරු ගනුදෙනු අංශයේ දක්වා ඇති නීති අදාළ වේ.
මෙයින් අදහස් කරන්නේ Z3Prover විසින් කොන්ත්‍රාත්තුවෙන් මුදල් ආපසු ගැනීමට අවසානයේ ඉඩ සලසන එවැනි කොන්දේසි මාලාවක් සොයන බවයි.
එහි ප්‍රතිඵලයක් වශයෙන්, අපගේ කොන්ත්‍රාත්තුවේ පූර්ණ ක්‍රියාකාරී SMT ආකෘතියක් අපට ස්වයංක්‍රීයව ලැබේ.
එය මා අතින් සම්පාදනය කරන ලද මගේ පෙර ලිපියේ ආකෘතියට බෙහෙවින් සමාන බව ඔබට පෙනෙනු ඇත.
සම්පුර්ණ කරන ලද අච්චුව
import json
from z3 import *
s = Solver()
Steps=7
Num= Steps+1
human = [ Int('human_%i' % (i + 1)) for i in range(Num) ]
wolf = [ Int('wolf_%i' % (i + 1)) for i in range(Num) ]
goat = [ Int('goat_%i' % (i + 1)) for i in range(Num) ]
cabbage = [ Int('cabbage_%i' % (i + 1)) for i in range(Num) ]
nothing= [ And( human[i] == human[i+1], wolf[i] == wolf[i+1], goat[i] == goat[i+1], cabbage[i] == cabbage[i+1] ) for i in range(Num-1) ]
start= [ human[0] == 1, wolf[0] == 0, goat[0] == 1, cabbage[0] == 0 ]
safeAlone= [ And( goat[i+1] != wolf[i+1] , goat[i+1] != cabbage[i+1] ) for i in range(Num-1) ]
safe= [ Or( safeAlone[i] , goat[i+1] == human[i+1] ) for i in range(Num-1) ]
humanTravel= [ human[i] != human[i+1] for i in range(Num-1) ]
cabbageSide= [ Or( cabbage[i] == 0 , cabbage[i] == 1 ) for i in range(Num-1) ]
goatSide= [ Or( goat[i] == 0 , goat[i] == 1 ) for i in range(Num-1) ]
humanSide= [ Or( human[i] == 0 , human[i] == 1 ) for i in range(Num-1) ]
t7= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t3= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] + 1 ) for i in range(Num-1) ]
t6= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] - 1 ) for i in range(Num-1) ]
t2= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] + 1 ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t5= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] ) , goat[i+1] == goat[i] - 1 ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t1= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] + 1 ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
t4= [ And( And( And( humanTravel[i] , wolf[i+1] == wolf[i] - 1 ) , goat[i+1] == goat[i] ) , cabbage[i+1] == cabbage[i] ) for i in range(Num-1) ]
wolfSide= [ Or( wolf[i] == 0 , wolf[i] == 1 ) for i in range(Num-1) ]
side= [ And( And( And( humanSide[i] , wolfSide[i] ) , goatSide[i] ) , cabbageSide[i] ) for i in range(Num-1) ]
objectTravel= [ Or( Or( Or( Or( Or( Or( t1[i] , t2[i] ) , t3[i] ) , t4[i] ) , t5[i] ) , t6[i] ) , t7[i] ) for i in range(Num-1) ]
data= [ Or( And( And( And( side[i] , safe[i] ) , humanTravel[i] ) , objectTravel[i] ) , nothing[i]) for i in range(Num-1) ]
fState= And( And( And( human[Steps] == 1 , wolf[Steps] == 1 ) , goat[Steps] == 1 ) , cabbage[Steps] == 1 )
final= fState
#template, only start rest
s.add(data + start)
#template
s.add(final)
ind = 0
f = open("/var/www/html/all/bin/python/log.txt", "a")
while s.check() == sat:
ind = ind +1
print ind
m = s.model()
print m
print "traversing model..."
#for d in m.decls():
#print "%s = %s" % (d.name(), m[d])
f.write(str(m))
f.write("nn")
exit()
#s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model
print "Total solution number: "
print ind
f.close()
දියත් කිරීමෙන් පසු, Z3Prover ස්මාර්ට් කොන්ත්රාත්තුව විසඳන අතර අපට අරමුදල් ආපසු ගැනීමට ඉඩ සලසන ගනුදෙනු දාමයක් අපට සපයයි:
Winning transaction chain found:
Data transaction: human= 0, wolf= 0, goat= 1, cabbage= 0
Data transaction: human= 1, wolf= 0, goat= 1, cabbage= 1
Data transaction: human= 0, wolf= 0, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 0, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Transfer transaction
තොටුපළ කොන්ත්රාත්තුවට අමතරව, ඔබට ඔබේම කොන්ත්රාත්තු සමඟ අත්හදා බැලීමට හෝ ගනුදෙනු 2 කින් විසඳා ඇති මෙම සරල උදාහරණය උත්සාහ කළ හැකිය.
let contract = tx.sender
let a= extract(getInteger(contract,"a"))
let b= extract(getInteger(contract,"b"))
let c= extract(getInteger(contract,"c"))
let d= extract(getInteger(contract,"d"))
match tx {
case t:DataTransaction =>
let na= extract(getInteger(t.data,"a"))
let nb= extract(getInteger(t.data,"b"))
let nc= extract(getInteger(t.data,"c"))
let nd= extract(getInteger(t.data,"d"))
nd == 0 || a == 100 - 5
case s:TransferTransaction =>
( a + b - c ) * d == 12
case _ => true
}
මෙය පළමු අනුවාදය වන බැවින්, වාක්‍ය ඛණ්ඩය ඉතා සීමිත වන අතර දෝෂ තිබිය හැක.
පහත ලිපි වලින්, මම VM හි වැඩිදුර සංවර්ධනය ආවරණය කිරීමට සැලසුම් කර ඇති අතර, ඒවා විසඳීමට පමණක් නොව, එහි ආධාරයෙන් විධිමත් ලෙස සත්‍යාපිත ස්මාර්ට් කොන්ත්රාත්තු නිර්මාණය කළ හැකි ආකාරය පෙන්වන්න.
අක්ෂර අතථ්‍ය යන්ත්‍රය මෙහි ඇත
සංකේතාත්මක VM හි මූල කේතය පිළිවෙලට තබා එහි අදහස් එකතු කිරීමෙන් පසු එය නොමිලේ ප්‍රවේශය සඳහා GitHub මත තැබීමට මම අදහස් කරමි.
මූලාශ්රය: www.habr.com