স্ক্র্যাচ থেকে একটি আনুষ্ঠানিক যাচাইকরণ সিস্টেম তৈরি করা। পার্ট 1: পিএইচপি এবং পাইথনে অক্ষর ভার্চুয়াল মেশিন

আনুষ্ঠানিক যাচাই হল একটি প্রোগ্রাম বা অ্যালগরিদম ব্যবহার করে অন্যটি যাচাই করা।

এটি সবচেয়ে শক্তিশালী পদ্ধতিগুলির মধ্যে একটি যা আপনাকে একটি প্রোগ্রামে সমস্ত দুর্বলতা খুঁজে পেতে বা প্রমাণ করতে দেয় যে সেগুলি বিদ্যমান নেই।

আনুষ্ঠানিক যাচাইকরণের আরও বিশদ বিবরণ সমস্যা সমাধানের উদাহরণে দেখা যেতে পারে নেকড়ে, ছাগল এবং বাঁধাকপি আমার আগের নিবন্ধে।

এই নিবন্ধে আমি সমস্যাগুলির আনুষ্ঠানিক যাচাইকরণ থেকে প্রোগ্রামগুলিতে চলে যাই এবং কীভাবে তা বর্ণনা করি
কিভাবে আপনি তাদের আনুষ্ঠানিক নিয়মের সিস্টেমে স্বয়ংক্রিয়ভাবে রূপান্তর করতে পারেন।

এটি করার জন্য, আমি প্রতীকী নীতিগুলি ব্যবহার করে একটি ভার্চুয়াল মেশিনের আমার নিজস্ব অ্যানালগ লিখেছি।

এটি প্রোগ্রাম কোড পার্স করে এবং এটিকে একটি সিস্টেম অফ ইকুয়েশন (SMT) তে অনুবাদ করে, যা ইতিমধ্যে প্রোগ্রামগতভাবে সমাধান করা যেতে পারে।

যেহেতু প্রতীকী গণনা সম্পর্কে তথ্য ইন্টারনেটে বরং খণ্ডিতভাবে উপস্থাপিত হয়,
আমি সংক্ষেপে এটা কি বর্ণনা করব.

সিম্বলিক কম্পিউটেশন হল একযোগে বিস্তৃত ডেটার উপর একটি প্রোগ্রাম চালানোর একটি উপায় এবং আনুষ্ঠানিক প্রোগ্রাম যাচাইয়ের প্রধান হাতিয়ার।

উদাহরণ স্বরূপ, আমরা ইনপুট শর্ত সেট করতে পারি যেখানে প্রথম আর্গুমেন্ট যেকোনো ইতিবাচক মান, দ্বিতীয় নেতিবাচক, তৃতীয় শূন্য এবং আউটপুট আর্গুমেন্ট নিতে পারে, উদাহরণস্বরূপ, 42।

এক দৌড়ে প্রতীকী গণনা আমাদের জন্য কাঙ্খিত ফলাফল এবং এই ধরনের ইনপুট পরামিতিগুলির একটি সেটের উদাহরণ পাওয়া সম্ভব কিনা তার উত্তর দেবে। অথবা প্রমাণ যে এই ধরনের কোন পরামিতি নেই।

অধিকন্তু, আমরা সম্ভাব্য সকলের জন্য ইনপুট আর্গুমেন্ট সেট করতে পারি এবং শুধুমাত্র আউটপুটগুলি নির্বাচন করতে পারি, উদাহরণস্বরূপ, প্রশাসকের পাসওয়ার্ড।

এই ক্ষেত্রে, আমরা প্রোগ্রামের সমস্ত দুর্বলতা খুঁজে পাব বা প্রশাসকের পাসওয়ার্ড নিরাপদ বলে প্রমাণ পাব।

এটি লক্ষ করা যায় যে নির্দিষ্ট ইনপুট ডেটা সহ একটি প্রোগ্রামের ক্লাসিক্যাল এক্সিকিউশন হল সিম্বলিক এক্সিকিউশনের একটি বিশেষ কেস।

অতএব, আমার চরিত্র VM একটি স্ট্যান্ডার্ড ভার্চুয়াল মেশিনের এমুলেশন মোডেও কাজ করতে পারে।

পূর্ববর্তী নিবন্ধের মন্তব্যে কেউ এর দুর্বলতাগুলির আলোচনার সাথে আনুষ্ঠানিক যাচাইকরণের ন্যায্য সমালোচনা খুঁজে পেতে পারেন।

প্রধান সমস্যা হল:

1. কম্বিনেটরিয়াল বিস্ফোরণ, যেহেতু আনুষ্ঠানিক যাচাইকরণ শেষ পর্যন্ত P=NP-তে নেমে আসে
2. ফাইল সিস্টেম, নেটওয়ার্ক এবং অন্যান্য বাহ্যিক সঞ্চয়স্থানে কল প্রক্রিয়াকরণ যাচাই করা আরও কঠিন
3. স্পেসিফিকেশনে বাগ, যখন গ্রাহক বা প্রোগ্রামার একটি জিনিস উদ্দেশ্য করে, কিন্তু প্রযুক্তিগত স্পেসিফিকেশনে যথেষ্ট সঠিকভাবে তা বর্ণনা করেনি।

ফলস্বরূপ, প্রোগ্রামটি যাচাই করা হবে এবং স্পেসিফিকেশন মেনে চলবে, তবে নির্মাতারা এটি থেকে যা আশা করেছিলেন তার থেকে সম্পূর্ণ ভিন্ন কিছু করবে।

যেহেতু এই নিবন্ধে আমি প্রধানত অনুশীলনে আনুষ্ঠানিক যাচাইকরণের ব্যবহার বিবেচনা করছি, তাই আমি আপাতত দেয়ালে মাথা ঠেকব না এবং এমন একটি সিস্টেম বেছে নেব যেখানে অ্যালগরিদমিক জটিলতা এবং বাহ্যিক কলের সংখ্যা ন্যূনতম।

যেহেতু স্মার্ট চুক্তিগুলি এই প্রয়োজনীয়তাগুলিকে সবচেয়ে ভাল করে, তাই পছন্দটি ওয়েভস প্ল্যাটফর্ম থেকে RIDE চুক্তিতে পড়ে: তারা টুরিং সম্পূর্ণ নয় এবং তাদের সর্বাধিক জটিলতা কৃত্রিমভাবে সীমিত৷

তবে আমরা প্রযুক্তিগত দিক থেকে তাদের একচেটিয়াভাবে বিবেচনা করব।

সবকিছুর পাশাপাশি, আনুষ্ঠানিক যাচাইকরণ বিশেষ করে যেকোনো চুক্তির চাহিদার মধ্যে থাকবে: এটি চালু হওয়ার পরে চুক্তির ত্রুটি সংশোধন করা সাধারণত অসম্ভব।
এবং এই ধরনের ত্রুটিগুলির খরচ খুব বেশি হতে পারে, যেহেতু বেশ বড় পরিমাণে তহবিল প্রায়শই স্মার্ট চুক্তিতে সংরক্ষণ করা হয়।

আমার সিম্বলিক ভার্চুয়াল মেশিন পিএইচপি এবং পাইথনে লেখা, এবং ফলে এসএমটি সূত্রগুলি সমাধান করতে মাইক্রোসফ্ট রিসার্চ থেকে Z3Prover ব্যবহার করে।

এর মূলে রয়েছে একটি শক্তিশালী বহু-লেনদেন অনুসন্ধান, যা
আপনি সমাধান বা দুর্বলতা খুঁজে পেতে অনুমতি দেয়, এমনকি যদি এটি অনেক লেনদেনের প্রয়োজন হয়.
এমন কি মিথ্রিল, Ethereum দুর্বলতা খুঁজে বের করার জন্য সবচেয়ে শক্তিশালী প্রতীকী কাঠামোর মধ্যে একটি, শুধুমাত্র কয়েক মাস আগে এই ক্ষমতা যোগ করেছে।

কিন্তু এটি লক্ষণীয় যে ইথার চুক্তিগুলি আরও জটিল এবং টুরিং সম্পূর্ণ।

PHP RIDE স্মার্ট কন্ট্রাক্টের সোর্স কোডকে একটি পাইথন স্ক্রিপ্টে অনুবাদ করে, যেখানে প্রোগ্রামটিকে তাদের ট্রানজিশনের জন্য চুক্তির অবস্থা এবং শর্তগুলির Z3 SMT-সামঞ্জস্যপূর্ণ সিস্টেম হিসাবে উপস্থাপন করা হয়:

এখন আমি আরও বিশদে ভিতরে কী ঘটছে তা বর্ণনা করব।

কিন্তু প্রথমে, RIDE স্মার্ট চুক্তির ভাষা সম্পর্কে কয়েকটি শব্দ।

এটি একটি কার্যকরী এবং অভিব্যক্তি-ভিত্তিক প্রোগ্রামিং ভাষা যা ডিজাইন দ্বারা অলস।
RIDE ব্লকচেইনের মধ্যে বিচ্ছিন্নভাবে চলে এবং ব্যবহারকারীর ওয়ালেটের সাথে সংযুক্ত স্টোরেজ থেকে তথ্য পুনরুদ্ধার এবং লিখতে পারে।

আপনি প্রতিটি ওয়ালেটে একটি RIDE চুক্তি সংযুক্ত করতে পারেন এবং কার্যকর করার ফলাফল শুধুমাত্র সত্য বা মিথ্যা হবে৷

TRUE এর অর্থ হল স্মার্ট চুক্তি লেনদেনের অনুমতি দেয় এবং 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

}

পিএইচপি প্রথমে স্মার্ট কন্ট্রাক্ট থেকে তাদের কী এবং সংশ্লিষ্ট বুলিয়ান এক্সপ্রেশন ভেরিয়েবলের আকারে সমস্ত ভেরিয়েবল বের করে।

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] )  

শর্তগুলি সাজানো হয়েছে এবং একটি স্ক্রিপ্ট টেমপ্লেটে সন্নিবেশ করা হয়েছে যা পাইথনে 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-এর আরও উন্নয়ন কভার করার পরিকল্পনা করছি, এবং কীভাবে আপনি এটির সাহায্যে আনুষ্ঠানিকভাবে যাচাইকৃত স্মার্ট চুক্তিগুলি তৈরি করতে পারেন তা দেখান এবং কেবল সেগুলি সমাধান করবেন না।

অক্ষর ভার্চুয়াল মেশিন পাওয়া যায় http://2.59.42.98/hyperbox/
সিম্বলিক ভিএম-এর সোর্স কোডটি ক্রমানুসারে রাখার এবং সেখানে মন্তব্য যোগ করার পরে, আমি বিনামূল্যে অ্যাক্সেসের জন্য এটিকে গিটহাবে রাখার পরিকল্পনা করছি।

উত্স: www.habr.com