TON-ൽ ഒരു സ്‌മാർട്ട് കരാർ എങ്ങനെ എഴുതാം, പ്രസിദ്ധീകരിക്കാം എന്നതിനെക്കുറിച്ച്

ഈ ലേഖനം എന്തിനെക്കുറിച്ചാണ്?

ആദ്യത്തെ (രണ്ടിൽ) ടെലിഗ്രാം ബ്ലോക്ക്ചെയിൻ മത്സരത്തിൽ ഞാൻ എങ്ങനെ പങ്കെടുത്തു, സമ്മാനം വാങ്ങിയില്ല, എന്റെ അനുഭവം ഒരു ലേഖനത്തിൽ രേഖപ്പെടുത്താൻ തീരുമാനിച്ചു, അങ്ങനെ അത് വിസ്മൃതിയിൽ മുങ്ങാതിരിക്കാനും ഒരുപക്ഷേ സഹായിക്കാനും ലേഖനത്തിൽ ഞാൻ സംസാരിക്കും. ആരെങ്കിലും.

എനിക്ക് അബ്‌സ്‌സ്‌ട്രാക്റ്റ് കോഡ് എഴുതാൻ താൽപ്പര്യമില്ലാത്തതിനാൽ, എന്തെങ്കിലും ജോലി ചെയ്യാൻ, ലേഖനത്തിനായി ഞാൻ ഒരു തൽക്ഷണ ലോട്ടറിക്ക് ഒരു സ്മാർട്ട് കരാറും ഇന്റർമീഡിയറ്റ് സ്റ്റോറേജ് ഉപയോഗിക്കാതെ തന്നെ TON-ൽ നിന്ന് നേരിട്ട് സ്‌മാർട്ട് കരാർ ഡാറ്റ കാണിക്കുന്ന ഒരു വെബ്‌സൈറ്റും എഴുതി.

TON-ൽ തങ്ങളുടെ ആദ്യത്തെ സ്മാർട്ട് കരാർ ഉണ്ടാക്കാൻ ആഗ്രഹിക്കുന്നവർക്ക് ലേഖനം ഉപയോഗപ്രദമാകും, എന്നാൽ എവിടെ തുടങ്ങണമെന്ന് അറിയില്ല.

ലോട്ടറി ഒരു ഉദാഹരണമായി ഉപയോഗിച്ച്, ഞാൻ പരിസ്ഥിതി ഇൻസ്റ്റാൾ ചെയ്യുന്നതിൽ നിന്ന് ഒരു സ്‌മാർട്ട് കരാർ പ്രസിദ്ധീകരിക്കുന്നതിനും അതുമായി ഇടപഴകുന്നതിനും ഡാറ്റ സ്വീകരിക്കുന്നതിനും പ്രസിദ്ധീകരിക്കുന്നതിനുമായി ഒരു വെബ്‌സൈറ്റ് എഴുതുന്നതിനും പോകും.

മത്സരത്തിൽ പങ്കെടുക്കുന്നതിനെക്കുറിച്ച്

കഴിഞ്ഞ ഒക്ടോബറിൽ ടെലിഗ്രാം പുതിയ ഭാഷകളുമായി ഒരു ബ്ലോക്ക് ചെയിൻ മത്സരം പ്രഖ്യാപിച്ചു Fift и FunC. നിർദ്ദേശിച്ച അഞ്ച് സ്മാർട്ട് കരാറുകളിൽ ഏതെങ്കിലും എഴുതുന്നതിൽ നിന്ന് തിരഞ്ഞെടുക്കേണ്ടത് ആവശ്യമാണ്. ഭാവിയിൽ വേറൊന്നും എഴുതേണ്ടി വന്നില്ലെങ്കിലും വ്യത്യസ്തമായി എന്തെങ്കിലും ചെയ്ത് ഭാഷ പഠിച്ച് എന്തെങ്കിലും ഉണ്ടാക്കിയാൽ നന്നായിരിക്കും എന്ന് തോന്നി. കൂടാതെ, വിഷയം നിരന്തരം ചുണ്ടുകളിൽ.

സ്‌മാർട്ട് കരാറുകൾ വികസിപ്പിക്കുന്നതിൽ എനിക്ക് യാതൊരു പരിചയവുമില്ലെന്ന് പറയേണ്ടതാണ്.

എനിക്ക് കഴിയുന്നത് വരെ അവസാനം വരെ പങ്കെടുക്കാനും തുടർന്ന് ഒരു അവലോകന ലേഖനം എഴുതാനും ഞാൻ പദ്ധതിയിട്ടിരുന്നു, പക്ഷേ ആദ്യത്തേതിൽ തന്നെ ഞാൻ പരാജയപ്പെട്ടു. ഐ ഒരു വാലറ്റ് എഴുതി ഒന്നിലധികം ഒപ്പുകൾ ഓണാക്കി FunC അത് പൊതുവെ പ്രവർത്തിക്കുകയും ചെയ്തു. ഞാനത് അടിസ്ഥാനമായി എടുത്തു സോളിഡിറ്റിയിലെ മികച്ച കരാർ.

അന്നു ഞാൻ കരുതി, ഇത് തീർച്ചയായും മതി എന്നെങ്കിലും സമ്മാനം കിട്ടാൻ. തൽഫലമായി, പങ്കെടുത്ത 40-ൽ 60-ഓളം പേർ സമ്മാന ജേതാക്കളായി, അവരിൽ ഞാനില്ലായിരുന്നു. പൊതുവേ, ഇതിൽ തെറ്റൊന്നുമില്ല, പക്ഷേ ഒരു കാര്യം എന്നെ വിഷമിപ്പിച്ചു. ഫലങ്ങൾ പ്രഖ്യാപിക്കുന്ന സമയത്ത്, എന്റെ കരാറിനായുള്ള പരിശോധനയുടെ അവലോകനം നടന്നിട്ടില്ല, ചാറ്റിൽ പങ്കെടുത്തവരോട് അത് ഇല്ലാത്ത മറ്റാരെങ്കിലും ഉണ്ടോ എന്ന് ഞാൻ ചോദിച്ചു, ആരുമില്ല.

പ്രത്യക്ഷത്തിൽ എന്റെ സന്ദേശങ്ങളിൽ ശ്രദ്ധ ചെലുത്തി, രണ്ട് ദിവസത്തിന് ശേഷം ജഡ്ജിമാർ ഒരു അഭിപ്രായം പ്രസിദ്ധീകരിച്ചു, വിധിനിർണ്ണയത്തിനിടയിൽ അവർക്ക് ആകസ്മികമായി എന്റെ സ്മാർട്ട് കരാർ നഷ്‌ടമായോ അതോ ഒരു അഭിപ്രായം ആവശ്യമില്ലാത്തത്ര മോശമാണെന്ന് കരുതിയിരുന്നോ എന്ന് എനിക്ക് ഇപ്പോഴും മനസ്സിലാകുന്നില്ല. ഞാൻ പേജിൽ ഒരു ചോദ്യം ചോദിച്ചു, പക്ഷേ ഉത്തരം ലഭിച്ചില്ല. ആരാണ് വിധിച്ചതെന്നത് രഹസ്യമല്ലെങ്കിലും, വ്യക്തിപരമായ സന്ദേശങ്ങൾ എഴുതുന്നത് അനാവശ്യമാണെന്ന് ഞാൻ കരുതി.

മനസ്സിലാക്കാൻ ധാരാളം സമയം ചെലവഴിച്ചു, അതിനാൽ ഒരു ലേഖനം എഴുതാൻ തീരുമാനിച്ചു. ഇതുവരെ ധാരാളം വിവരങ്ങൾ ഇല്ലാത്തതിനാൽ, താൽപ്പര്യമുള്ള എല്ലാവർക്കും സമയം ലാഭിക്കാൻ ഈ ലേഖനം സഹായിക്കും.

TON-ലെ സ്മാർട്ട് കരാറുകളുടെ ആശയം

നിങ്ങൾ എന്തെങ്കിലും എഴുതുന്നതിനുമുമ്പ്, ഏത് വശത്ത് നിന്നാണ് ഈ കാര്യത്തെ സമീപിക്കേണ്ടതെന്ന് നിങ്ങൾ കണ്ടെത്തേണ്ടതുണ്ട്. അതിനാൽ, സിസ്റ്റം ഏതെല്ലാം ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നുവെന്ന് ഇപ്പോൾ ഞാൻ നിങ്ങളോട് പറയും. കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, കുറഞ്ഞത് ഏതെങ്കിലും തരത്തിലുള്ള വർക്കിംഗ് കരാറെങ്കിലും എഴുതാൻ നിങ്ങൾ അറിയേണ്ട ഭാഗങ്ങൾ.

ഒരു മികച്ച കരാർ എഴുതുന്നതിലും പ്രവർത്തിക്കുന്നതിലും ഞങ്ങൾ ശ്രദ്ധ കേന്ദ്രീകരിക്കും TON Virtual Machine (TVM), Fift и FunC, അതിനാൽ ലേഖനം ഒരു സാധാരണ പ്രോഗ്രാമിന്റെ വികസനത്തിന്റെ വിവരണം പോലെയാണ്. പ്ലാറ്റ്ഫോം തന്നെ ഇവിടെ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് ഞങ്ങൾ ചിന്തിക്കില്ല.

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് പൊതുവായി TVM ഭാഷയും Fift നല്ല ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ ഉണ്ട്. മത്സരത്തിൽ പങ്കെടുക്കുമ്പോഴും ഇപ്പോൾ നിലവിലുള്ള കരാർ എഴുതുമ്പോഴും ഞാൻ പലപ്പോഴും അവളുടെ നേരെ തിരിഞ്ഞു.

സ്മാർട്ട് കരാറുകൾ എഴുതപ്പെടുന്ന പ്രധാന ഭാഷയാണ് FunC. ഇപ്പോൾ അതിൽ ഡോക്യുമെന്റേഷൻ ഒന്നുമില്ല, അതിനാൽ എന്തെങ്കിലും എഴുതുന്നതിന് നിങ്ങൾ ഔദ്യോഗിക ശേഖരത്തിൽ നിന്നുള്ള സ്മാർട്ട് കരാറുകളുടെ ഉദാഹരണങ്ങളും അവിടെ തന്നെ ഭാഷ നടപ്പിലാക്കുന്നതും പഠിക്കേണ്ടതുണ്ട്, കൂടാതെ കഴിഞ്ഞ രണ്ടിലെ സ്മാർട്ട് കരാറുകളുടെ ഉദാഹരണങ്ങൾ നിങ്ങൾക്ക് നോക്കാം. മത്സരങ്ങൾ. ലേഖനത്തിന്റെ അവസാനം ലിങ്കുകൾ.

ഇതിനായി ഞങ്ങൾ ഇതിനകം ഒരു മികച്ച കരാർ എഴുതിയിട്ടുണ്ടെന്ന് പറയാം FunC, അതിനുശേഷം ഞങ്ങൾ കോഡ് ഫിഫ്റ്റ് അസംബ്ലറിലേക്ക് കംപൈൽ ചെയ്യുന്നു.

സമാഹരിച്ച സ്മാർട്ട് കരാർ പ്രസിദ്ധീകരിക്കാൻ ശേഷിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഒരു ഫംഗ്ഷൻ എഴുതേണ്ടതുണ്ട് Fift, ഇത് സ്‌മാർട്ട് കരാർ കോഡും മറ്റ് ചില പാരാമീറ്ററുകളും ഇൻപുട്ടായി എടുക്കും, കൂടാതെ ഔട്ട്‌പുട്ട് വിപുലീകരണത്തോടുകൂടിയ ഒരു ഫയലായിരിക്കും .boc ("സെല്ലുകളുടെ ബാഗ്" എന്നാണ് അർത്ഥമാക്കുന്നത്), കൂടാതെ, ഞങ്ങൾ അത് എങ്ങനെ എഴുതുന്നു എന്നതിനെ ആശ്രയിച്ച്, ഒരു സ്വകാര്യ കീയും വിലാസവും, അത് സ്മാർട്ട് കരാർ കോഡ് അടിസ്ഥാനമാക്കി ജനറേറ്റുചെയ്യുന്നു. ഇതുവരെ പ്രസിദ്ധീകരിച്ചിട്ടില്ലാത്ത ഒരു സ്‌മാർട്ട് കരാറിന്റെ വിലാസത്തിലേക്ക് നിങ്ങൾക്ക് ഇതിനകം ഗ്രാം അയയ്‌ക്കാൻ കഴിയും.

TON-ൽ ഒരു മികച്ച കരാർ പ്രസിദ്ധീകരിക്കാൻ ലഭിച്ചു .boc ഒരു ലൈറ്റ് ക്ലയന്റ് ഉപയോഗിച്ച് ഫയൽ ബ്ലോക്ക്ചെയിനിലേക്ക് അയയ്‌ക്കേണ്ടതുണ്ട് (താഴെയുള്ളതിൽ കൂടുതൽ). എന്നാൽ പ്രസിദ്ധീകരിക്കുന്നതിന് മുമ്പ്, നിങ്ങൾ സൃഷ്ടിച്ച വിലാസത്തിലേക്ക് ഗ്രാം ട്രാൻസ്ഫർ ചെയ്യേണ്ടതുണ്ട്, അല്ലാത്തപക്ഷം സ്മാർട്ട് കരാർ പ്രസിദ്ധീകരിക്കില്ല. പ്രസിദ്ധീകരണത്തിന് ശേഷം, നിങ്ങൾക്ക് പുറത്ത് നിന്ന് (ഉദാഹരണത്തിന്, ഒരു ലൈറ്റ് ക്ലയന്റ് ഉപയോഗിച്ച്) അല്ലെങ്കിൽ അകത്ത് നിന്ന് (ഉദാഹരണത്തിന്, ഒരു സ്മാർട്ട് കോൺട്രാക്റ്റ് TON-നുള്ളിൽ മറ്റൊരു സന്ദേശം അയയ്‌ക്കുന്നു) സന്ദേശങ്ങൾ അയച്ചുകൊണ്ട് സ്‌മാർട്ട് കരാറുമായി സംവദിക്കാം.

കോഡ് എങ്ങനെയാണ് പ്രസിദ്ധീകരിക്കുന്നതെന്ന് മനസ്സിലാക്കിക്കഴിഞ്ഞാൽ, അത് എളുപ്പമാകും. ഞങ്ങൾ എന്താണ് എഴുതേണ്ടതെന്നും ഞങ്ങളുടെ പ്രോഗ്രാം എങ്ങനെ പ്രവർത്തിക്കുമെന്നും ഞങ്ങൾക്ക് ഏകദേശം അറിയാം. എഴുതുമ്പോൾ, നിലവിലുള്ള സ്മാർട്ട് കരാറുകളിൽ ഇത് എങ്ങനെ നടപ്പിലാക്കി എന്ന് ഞങ്ങൾ നോക്കുന്നു, അല്ലെങ്കിൽ ഞങ്ങൾ നടപ്പിലാക്കൽ കോഡ് പരിശോധിക്കുന്നു Fift и FunC ഔദ്യോഗിക ശേഖരത്തിൽ, അല്ലെങ്കിൽ ഔദ്യോഗിക ഡോക്യുമെന്റേഷനിൽ നോക്കുക.

എല്ലാ മത്സര പങ്കാളികളും ടെലിഗ്രാം ജീവനക്കാരും ഒത്തുകൂടിയ ടെലിഗ്രാം ചാറ്റിൽ ഞാൻ പലപ്പോഴും കീവേഡുകൾക്കായി തിരഞ്ഞു, മത്സരത്തിനിടെ എല്ലാവരും അവിടെ ഒത്തുകൂടി ഫിഫ്റ്റും ഫൺസിയും ചർച്ച ചെയ്യാൻ തുടങ്ങി. ലേഖനത്തിന്റെ അവസാനം ലിങ്ക്.

സിദ്ധാന്തത്തിൽ നിന്ന് പരിശീലനത്തിലേക്ക് മാറേണ്ട സമയമാണിത്.

TON-നൊപ്പം പ്രവർത്തിക്കാനുള്ള അന്തരീക്ഷം ഒരുക്കുന്നു

MacOS-ലെ ലേഖനത്തിൽ വിവരിക്കുന്നതെല്ലാം ഞാൻ ചെയ്തു, ഡോക്കറിലെ ക്ലീൻ ഉബുണ്ടു 18.04 LTS-ൽ അത് രണ്ടുതവണ പരിശോധിച്ചു.

നിങ്ങൾ ആദ്യം ചെയ്യേണ്ടത് ഡൗൺലോഡ് ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യുക എന്നതാണ് lite-client ഇത് ഉപയോഗിച്ച് നിങ്ങൾക്ക് TON-ലേക്ക് അഭ്യർത്ഥനകൾ അയയ്‌ക്കാൻ കഴിയും.

ഔദ്യോഗിക വെബ്‌സൈറ്റിലെ നിർദ്ദേശങ്ങൾ ഇൻസ്റ്റാളേഷൻ പ്രക്രിയയെ വളരെ വിശദമായും വ്യക്തമായും വിവരിക്കുകയും ചില വിശദാംശങ്ങൾ ഒഴിവാക്കുകയും ചെയ്യുന്നു. ഇവിടെ ഞങ്ങൾ നിർദ്ദേശങ്ങൾ പാലിക്കുന്നു, വഴിയിൽ കാണാതായ ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു. ഓരോ പ്രൊജക്‌റ്റും ഞാൻ സ്വയം കംപൈൽ ചെയ്യാതെ ഔദ്യോഗിക ഉബുണ്ടു ശേഖരണത്തിൽ (ഞാൻ ഉപയോഗിച്ച MacOS-ൽ) നിന്ന് ഇൻസ്റ്റാൾ ചെയ്തു. brew).

apt -y install git 
apt -y install wget 
apt -y install cmake 
apt -y install g++ 
apt -y install zlib1g-dev 
apt -y install libssl-dev 

എല്ലാ ഡിപൻഡൻസികളും ഇൻസ്റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ നിങ്ങൾക്ക് ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും lite-client, Fift, FunC.

ആദ്യം, ഞങ്ങൾ TON റിപ്പോസിറ്ററി അതിന്റെ ഡിപൻഡൻസികൾക്കൊപ്പം ക്ലോൺ ചെയ്യുന്നു. സൗകര്യാർത്ഥം, ഞങ്ങൾ എല്ലാം ഒരു ഫോൾഡറിൽ ചെയ്യും ~/TON.

cd ~/TON
git clone https://github.com/ton-blockchain/ton.git
cd ./ton
git submodule update --init --recursive

റിപ്പോസിറ്ററി നടപ്പാക്കലുകളും സംഭരിക്കുന്നു Fift и FunC.

ഇപ്പോൾ ഞങ്ങൾ പ്രോജക്റ്റ് കൂട്ടിച്ചേർക്കാൻ തയ്യാറാണ്. റിപ്പോസിറ്ററി കോഡ് ഒരു ഫോൾഡറിലേക്ക് ക്ലോൺ ചെയ്തിരിക്കുന്നു ~/TON/ton. ദി ~/TON ഒരു ഫോൾഡർ സൃഷ്ടിക്കുക build അതിൽ പ്രോജക്റ്റ് ശേഖരിക്കുക.

mkdir ~/TON/build 
cd ~/TON/build
cmake ../ton

ഞങ്ങൾ ഒരു സ്മാർട്ട് കരാർ എഴുതാൻ പോകുന്നതിനാൽ, ഞങ്ങൾക്ക് മാത്രമല്ല വേണ്ടത് lite-clientപക്ഷേ Fift с FunC, അതിനാൽ നമുക്ക് എല്ലാം സമാഹരിക്കാം. ഇതൊരു പെട്ടെന്നുള്ള പ്രക്രിയയല്ല, അതിനാൽ ഞങ്ങൾ കാത്തിരിക്കുകയാണ്.

cmake --build . --target lite-client
cmake --build . --target fift
cmake --build . --target func

അടുത്തതായി, ഏത് നോഡിലേക്കുള്ള ഡാറ്റ അടങ്ങുന്ന കോൺഫിഗറേഷൻ ഫയൽ ഡൗൺലോഡ് ചെയ്യുക lite-client ബന്ധിപ്പിക്കും.

wget https://test.ton.org/ton-lite-client-test1.config.json

TON-ലേക്ക് ആദ്യ അഭ്യർത്ഥനകൾ നടത്തുന്നു

ഇനി നമുക്ക് ലോഞ്ച് ചെയ്യാം lite-client.

cd ~/TON/build
./lite-client/lite-client -C ton-lite-client-test1.config.json

ബിൽഡ് വിജയകരമാണെങ്കിൽ, ലോഞ്ച് ചെയ്ത ശേഷം ലൈറ്റ് ക്ലയന്റ് നോഡിലേക്കുള്ള കണക്ഷന്റെ ഒരു ലോഗ് നിങ്ങൾ കാണും.

[ 1][t 2][1582054822.963129282][lite-client.h:201][!testnode]   conn ready
[ 2][t 2][1582054823.085654020][lite-client.cpp:277][!testnode] server version is 1.1, capabilities 7
[ 3][t 2][1582054823.085725069][lite-client.cpp:286][!testnode] server time is 1582054823 (delta 0)
...

നിങ്ങൾക്ക് കമാൻഡ് പ്രവർത്തിപ്പിക്കാൻ കഴിയും help കൂടാതെ ഏതൊക്കെ കമാൻഡുകൾ ലഭ്യമാണെന്ന് കാണുക.

help

ഈ ലേഖനത്തിൽ നമ്മൾ ഉപയോഗിക്കുന്ന കമാൻഡുകൾ പട്ടികപ്പെടുത്താം.

list of available commands:
last    Get last block and state info from server
sendfile <filename> Load a serialized message from <filename> and send it to server
getaccount <addr> [<block-id-ext>]  Loads the most recent state of specified account; <addr> is in [<workchain>:]<hex-or-base64-addr> format
runmethod <addr> [<block-id-ext>] <method-id> <params>...   Runs GET method <method-id> of account <addr> with specified parameters

last получает последний созданный блок с сервера. 

sendfile <filename> отправляет в TON файл с сообщением, именно с помощью этой команды публикуется смарт-контракт и запрсосы к нему. 

getaccount <addr> загружает текущее состояние смарт-контракта с указанным адресом. 

runmethod <addr> [<block-id-ext>] <method-id> <params>  запускает get-методы смартконтракта. 

ഇപ്പോൾ ഞങ്ങൾ കരാർ തന്നെ എഴുതാൻ തയ്യാറാണ്.

നടപ്പാക്കൽ

ഐഡിയ

ഞാൻ മുകളിൽ എഴുതിയതുപോലെ, ഞങ്ങൾ എഴുതുന്ന സ്മാർട്ട് കരാർ ഒരു ലോട്ടറിയാണ്.

മാത്രമല്ല, ഇത് നിങ്ങൾ ഒരു ടിക്കറ്റ് വാങ്ങി ഒരു മണിക്കൂറോ ദിവസമോ മാസമോ കാത്തിരിക്കേണ്ട ഒരു ലോട്ടറിയല്ല, മറിച്ച് ഉപയോക്താവ് കരാർ വിലാസത്തിലേക്ക് കൈമാറുന്ന തൽക്ഷണമാണ്. N ഗ്രാം, അത് തൽക്ഷണം തിരികെ ലഭിക്കും 2 * N ഗ്രാം അല്ലെങ്കിൽ നഷ്ടം. ഞങ്ങൾ വിജയിക്കാനുള്ള സാധ്യത ഏകദേശം 40% ആക്കും. പേയ്‌മെന്റിന് മതിയായ ഗ്രാം ഇല്ലെങ്കിൽ, ഞങ്ങൾ ഇടപാട് ഒരു ടോപ്പ്-അപ്പായി പരിഗണിക്കും.

മാത്രമല്ല, വാതുവെപ്പുകൾ തത്സമയം കാണാനും സൗകര്യപ്രദമായ ഫോമിൽ കാണാനും കഴിയുന്നത് പ്രധാനമാണ്, അതുവഴി ഉപയോക്താവിന് താൻ വിജയിച്ചോ തോറ്റോ എന്ന് ഉടനടി മനസ്സിലാക്കാൻ കഴിയും. അതിനാൽ, TON-ൽ നിന്ന് നേരിട്ട് പന്തയങ്ങളും ഫലങ്ങളും കാണിക്കുന്ന ഒരു വെബ്‌സൈറ്റ് നിങ്ങൾ നിർമ്മിക്കേണ്ടതുണ്ട്.

ഒരു മികച്ച കരാർ എഴുതുന്നു

സൗകര്യാർത്ഥം, FunC-നുള്ള കോഡ് ഞാൻ ഹൈലൈറ്റ് ചെയ്തിട്ടുണ്ട്; വിഷ്വൽ സ്റ്റുഡിയോ കോഡ് തിരയലിൽ പ്ലഗിൻ കണ്ടെത്താനും ഇൻസ്റ്റാൾ ചെയ്യാനും കഴിയും; നിങ്ങൾ പെട്ടെന്ന് എന്തെങ്കിലും ചേർക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഞാൻ പ്ലഗിൻ പൊതുവായി ലഭ്യമാക്കിയിട്ടുണ്ട്. കൂടാതെ, ഫിഫ്റ്റിനൊപ്പം പ്രവർത്തിക്കാൻ ആരെങ്കിലും മുമ്പ് ഒരു പ്ലഗിൻ ഉണ്ടാക്കി, നിങ്ങൾക്ക് ഇത് ഇൻസ്റ്റാൾ ചെയ്യാനും വിഎസ്‌സിയിൽ കണ്ടെത്താനും കഴിയും.

നമുക്ക് ഉടൻ തന്നെ ഒരു ശേഖരം ഉണ്ടാക്കാം, അവിടെ ഞങ്ങൾ ഇന്റർമീഡിയറ്റ് ഫലങ്ങൾ ഉണ്ടാക്കും.

ഞങ്ങളുടെ ജീവിതം സുഗമമാക്കുന്നതിന്, ഞങ്ങൾ ഒരു സ്‌മാർട്ട് കരാർ എഴുതുകയും അത് തയ്യാറാകുന്നതുവരെ പ്രാദേശികമായി പരീക്ഷിക്കുകയും ചെയ്യും. അതിനുശേഷം മാത്രമേ ഞങ്ങൾ അത് TON-ൽ പ്രസിദ്ധീകരിക്കുകയുള്ളൂ.

സ്‌മാർട്ട് കരാറിന് ആക്‌സസ് ചെയ്യാൻ കഴിയുന്ന രണ്ട് ബാഹ്യ രീതികളുണ്ട്. ആദ്യം, recv_external() കരാറിനുള്ള ഒരു അഭ്യർത്ഥന പുറം ലോകത്ത് നിന്ന് വരുമ്പോൾ, അതായത്, TON-ൽ നിന്നല്ല, ഉദാഹരണത്തിന്, നമ്മൾ തന്നെ ഒരു സന്ദേശം സൃഷ്ടിച്ച് ലൈറ്റ്-ക്ലയന്റ് വഴി അയയ്ക്കുമ്പോൾ ഈ ഫംഗ്ഷൻ നടപ്പിലാക്കുന്നു. രണ്ടാമത്, recv_internal() ഇത്, TON-ൽ തന്നെ, ഏതൊരു കരാറും നമ്മുടേതിനെ സൂചിപ്പിക്കുന്നു. രണ്ട് സാഹചര്യങ്ങളിലും, നിങ്ങൾക്ക് ഫംഗ്ഷനിലേക്ക് പാരാമീറ്ററുകൾ കൈമാറാൻ കഴിയും.

പ്രസിദ്ധീകരിച്ചാൽ പ്രവർത്തിക്കുന്ന ഒരു ലളിതമായ ഉദാഹരണത്തിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം, പക്ഷേ അതിൽ പ്രവർത്തനപരമായ ലോഡ് ഇല്ല.

() recv_internal(slice in_msg) impure {
    ;; TODO: implementation 
}

() recv_external(slice in_msg) impure {
    ;; TODO: implementation  
}

അത് എന്താണെന്ന് ഇവിടെ വിശദീകരിക്കേണ്ടതുണ്ട് slice. TON ബ്ലോക്ക്‌ചെയിനിൽ സംഭരിച്ചിരിക്കുന്ന എല്ലാ ഡാറ്റയും ഒരു ശേഖരമാണ് TVM cell അല്ലെങ്കിൽ ലളിതമായി cell, അത്തരം ഒരു സെല്ലിൽ നിങ്ങൾക്ക് 1023 ബിറ്റ് ഡാറ്റയും മറ്റ് സെല്ലുകളിലേക്കുള്ള 4 ലിങ്കുകളും വരെ സംഭരിക്കാൻ കഴിയും.

TVM cell slice അഥവാ slice ഇത് നിലവിലുള്ളതിന്റെ ഭാഗമാണ് cell ഇത് പാഴ്‌സ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു, അത് പിന്നീട് വ്യക്തമാകും. ഞങ്ങൾക്ക് കൈമാറാൻ കഴിയും എന്നതാണ് പ്രധാന കാര്യം slice സന്ദേശത്തിന്റെ തരം അനുസരിച്ച്, ഡാറ്റ പ്രോസസ്സ് ചെയ്യുക recv_external() അഥവാ recv_internal().

impure — ഫംഗ്ഷൻ സ്മാർട്ട് കരാർ ഡാറ്റ പരിഷ്കരിക്കുന്നു എന്ന് സൂചിപ്പിക്കുന്ന ഒരു കീവേഡ്.

നമുക്ക് കരാർ കോഡ് സേവ് ചെയ്യാം lottery-code.fc സമാഹരിക്കുക.

~/TON/build/crypto/func -APSR -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc 

കമാൻഡ് ഉപയോഗിച്ച് ഫ്ലാഗുകളുടെ അർത്ഥം കാണാൻ കഴിയും

~/TON/build/crypto/func -help

ഞങ്ങൾ ഫിഫ്റ്റ് അസംബ്ലർ കോഡ് സമാഹരിച്ചു lottery-compiled.fif:

// lottery-compiled.fif

"Asm.fif" include
// automatically generated from `/Users/rajymbekkapisev/TON/ton/crypto/smartcont/stdlib.fc` `./lottery-code.fc` 
PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>c

ഇത് പ്രാദേശികമായി വിക്ഷേപിക്കാം, ഇതിനായി ഞങ്ങൾ പരിസ്ഥിതി ഒരുക്കും.

ആദ്യ വരി ബന്ധിപ്പിക്കുന്നത് ശ്രദ്ധിക്കുക Asm.fif, ഇത് ഫിഫ്റ്റ് അസംബ്ലർക്കായി ഫിഫ്റ്റിൽ എഴുതിയ കോഡാണ്.

സ്‌മാർട്ട് കരാർ പ്രാദേശികമായി പ്രവർത്തിപ്പിക്കാനും പരിശോധിക്കാനും ഞങ്ങൾ ആഗ്രഹിക്കുന്നതിനാൽ, ഞങ്ങൾ ഒരു ഫയൽ സൃഷ്‌ടിക്കും lottery-test-suite.fif കംപൈൽ ചെയ്‌ത കോഡ് അവിടെ പകർത്തുക, അതിലെ അവസാന വരി മാറ്റിസ്ഥാപിക്കുക, അത് സ്‌മാർട്ട് കോൺട്രാക്‌ട് കോഡ് ഒരു സ്ഥിരാങ്കത്തിലേക്ക് എഴുതുന്നു. codeഅത് വെർച്വൽ മെഷീനിലേക്ക് മാറ്റുന്നതിന്:

"TonUtil.fif" include
"Asm.fif" include

PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>s constant code

ഇതുവരെ വ്യക്തമായതായി തോന്നുന്നു, ഇപ്പോൾ അതേ ഫയലിലേക്ക് ടിവിഎം സമാരംഭിക്കാൻ ഉപയോഗിക്കുന്ന കോഡ് ചേർക്കാം.

0 tuple 0x076ef1ea , // magic
0 , 0 , // actions msg_sents
1570998536 , // unix_time
1 , 1 , 3 , // block_lt, trans_lt, rand_seed
0 tuple 100000000000000 , dictnew , , // remaining balance
0 , dictnew , // contract_address, global_config
1 tuple // wrap to another tuple
constant c7

0 constant recv_internal // to run recv_internal() 
-1 constant recv_external // to invoke recv_external()

В c7 ഞങ്ങൾ സന്ദർഭം രേഖപ്പെടുത്തുന്നു, അതായത് ടിവിഎം (അല്ലെങ്കിൽ നെറ്റ്‌വർക്ക് നില) സമാരംഭിക്കുന്ന ഡാറ്റ. മത്സര സമയത്ത് പോലും, ഡവലപ്പർമാരിൽ ഒരാൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് കാണിച്ചു c7 ഞാൻ പകർത്തുകയും ചെയ്തു. ഈ ലേഖനത്തിൽ നമുക്ക് മാറ്റം ആവശ്യമായി വന്നേക്കാം rand_seed ഒരു റാൻഡം സംഖ്യയുടെ ജനറേഷൻ അതിനെ ആശ്രയിച്ചിരിക്കുന്നതിനാൽ, മാറ്റിയില്ലെങ്കിൽ, ഓരോ തവണയും അതേ നമ്പർ തിരികെ നൽകും.

recv_internal и recv_external 0, -1 എന്നീ മൂല്യങ്ങളുള്ള സ്ഥിരാങ്കങ്ങൾ സ്‌മാർട്ട് കരാറിലെ അനുബന്ധ ഫംഗ്‌ഷനുകൾ വിളിക്കുന്നതിന് ഉത്തരവാദിയായിരിക്കും.

ഞങ്ങളുടെ ശൂന്യമായ സ്‌മാർട്ട് കരാറിനായുള്ള ആദ്യ ടെസ്റ്റ് സൃഷ്‌ടിക്കാൻ ഞങ്ങൾ ഇപ്പോൾ തയ്യാറാണ്. വ്യക്തതയ്ക്കായി, ഇപ്പോൾ ഞങ്ങൾ എല്ലാ ടെസ്റ്റുകളും ഒരേ ഫയലിലേക്ക് ചേർക്കും lottery-test-suite.fif.

നമുക്ക് ഒരു വേരിയബിൾ ഉണ്ടാക്കാം storage അതിൽ ഒഴിഞ്ഞ ഒരെണ്ണം എഴുതുക cell, ഇത് സ്മാർട്ട് കോൺട്രാക്ട് സ്റ്റോറേജ് ആയിരിക്കും.

message പുറത്തുള്ള സ്‌മാർട്ട് കോൺടാക്‌റ്റിലേക്ക് ഞങ്ങൾ കൈമാറുന്ന സന്ദേശമാണിത്. ഞങ്ങളും തൽക്കാലം ശൂന്യമാക്കും.

variable storage 
<b b> storage ! 

variable message 
<b b> message ! 

ഞങ്ങൾ സ്ഥിരാങ്കങ്ങളും വേരിയബിളുകളും തയ്യാറാക്കിയ ശേഷം, കമാൻഡ് ഉപയോഗിച്ച് ഞങ്ങൾ ടിവിഎം സമാരംഭിക്കുന്നു runvmctx കൂടാതെ സൃഷ്ടിച്ച പാരാമീറ്ററുകൾ ഇൻപുട്ടിലേക്ക് കൈമാറുക.

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx 

അവസാനം നമ്മൾ വിജയിക്കും അത് പോലെ എന്നതിനായുള്ള ഇന്റർമീഡിയറ്റ് കോഡ് Fift.

ഇപ്പോൾ നമുക്ക് ലഭിക്കുന്ന കോഡ് പ്രവർത്തിപ്പിക്കാം.

export FIFTPATH=~/TON/ton/crypto/fift/lib // выполняем один раз для удобства 
~/TON/build/crypto/fift -s lottery-test-suite.fif 

പ്രോഗ്രാം പിശകുകളില്ലാതെ പ്രവർത്തിക്കണം, ഔട്ട്പുട്ടിൽ നമ്മൾ എക്സിക്യൂഷൻ ലോഗ് കാണും:

execute SETCP 0
execute DICTPUSHCONST 19 (xC_,1)
execute DICTIGETJMPZ
execute DROP
execute implicit RET
[ 3][t 0][1582281699.325381279][vm.cpp:479]     steps: 5 gas: used=304, max=9223372036854775807, limit=9223372036854775807, credit=0

കൊള്ളാം, സ്‌മാർട്ട് കരാറിന്റെ ആദ്യ പ്രവർത്തന പതിപ്പ് ഞങ്ങൾ എഴുതിയിട്ടുണ്ട്.

ഇപ്പോൾ നമ്മൾ പ്രവർത്തനക്ഷമത ചേർക്കേണ്ടതുണ്ട്. ആദ്യം നമുക്ക് പുറം ലോകത്ത് നിന്ന് വരുന്ന സന്ദേശങ്ങൾ കൈകാര്യം ചെയ്യാം recv_external()

കരാർ അംഗീകരിക്കാൻ കഴിയുന്ന സന്ദേശ ഫോർമാറ്റ് ഡവലപ്പർ തന്നെ തിരഞ്ഞെടുക്കുന്നു.

എന്നാൽ സാധാരണയായി

• ഒന്നാമതായി, ഞങ്ങളുടെ കരാറിനെ പുറം ലോകത്തിൽ നിന്ന് സംരക്ഷിക്കാനും കരാറിന്റെ ഉടമയ്ക്ക് മാത്രമേ അതിലേക്ക് ബാഹ്യ സന്ദേശങ്ങൾ അയയ്‌ക്കാൻ കഴിയൂ എന്നതും ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.
• രണ്ടാമതായി, ഞങ്ങൾ TON-ലേക്ക് സാധുവായ ഒരു സന്ദേശം അയയ്‌ക്കുമ്പോൾ, ഇത് കൃത്യമായി ഒരിക്കൽ സംഭവിക്കണമെന്ന് ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, അതേ സന്ദേശം വീണ്ടും അയയ്‌ക്കുമ്പോൾ, സ്‌മാർട്ട് കരാർ അത് നിരസിക്കുന്നു.

അതിനാൽ മിക്കവാറും എല്ലാ കരാറുകളും ഈ രണ്ട് പ്രശ്‌നങ്ങളും പരിഹരിക്കുന്നു, ഞങ്ങളുടെ കരാർ ബാഹ്യ സന്ദേശങ്ങൾ സ്വീകരിക്കുന്നതിനാൽ, ഞങ്ങൾ അതും ശ്രദ്ധിക്കേണ്ടതുണ്ട്.

ഞങ്ങൾ അത് വിപരീത ക്രമത്തിൽ ചെയ്യും. ആദ്യം, ആവർത്തനത്തിലൂടെ പ്രശ്നം പരിഹരിക്കാം; കരാറിന് ഇതിനകം അത്തരമൊരു സന്ദേശം ലഭിക്കുകയും അത് പ്രോസസ്സ് ചെയ്യുകയും ചെയ്തിട്ടുണ്ടെങ്കിൽ, അത് രണ്ടാം തവണ അത് നടപ്പിലാക്കില്ല. തുടർന്ന് ഞങ്ങൾ പ്രശ്നം പരിഹരിക്കും, അതിലൂടെ ഒരു നിശ്ചിത സർക്കിൾ ആളുകൾക്ക് മാത്രമേ സ്മാർട്ട് കരാറിലേക്ക് സന്ദേശങ്ങൾ അയയ്ക്കാൻ കഴിയൂ.

ഡ്യൂപ്ലിക്കേറ്റ് സന്ദേശങ്ങൾ ഉപയോഗിച്ച് പ്രശ്നം പരിഹരിക്കാൻ വ്യത്യസ്ത മാർഗങ്ങളുണ്ട്. ഞങ്ങൾ അത് എങ്ങനെ ചെയ്യുമെന്ന് ഇതാ. സ്‌മാർട്ട് കരാറിൽ, ലഭിച്ച സന്ദേശങ്ങളുടെ കൗണ്ടർ ഞങ്ങൾ പ്രാരംഭ മൂല്യം 0 ഉപയോഗിച്ച് സമാരംഭിക്കുന്നു. സ്‌മാർട്ട് കരാറിലേക്കുള്ള ഓരോ സന്ദേശത്തിലും, ഞങ്ങൾ നിലവിലെ കൗണ്ടർ മൂല്യം ചേർക്കും. സന്ദേശത്തിലെ കൌണ്ടർ മൂല്യം സ്മാർട്ട് കരാറിലെ മൂല്യവുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, ഞങ്ങൾ അത് പ്രോസസ്സ് ചെയ്യുന്നില്ല; അങ്ങനെയാണെങ്കിൽ, ഞങ്ങൾ അത് പ്രോസസ്സ് ചെയ്യുകയും സ്മാർട്ട് കരാറിലെ കൗണ്ടർ 1 കൊണ്ട് വർദ്ധിപ്പിക്കുകയും ചെയ്യും.

നമുക്ക് മടങ്ങാം lottery-test-suite.fif അതിലേക്ക് രണ്ടാമത്തെ ടെസ്റ്റ് ചേർക്കുക. ഞങ്ങൾ ഒരു തെറ്റായ നമ്പർ അയച്ചാൽ, കോഡ് ഒരു ഒഴിവാക്കൽ നൽകണം. ഉദാഹരണത്തിന്, കരാർ ഡാറ്റ 166 സംഭരിക്കാൻ അനുവദിക്കുക, ഞങ്ങൾ 165 അയയ്ക്കും.

<b 166 32 u, b> storage !
<b 165 32 u, b> message !

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

drop 
exit_code ! 
."Exit code " exit_code @ . cr 
exit_code @ 33 - abort"Test #2 Not passed"

നമുക്ക് ലോഞ്ച് ചെയ്യാം.

 ~/TON/build/crypto/fift -s lottery-test-suite.fif 

കൂടാതെ, പരിശോധന ഒരു പിശക് ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നത് ഞങ്ങൾ കാണും.

[ 1][t 0][1582283084.210902214][words.cpp:3046] lottery-test-suite.fif:67: abort": Test #2 Not passed
[ 1][t 0][1582283084.210941076][fift-main.cpp:196]      Error interpreting file `lottery-test-suite.fif`: error interpreting included file `lottery-test-suite.fif` : lottery-test-suite.fif:67: abort": Test #2 Not passed

ഈ ഘട്ടത്തിൽ lottery-test-suite.fif പോലെ കാണണം ബന്ധം.

ഇനി സ്മാർട്ട് കരാറിലേക്ക് കൌണ്ടർ ലോജിക്ക് ചേർക്കാം lottery-code.fc.

() recv_internal(slice in_msg) impure {
    ;; TODO: implementation 
}

() recv_external(slice in_msg) impure {
    if (slice_empty?(in_msg)) {
        return (); 
    }
    int msg_seqno = in_msg~load_uint(32);
    var ds = begin_parse(get_data());
    int stored_seqno = ds~load_uint(32);
    throw_unless(33, msg_seqno == stored_seqno);
}

В slice in_msg ഞങ്ങൾ അയക്കുന്ന സന്ദേശം വ്യാജമാണ്.

ഞങ്ങൾ ആദ്യം ചെയ്യുന്നത് സന്ദേശത്തിൽ ഡാറ്റ ഉണ്ടോ എന്ന് പരിശോധിക്കുകയാണ്, ഇല്ലെങ്കിൽ, ഞങ്ങൾ പുറത്തുകടക്കുക.

അടുത്തതായി ഞങ്ങൾ സന്ദേശം പാഴ്‌സ് ചെയ്യുന്നു. in_msg~load_uint(32) നമ്പർ 165, 32-ബിറ്റ് ലോഡ് ചെയ്യുന്നു unsigned int കൈമാറിയ സന്ദേശത്തിൽ നിന്ന്.

അടുത്തതായി ഞങ്ങൾ സ്‌മാർട്ട് കോൺട്രാക്‌ട് സ്‌റ്റോറേജിൽ നിന്ന് 32 ബിറ്റുകൾ ലോഡ് ചെയ്യുന്നു. ലോഡുചെയ്‌ത നമ്പർ പാസാക്കിയ നമ്പറുമായി പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു; ഇല്ലെങ്കിൽ, ഞങ്ങൾ ഒരു ഒഴിവാക്കൽ നൽകുന്നു. ഞങ്ങളുടെ കാര്യത്തിൽ, ഞങ്ങൾ ഒരു നോൺ-മാച്ച് പാസ്സായതിനാൽ, ഒരു അപവാദം എറിയണം.

ഇനി നമുക്ക് സമാഹരിക്കാം.

~/TON/build/crypto/func -APSR -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc 

തത്ഫലമായുണ്ടാകുന്ന കോഡ് ഇതിലേക്ക് പകർത്തുക lottery-test-suite.fif, അവസാന വരി മാറ്റിസ്ഥാപിക്കാൻ മറക്കുന്നില്ല.

ടെസ്റ്റ് വിജയിച്ചിട്ടുണ്ടോയെന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു:

~/TON/build/crypto/fift -s lottery-test-suite.fif

ഇവിടെത്തന്നെ നിലവിലെ ഫലങ്ങൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് അനുബന്ധ പ്രതിബദ്ധത കാണാൻ കഴിയും.

ഒരു സ്‌മാർട്ട് കരാറിന്റെ കംപൈൽ ചെയ്‌ത കോഡ് ടെസ്റ്റുകളുള്ള ഒരു ഫയലിലേക്ക് നിരന്തരം പകർത്തുന്നത് അസൗകര്യമാണെന്ന കാര്യം ശ്രദ്ധിക്കുക, അതിനാൽ ഞങ്ങൾ ഒരു സ്‌ക്രിപ്റ്റ് എഴുതും, അത് ഞങ്ങൾക്കായി കോഡ് സ്ഥിരമായി എഴുതും, കൂടാതെ ഞങ്ങൾ കംപൈൽ ചെയ്‌ത കോഡ് ഉപയോഗിച്ച് ഞങ്ങളുടെ ടെസ്റ്റുകളിലേക്ക് കണക്റ്റുചെയ്യും. "include".

പ്രോജക്റ്റ് ഫോൾഡറിൽ ഒരു ഫയൽ സൃഷ്ടിക്കുക build.sh ഇനിപ്പറയുന്ന ഉള്ളടക്കത്തോടൊപ്പം.

#!/bin/bash

~/TON/build/crypto/func -SPA -R -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc

നമുക്ക് അത് എക്സിക്യൂട്ടബിൾ ആക്കാം.

chmod +x ./build.sh

ഇപ്പോൾ, കരാർ കംപൈൽ ചെയ്യാൻ ഞങ്ങളുടെ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുക. എന്നാൽ ഇതുകൂടാതെ, നമ്മൾ ഇത് ഒരു സ്ഥിരാങ്കത്തിലേക്ക് എഴുതേണ്ടതുണ്ട് code. അതിനാൽ ഞങ്ങൾ ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കും lotter-compiled-for-test.fif, ഞങ്ങൾ ഫയലിൽ ഉൾപ്പെടുത്തും lottery-test-suite.fif.

നമുക്ക് sh-ലേക്ക് സ്കിർപ്റ്റ് കോഡ് ചേർക്കാം, അത് കംപൈൽ ചെയ്ത ഫയലിനെ തനിപ്പകർപ്പാക്കും lotter-compiled-for-test.fif അതിലെ അവസാന വരി മാറ്റുകയും ചെയ്യുക.

# copy and change for test 
cp lottery-compiled.fif lottery-compiled-for-test.fif
sed '$d' lottery-compiled-for-test.fif > test.fif
rm lottery-compiled-for-test.fif
mv test.fif lottery-compiled-for-test.fif
echo -n "}END>s constant code" >> lottery-compiled-for-test.fif

ഇപ്പോൾ, പരിശോധിക്കാൻ, ഫലമായുണ്ടാകുന്ന സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാം, ഒരു ഫയൽ ജനറേറ്റുചെയ്യും lottery-compiled-for-test.fif, ഞങ്ങൾ അതിൽ ഉൾപ്പെടുത്തും lottery-test-suite.fif

В lottery-test-suite.fif കരാർ കോഡ് ഇല്ലാതാക്കി ലൈൻ ചേർക്കുക "lottery-compiled-for-test.fif" include.

അവർ വിജയിച്ചിട്ടുണ്ടോയെന്ന് പരിശോധിക്കാൻ ഞങ്ങൾ ടെസ്റ്റുകൾ നടത്തുന്നു.

~/TON/build/crypto/fift -s lottery-test-suite.fif

കൊള്ളാം, ഇപ്പോൾ ടെസ്റ്റുകളുടെ സമാരംഭം ഓട്ടോമേറ്റ് ചെയ്യാൻ, നമുക്ക് ഒരു ഫയൽ സൃഷ്ടിക്കാം test.sh, ഏത് ആദ്യം എക്സിക്യൂട്ട് ചെയ്യും build.sh, തുടർന്ന് ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുക.

touch test.sh
chmod +x test.sh

ഞങ്ങൾ ഉള്ളിൽ എഴുതുന്നു

./build.sh 

echo "nCompilation completedn"

export FIFTPATH=~/TON/ton/crypto/fift/lib
~/TON/build/crypto/fift -s lottery-test-suite.fif

നമുക്ക് ഇതുചെയ്യാം test.sh ടെസ്റ്റുകൾ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ അത് പ്രവർത്തിപ്പിക്കുക.

chmod +x ./test.sh
./test.sh

കരാർ കംപൈൽ ചെയ്യുകയും ടെസ്റ്റുകൾ നടപ്പിലാക്കുകയും ചെയ്തിട്ടുണ്ടോയെന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു.

കൊള്ളാം, ഇപ്പോൾ സ്റ്റാർട്ടപ്പിലാണ് test.sh പരിശോധനകൾ സമാഹരിച്ച് ഉടനടി പ്രവർത്തിപ്പിക്കും. ഇതിലേക്കുള്ള ലിങ്ക് ഇതാ പ്രതിബദ്ധത.

ശരി, തുടരുന്നതിന് മുമ്പ്, സൗകര്യാർത്ഥം ഒരു കാര്യം കൂടി ചെയ്യാം.

നമുക്ക് ഒരു ഫോൾഡർ ഉണ്ടാക്കാം build അവിടെ ഞങ്ങൾ പകർത്തിയ കരാറും അതിന്റെ ക്ലോണും ഒരു സ്ഥിരാങ്കത്തിൽ എഴുതി സൂക്ഷിക്കും lottery-compiled.fif, lottery-compiled-for-test.fif. നമുക്കും ഒരു ഫോൾഡർ ഉണ്ടാക്കാം test ടെസ്റ്റ് ഫയൽ എവിടെ സൂക്ഷിക്കും? lottery-test-suite.fif മറ്റ് പിന്തുണയ്ക്കുന്ന ഫയലുകളും. പ്രസക്തമായ മാറ്റങ്ങളിലേക്കുള്ള ലിങ്ക്.

സ്മാർട്ട് കരാർ വികസിപ്പിക്കുന്നത് തുടരാം.

അടുത്തതായി ഞങ്ങൾ ശരിയായ നമ്പർ അയയ്‌ക്കുമ്പോൾ സന്ദേശം ലഭിച്ചുവെന്നും സ്റ്റോറിൽ കൗണ്ടർ അപ്‌ഡേറ്റ് ചെയ്യപ്പെടുന്നുവെന്നും പരിശോധിക്കുന്ന ഒരു പരിശോധന ഉണ്ടായിരിക്കണം. എന്നാൽ ഞങ്ങൾ അത് പിന്നീട് ചെയ്യും.

സ്‌മാർട്ട് കരാറിൽ എന്ത് ഡാറ്റ ഘടനയെക്കുറിച്ചും എന്ത് ഡാറ്റയാണ് സൂക്ഷിക്കേണ്ടതെന്നും ഇപ്പോൾ നമുക്ക് ചിന്തിക്കാം.

ഞങ്ങൾ സംഭരിക്കുന്നതെല്ലാം ഞാൻ വിവരിക്കും.

`seqno` 32-х битное целое положительное число счетчик. 

`pubkey` 256-ти битное целое положительное число публичный ключ, с помощью которого, мы будем проверять подпись отправленного извне сообщения, о чем ниже. 

`order_seqno` 32-х битное целое положительное число хранит счетчик количества ставок. 

`number_of_wins` 32-х битное целое положительное число хранит  количество побед. 

`incoming_amount` тип данных Gram (первые 4 бита отвечает за длину), хранит общее количество грамов, которые были отправлены на контртакт. 

`outgoing_amount` общее количество грамов, которое было отправлено победителям. 

`owner_wc` номер воркчейна, 32-х битное (в некоторых местах написано, что 8-ми битное) целое число. В данный момент всего два -1 и 0. 

`owner_account_id` 256-ти битное целое положительное число, адрес контракта в текущем воркчейне. 

`orders` переменная типа словарь, хранит последние двадцать ставок. 

അടുത്തതായി നിങ്ങൾ രണ്ട് ഫംഗ്ഷനുകൾ എഴുതേണ്ടതുണ്ട്. ആദ്യം വിളിക്കാം pack_state(), ഇത് സ്‌മാർട്ട് കോൺട്രാക്‌ട് സ്‌റ്റോറേജിൽ തുടർന്നുള്ള ലാഭിക്കുന്നതിന് ഡാറ്റ പാക്ക് ചെയ്യും. നമുക്ക് രണ്ടാമത്തേത് വിളിക്കാം unpack_state() സ്റ്റോറേജിൽ നിന്ന് ഡാറ്റ വായിക്കുകയും തിരികെ നൽകുകയും ചെയ്യും.

_ pack_state(int seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) inline_ref {
    return begin_cell()
            .store_uint(seqno, 32)
            .store_uint(pubkey, 256)
            .store_uint(order_seqno, 32)
            .store_uint(number_of_wins, 32)
            .store_grams(incoming_amount)
            .store_grams(outgoing_amount)
            .store_int(owner_wc, 32)
            .store_uint(owner_account_id, 256)
            .store_dict(orders)
            .end_cell();
}

_ unpack_state() inline_ref {
    var ds = begin_parse(get_data());
    var unpacked = (ds~load_uint(32), ds~load_uint(256), ds~load_uint(32), ds~load_uint(32), ds~load_grams(), ds~load_grams(), ds~load_int(32), ds~load_uint(256), ds~load_dict());
    ds.end_parse();
    return unpacked;
}

സ്മാർട്ട് കരാറിന്റെ തുടക്കത്തിൽ ഞങ്ങൾ ഈ രണ്ട് ഫംഗ്ഷനുകൾ ചേർക്കുന്നു. അത് പ്രവർത്തിക്കും അത് പോലെ ഇന്റർമീഡിയറ്റ് ഫലം.

ഡാറ്റ സംരക്ഷിക്കാൻ നിങ്ങൾ ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനിലേക്ക് വിളിക്കേണ്ടതുണ്ട് set_data() എന്നതിൽ നിന്ന് ഡാറ്റ എഴുതുകയും ചെയ്യും pack_state() സ്മാർട്ട് കരാർ സംഭരണത്തിൽ.

cell packed_state = pack_state(arg_1, .., arg_n); 
set_data(packed_state);

ഇപ്പോൾ നമുക്ക് ഡാറ്റ എഴുതുന്നതിനും വായിക്കുന്നതിനും സൗകര്യപ്രദമായ പ്രവർത്തനങ്ങൾ ഉണ്ട്, നമുക്ക് മുന്നോട്ട് പോകാം.

പുറത്ത് നിന്ന് വരുന്ന സന്ദേശം കരാറിന്റെ ഉടമ (അല്ലെങ്കിൽ സ്വകാര്യ കീയിലേക്ക് ആക്‌സസ് ഉള്ള മറ്റൊരു ഉപയോക്താവ്) ഒപ്പിട്ടിട്ടുണ്ടോ എന്ന് പരിശോധിക്കേണ്ടതുണ്ട്.

ഞങ്ങൾ ഒരു സ്‌മാർട്ട് കരാർ പ്രസിദ്ധീകരിക്കുമ്പോൾ, സ്‌റ്റോറേജിൽ ആവശ്യമായ ഡാറ്റ ഉപയോഗിച്ച് അത് ആരംഭിക്കാം, അത് ഭാവിയിലെ ഉപയോഗത്തിനായി സംരക്ഷിക്കപ്പെടും. ഞങ്ങൾ അവിടെ പബ്ലിക് കീ റെക്കോർഡ് ചെയ്യും, അതുവഴി ഇൻകമിംഗ് സന്ദേശം അനുബന്ധ സ്വകാര്യ കീ ഉപയോഗിച്ചാണോ ഒപ്പിട്ടതെന്ന് പരിശോധിക്കാൻ കഴിയും.

തുടരുന്നതിന് മുമ്പ്, നമുക്ക് ഒരു സ്വകാര്യ കീ സൃഷ്ടിച്ച് അത് എഴുതാം test/keys/owner.pk. ഇത് ചെയ്യുന്നതിന്, നമുക്ക് ഇന്ററാക്ടീവ് മോഡിൽ ഫിഫ്റ്റ് സമാരംഭിച്ച് നാല് കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യാം.

`newkeypair` генерация публичного и приватного ключа и запись их в стек. 

`drop` удаления из стека верхнего элемента (в данном случае публичный ключ)  

`.s` просто посмотреть что лежит в стеке в данный момент 

`"owner.pk" B>file` запись приватного ключа в файл с именем `owner.pk`. 

`bye` завершает работу с Fift. 

നമുക്ക് ഒരു ഫോൾഡർ ഉണ്ടാക്കാം keys ഫോൾഡറിനുള്ളിൽ test അവിടെ പ്രൈവറ്റ് കീ എഴുതുക.

mkdir test/keys
cd test/keys
~/TON/build/crypto/fift -i 
newkeypair
 ok
.s 
BYTES:128DB222CEB6CF5722021C3F21D4DF391CE6D5F70C874097E28D06FCE9FD6917 BYTES:DD0A81AAF5C07AAAA0C7772BB274E494E93BB0123AA1B29ECE7D42AE45184128 
drop 
 ok
"owner.pk" B>file
 ok
bye

നിലവിലെ ഫോൾഡറിൽ ഞങ്ങൾ ഒരു ഫയൽ കാണുന്നു owner.pk.

ഞങ്ങൾ പബ്ലിക് കീ സ്റ്റാക്കിൽ നിന്ന് നീക്കം ചെയ്യുന്നു, ആവശ്യമുള്ളപ്പോൾ നമുക്ക് അത് സ്വകാര്യത്തിൽ നിന്ന് ലഭിക്കും.

ഇനി ഒരു ഒപ്പ് വെരിഫിക്കേഷൻ എഴുതണം. നമുക്ക് പരീക്ഷയിൽ നിന്ന് ആരംഭിക്കാം. ആദ്യം നമ്മൾ ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഫയലിൽ നിന്ന് സ്വകാര്യ കീ വായിക്കുന്നു file>B ഒരു വേരിയബിളിൽ എഴുതുക owner_private_key, തുടർന്ന് ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു priv>pub പ്രൈവറ്റ് കീ ഒരു പബ്ലിക് കീ ആയി പരിവർത്തനം ചെയ്ത് ഫലം എഴുതുക owner_public_key.

variable owner_private_key
variable owner_public_key 

"./keys/owner.pk" file>B owner_private_key !
owner_private_key @ priv>pub owner_public_key !

ഞങ്ങൾക്ക് രണ്ട് കീകളും ആവശ്യമാണ്.

ഫംഗ്‌ഷനിലെ അതേ ശ്രേണിയിൽ അനിയന്ത്രിതമായ ഡാറ്റ ഉപയോഗിച്ച് ഞങ്ങൾ സ്‌മാർട്ട് കോൺട്രാക്‌റ്റ് സ്‌റ്റോറേജ് ആരംഭിക്കുന്നു pack_state()ഒരു വേരിയബിളിൽ എഴുതുക storage.

variable owner_private_key
variable owner_public_key 
variable orders
variable owner_wc
variable owner_account_id

"./keys/owner.pk" file>B owner_private_key !
owner_private_key @ priv>pub owner_public_key !
dictnew orders !
0 owner_wc !
0 owner_account_id !

<b 0 32 u, owner_public_key @ B, 0 32 u, 0 32 u, 0 Gram, 0 Gram, owner_wc @ 32 i, owner_account_id @ 256 u,  orders @ dict, b> storage !

അടുത്തതായി, ഞങ്ങൾ ഒപ്പിട്ട സന്ദേശം രചിക്കും, അതിൽ ഒപ്പും കൌണ്ടർ മൂല്യവും മാത്രമേ അടങ്ങിയിരിക്കൂ.

ആദ്യം, ഞങ്ങൾ കൈമാറാൻ ആഗ്രഹിക്കുന്ന ഡാറ്റ ഞങ്ങൾ സൃഷ്ടിക്കുന്നു, തുടർന്ന് ഞങ്ങൾ അത് ഒരു സ്വകാര്യ കീ ഉപയോഗിച്ച് ഒപ്പിടുന്നു, ഒടുവിൽ ഞങ്ങൾ ഒപ്പിട്ട സന്ദേശം സൃഷ്ടിക്കുന്നു.

variable message_to_sign
variable message_to_send
variable signature
<b 0 32 u, b> message_to_sign !
message_to_sign @ hashu owner_private_key @ ed25519_sign_uint signature !
<b signature @ B, 0 32 u, b> <s  message_to_send !  

തൽഫലമായി, ഞങ്ങൾ സ്മാർട്ട് കരാറിലേക്ക് അയയ്ക്കുന്ന സന്ദേശം ഒരു വേരിയബിളിൽ രേഖപ്പെടുത്തുന്നു message_to_send, പ്രവർത്തനങ്ങളെക്കുറിച്ച് hashu, ed25519_sign_uint നിങ്ങൾക്ക് വായിക്കാം അഞ്ചാമത്തെ ഡോക്യുമെന്റേഷനിൽ.

ടെസ്റ്റ് നടത്താൻ ഞങ്ങൾ വീണ്ടും വിളിക്കുന്നു.

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

ഇതുപോലെ ഈ ഘട്ടത്തിൽ ടെസ്റ്റുകളുള്ള ഫയൽ ഇതുപോലെയായിരിക്കണം.

നമുക്ക് ടെസ്റ്റ് നടത്താം, അത് പരാജയപ്പെടും, അതിനാൽ ഈ ഫോർമാറ്റിന്റെ സന്ദേശങ്ങൾ സ്വീകരിക്കാനും ഒപ്പ് പരിശോധിക്കാനും കഴിയുന്ന തരത്തിൽ ഞങ്ങൾ സ്മാർട്ട് കരാർ മാറ്റും.

ആദ്യം, ഞങ്ങൾ സന്ദേശത്തിൽ നിന്ന് ഒപ്പിന്റെ 512 ബിറ്റുകൾ എണ്ണുകയും ഒരു വേരിയബിളിലേക്ക് എഴുതുകയും ചെയ്യുന്നു, തുടർന്ന് ഞങ്ങൾ കൗണ്ടർ വേരിയബിളിന്റെ 32 ബിറ്റുകൾ കണക്കാക്കുന്നു.

സ്‌മാർട്ട് കോൺട്രാക്‌ട് സ്‌റ്റോറേജിൽ നിന്ന് ഡാറ്റ റീഡുചെയ്യുന്നതിനുള്ള ഒരു ഫംഗ്‌ഷൻ ഉള്ളതിനാൽ, ഞങ്ങൾ അത് ഉപയോഗിക്കും.

അടുത്തത് സ്റ്റോറേജ് ഉപയോഗിച്ച് കൈമാറ്റം ചെയ്ത കൗണ്ടർ പരിശോധിക്കുകയും ഒപ്പ് പരിശോധിക്കുകയും ചെയ്യുന്നു. എന്തെങ്കിലും പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, ഉചിതമായ കോഡ് ഉപയോഗിച്ച് ഞങ്ങൾ ഒരു ഒഴിവാക്കൽ ഇടുന്നു.

var signature = in_msg~load_bits(512);
var message = in_msg;
int msg_seqno = message~load_uint(32);
(int stored_seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) = unpack_state();
throw_unless(33, msg_seqno == stored_seqno);
throw_unless(34, check_signature(slice_hash(in_msg), signature, pubkey));

പ്രസക്തമായ പ്രതിബദ്ധത ഇവിടെ ഇതാ.

നമുക്ക് ടെസ്റ്റുകൾ നടത്തി രണ്ടാമത്തെ ടെസ്റ്റ് പരാജയപ്പെടുമെന്ന് നോക്കാം. രണ്ട് കാരണങ്ങളാൽ, സന്ദേശത്തിൽ മതിയായ ബിറ്റുകൾ ഇല്ല, സംഭരണത്തിൽ മതിയായ ബിറ്റുകൾ ഇല്ല, അതിനാൽ പാഴ്‌സ് ചെയ്യുമ്പോൾ കോഡ് ക്രാഷ് ചെയ്യുന്നു. നമ്മൾ അയക്കുന്ന സന്ദേശത്തിൽ ഒരു ഒപ്പ് ചേർക്കുകയും അവസാനത്തെ ടെസ്റ്റിൽ നിന്ന് സ്റ്റോറേജ് പകർത്തുകയും വേണം.

രണ്ടാമത്തെ ടെസ്റ്റിൽ, ഞങ്ങൾ ഒരു സന്ദേശ ഒപ്പ് ചേർക്കുകയും സ്‌മാർട്ട് കരാർ സംഭരണം മാറ്റുകയും ചെയ്യും. ഇതുപോലെ ടെസ്റ്റുകളുള്ള ഫയൽ ഇപ്പോൾ പോലെ കാണപ്പെടുന്നു.

നമുക്ക് നാലാമത്തെ പരീക്ഷ എഴുതാം, അതിൽ മറ്റൊരാളുടെ സ്വകാര്യ കീ ഉപയോഗിച്ച് ഒപ്പിട്ട ഒരു സന്ദേശം ഞങ്ങൾ അയയ്ക്കും. നമുക്ക് മറ്റൊരു സ്വകാര്യ കീ സൃഷ്ടിച്ച് ഒരു ഫയലിൽ സേവ് ചെയ്യാം not-owner.pk. ഈ സ്വകാര്യ കീ ഉപയോഗിച്ച് ഞങ്ങൾ സന്ദേശത്തിൽ ഒപ്പിടും. നമുക്ക് ടെസ്റ്റുകൾ നടത്തി എല്ലാ ടെസ്റ്റുകളും വിജയിച്ചെന്ന് ഉറപ്പാക്കാം. പ്രതിബദ്ധത ഈ നിമിഷം.

ഇപ്പോൾ നമുക്ക് സ്‌മാർട്ട് കരാർ ലോജിക് നടപ്പിലാക്കുന്നതിലേക്ക് പോകാം.
В recv_external() ഞങ്ങൾ രണ്ട് തരത്തിലുള്ള സന്ദേശങ്ങൾ സ്വീകരിക്കും.

ഞങ്ങളുടെ കരാർ കളിക്കാരുടെ നഷ്ടം കുമിഞ്ഞുകൂടുമെന്നതിനാൽ, ഈ പണം ലോട്ടറിയുടെ സ്രഷ്ടാവിന് കൈമാറണം. കരാർ ഉണ്ടാക്കുമ്പോൾ ലോട്ടറി സ്രഷ്ടാവിന്റെ വാലറ്റ് വിലാസം സ്റ്റോറേജിൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്.

നഷ്ടമായവരുടെ ഗ്രാം അയക്കുന്ന വിലാസം മാറ്റാനുള്ള കഴിവ് ഞങ്ങൾക്ക് ആവശ്യമാണ്. ലോട്ടറിയിൽ നിന്ന് ഉടമയുടെ വിലാസത്തിലേക്ക് ഗ്രാം അയയ്ക്കാനും ഞങ്ങൾക്ക് കഴിയണം.

ആദ്യത്തേതിൽ നിന്ന് തുടങ്ങാം. സന്ദേശം അയച്ചതിന് ശേഷം, സ്മാർട്ട് കരാർ പുതിയ വിലാസം സ്റ്റോറേജിൽ സംരക്ഷിച്ചിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്ന ഒരു ടെസ്റ്റ് നമുക്ക് ആദ്യം എഴുതാം. സന്ദേശത്തിൽ, കൗണ്ടറിനും പുതിയ വിലാസത്തിനും പുറമേ, ഞങ്ങളും ട്രാൻസ്മിറ്റ് ചെയ്യുന്നു എന്നത് ശ്രദ്ധിക്കുക action ഒരു 7-ബിറ്റ് പൂർണ്ണസംഖ്യ നോൺ-നെഗറ്റീവ് നമ്പർ, അതിനെ ആശ്രയിച്ച്, സ്മാർട്ട് കരാറിൽ സന്ദേശം എങ്ങനെ പ്രോസസ്സ് ചെയ്യണമെന്ന് ഞങ്ങൾ തിരഞ്ഞെടുക്കും.

<b 0 32 u, 1 @ 7 u, new_owner_wc @  32 i, new_owner_account_id @ 256 u, b> message_to_sign !

സ്‌മാർട്ട് കോൺട്രാക്‌ട് സ്‌റ്റോറേജ് എങ്ങനെയാണ് ഡീസീരിയലൈസ് ചെയ്‌തതെന്ന് ടെസ്റ്റിൽ നിങ്ങൾക്ക് കാണാൻ കഴിയും storage അഞ്ചിൽ. വേരിയബിളുകളുടെ ഡീസീരിയലൈസേഷൻ ഫിഫ്റ്റ് ഡോക്യുമെന്റേഷനിൽ വിവരിച്ചിരിക്കുന്നു.

കമ്മിറ്റ് ലിങ്ക് ചേർത്ത മാവ് കൊണ്ട്.

നമുക്ക് ടെസ്റ്റ് നടത്തി അത് പരാജയമാണെന്ന് ഉറപ്പാക്കാം. ഇനി ലോട്ടറി ഉടമയുടെ വിലാസം മാറ്റാൻ ലോജിക് ചേർക്കാം.

സ്മാർട്ട് കരാറിൽ ഞങ്ങൾ പാഴ്സ് ചെയ്യുന്നത് തുടരുന്നു message, വായിക്കുക action. നമുക്ക് രണ്ടെണ്ണം ഉണ്ടാകുമെന്ന് ഓർമ്മിപ്പിക്കാം action: വിലാസം മാറ്റി ഗ്രാം അയയ്ക്കുക.

അതിനുശേഷം ഞങ്ങൾ കരാർ ഉടമയുടെ പുതിയ വിലാസം വായിക്കുകയും സ്റ്റോറേജിൽ സംരക്ഷിക്കുകയും ചെയ്യുന്നു.
ഞങ്ങൾ ടെസ്റ്റുകൾ നടത്തുകയും മൂന്നാമത്തെ ടെസ്റ്റ് പരാജയപ്പെടുകയും ചെയ്യുന്നു. ടെസ്റ്റിൽ നഷ്‌ടമായ സന്ദേശത്തിൽ നിന്ന് കരാർ ഇപ്പോൾ അധികമായി 7 ബിറ്റുകൾ പാഴ്‌സ് ചെയ്യുന്നതിനാൽ ഇത് ക്രാഷ് ചെയ്യുന്നു. സന്ദേശത്തിൽ നിലവിലില്ലാത്ത ഒന്ന് ചേർക്കുക action. നമുക്ക് ടെസ്റ്റുകൾ നടത്തി എല്ലാം കടന്നുപോകുമെന്ന് നോക്കാം. ഇവിടെ മാറ്റങ്ങൾക്ക് പ്രതിജ്ഞാബദ്ധമാണ്. കൊള്ളാം.

മുമ്പ് സേവ് ചെയ്ത വിലാസത്തിലേക്ക് നിർദ്ദിഷ്ട എണ്ണം ഗ്രാമുകൾ അയയ്ക്കുന്നതിനുള്ള യുക്തി ഇപ്പോൾ എഴുതാം.

ആദ്യം നമുക്ക് ഒരു പരീക്ഷ എഴുതാം. ഞങ്ങൾ രണ്ട് ടെസ്റ്റുകൾ എഴുതും, ഒന്ന് മതിയായ ബാലൻസ് ഇല്ലെങ്കിൽ, രണ്ടാമത്തേത് എല്ലാം വിജയകരമായി കടന്നുപോകുമ്പോൾ. ടെസ്റ്റുകൾ കാണാൻ കഴിയും ഈ പ്രതിബദ്ധതയിൽ.

ഇനി നമുക്ക് കോഡ് ചേർക്കാം. ആദ്യം, നമുക്ക് രണ്ട് സഹായ രീതികൾ എഴുതാം. ഒരു സ്‌മാർട്ട് കരാറിന്റെ നിലവിലെ ബാലൻസ് കണ്ടെത്തുക എന്നതാണ് ആദ്യത്തെ ഗെറ്റ് രീതി.

int balance() inline_ref method_id {
    return get_balance().pair_first();
}

രണ്ടാമത്തേത് മറ്റൊരു സ്മാർട്ട് കരാറിലേക്ക് ഗ്രാം അയയ്ക്കുന്നതിനുള്ളതാണ്. മറ്റൊരു സ്മാർട്ട് കരാറിൽ നിന്ന് ഞാൻ ഈ രീതി പൂർണ്ണമായും പകർത്തി.

() send_grams(int wc, int addr, int grams) impure {
    ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 011000
    cell msg = begin_cell()
    ;;  .store_uint(0, 1) ;; 0 <= format indicator int_msg_info$0 
    ;;  .store_uint(1, 1) ;; 1 <= ihr disabled
    ;;  .store_uint(1, 1) ;; 1 <= bounce = true
    ;;  .store_uint(0, 1) ;; 0 <= bounced = false
    ;;  .store_uint(4, 5)  ;; 00100 <= address flags, anycast = false, 8-bit workchain
        .store_uint (196, 9)
        .store_int(wc, 8)
        .store_uint(addr, 256)
        .store_grams(grams)
        .store_uint(0, 107) ;; 106 zeroes +  0 as an indicator that there is no cell with the data.
        .end_cell(); 
    send_raw_message(msg, 3); ;; mode, 2 for ignoring errors, 1 for sender pays fees, 64 for returning inbound message value
}

ഈ രണ്ട് രീതികളും സ്മാർട്ട് കരാറിൽ ചേർത്ത് യുക്തി എഴുതാം. ആദ്യം, സന്ദേശത്തിൽ നിന്നുള്ള ഗ്രാമുകളുടെ എണ്ണം ഞങ്ങൾ പാഴ്സ് ചെയ്യുന്നു. അടുത്തതായി ഞങ്ങൾ ബാലൻസ് പരിശോധിക്കുന്നു, അത് പര്യാപ്തമല്ലെങ്കിൽ ഞങ്ങൾ ഒരു ഒഴിവാക്കൽ ഇടുന്നു. എല്ലാം ശരിയാണെങ്കിൽ, ഞങ്ങൾ സേവ് ചെയ്ത വിലാസത്തിലേക്ക് ഗ്രാം അയച്ച് കൌണ്ടർ അപ്ഡേറ്റ് ചെയ്യുക.

int amount_to_send = message~load_grams();
throw_if(36, amount_to_send + 500000000 > balance());
accept_message();
send_grams(owner_wc, owner_account_id, amount_to_send);
set_data(pack_state(stored_seqno + 1, pubkey, order_seqno, number_of_wins, incoming_amount, outgoing_amount, owner_wc, owner_account_id, orders));

ഇതുപോലെ ഇപ്പോൾ മികച്ച കരാർ പോലെ തോന്നുന്നു. നമുക്ക് ടെസ്റ്റുകൾ നടത്തി അവർ വിജയിക്കുന്നുവെന്ന് ഉറപ്പാക്കാം.

വഴിയിൽ, ഒരു പ്രോസസ്സ് ചെയ്ത സന്ദേശത്തിനായി ഓരോ തവണയും സ്മാർട്ട് കരാറിൽ നിന്ന് ഒരു കമ്മീഷൻ കുറയ്ക്കുന്നു. സ്‌മാർട്ട് കരാർ സന്ദേശങ്ങൾ അഭ്യർത്ഥന നടപ്പിലാക്കുന്നതിന്, അടിസ്ഥാന പരിശോധനകൾക്ക് ശേഷം നിങ്ങൾ വിളിക്കേണ്ടതുണ്ട് accept_message().

ഇനി നമുക്ക് ആന്തരിക സന്ദേശങ്ങളിലേക്ക് പോകാം. വാസ്തവത്തിൽ, ഞങ്ങൾ ഗ്രാം മാത്രം സ്വീകരിക്കുകയും കളിക്കാരൻ വിജയിച്ചാൽ ഇരട്ടി തുകയും തോറ്റാൽ മൂന്നിലൊന്ന് ഉടമയ്ക്ക് തിരികെ അയയ്ക്കുകയും ചെയ്യും.

ആദ്യം, നമുക്ക് ഒരു ലളിതമായ പരീക്ഷ എഴുതാം. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾക്ക് സ്മാർട്ട് കരാറിന്റെ ഒരു ടെസ്റ്റ് വിലാസം ആവശ്യമാണ്, അതിൽ നിന്ന് ഞങ്ങൾ സ്മാർട്ട് കരാറിലേക്ക് ഗ്രാം അയയ്ക്കുന്നു.

സ്‌മാർട്ട് കോൺട്രാക്‌ട് വിലാസത്തിൽ രണ്ട് സംഖ്യകൾ അടങ്ങിയിരിക്കുന്നു, വർക്ക്‌ചെയിനിന്റെ ഉത്തരവാദിത്തമുള്ള 32-ബിറ്റ് പൂർണ്ണസംഖ്യയും ഈ വർക്ക്ചെയിനിലെ 256-ബിറ്റ് നോൺ-നെഗറ്റീവ് ഇന്റിജർ അദ്വിതീയ അക്കൗണ്ട് നമ്പറും. ഉദാഹരണത്തിന്, -1, 12345, ഇതാണ് ഞങ്ങൾ ഒരു ഫയലിലേക്ക് സംരക്ഷിക്കുന്ന വിലാസം.

വിലാസം സംരക്ഷിക്കുന്നതിനുള്ള പ്രവർത്തനം ഞാൻ പകർത്തി TonUtil.fif.

// ( wc addr fname -- )  Save address to file in 36-byte format
{ -rot 256 u>B swap 32 i>B B+ swap B>file } : save-address

ഫംഗ്ഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നോക്കാം, ഇത് ഫിഫ്റ്റ് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ച് ഒരു ധാരണ നൽകും. ഇന്ററാക്ടീവ് മോഡിൽ ഫിഫ്റ്റ് സമാരംഭിക്കുക.

~/TON/build/crypto/fift -i 

ആദ്യം നമ്മൾ -1, 12345, ഭാവി ഫയലിന്റെ പേര് "sender.addr" എന്നിവ സ്റ്റാക്കിലേക്ക് തള്ളുന്നു:

-1 12345 "sender.addr" 

അടുത്ത ഘട്ടം ഫംഗ്ഷൻ എക്സിക്യൂട്ട് ചെയ്യുക എന്നതാണ് -rot, ഇത് സ്റ്റാക്കിന്റെ മുകളിൽ ഒരു അദ്വിതീയ സ്‌മാർട്ട് കോൺട്രാക്റ്റ് നമ്പർ ഉള്ള തരത്തിൽ സ്റ്റാക്ക് മാറ്റുന്നു:

"sender.addr" -1 12345

256 u>B 256-ബിറ്റ് നോൺ-നെഗറ്റീവ് പൂർണ്ണസംഖ്യയെ ബൈറ്റുകളാക്കി മാറ്റുന്നു.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap സ്റ്റാക്കിന്റെ മുകളിലെ രണ്ട് ഘടകങ്ങൾ സ്വാപ്പ് ചെയ്യുന്നു.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B 32-ബിറ്റ് പൂർണ്ണസംഖ്യയെ ബൈറ്റുകളാക്കി മാറ്റുന്നു.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ ബൈറ്റുകളുടെ രണ്ട് സീക്വൻസുകൾ ബന്ധിപ്പിക്കുന്നു.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

വീണ്ടും swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

ഒടുവിൽ ബൈറ്റുകൾ ഫയലിൽ എഴുതുന്നു B>file. ഇതിനുശേഷം ഞങ്ങളുടെ സ്റ്റാക്ക് ശൂന്യമാണ്. ഞങ്ങൾ നിർത്തുന്നു Fift. നിലവിലെ ഫോൾഡറിൽ ഒരു ഫയൽ സൃഷ്ടിച്ചു sender.addr. സൃഷ്ടിച്ച ഫോൾഡറിലേക്ക് ഫയൽ നീക്കാം test/addresses/.

ഒരു സ്‌മാർട്ട് കോൺട്രാക്‌റ്റിലേക്ക് ഗ്രാം അയയ്‌ക്കുന്ന ഒരു ലളിതമായ പരീക്ഷ എഴുതാം. പ്രതിബദ്ധത ഇതാ.

ഇനി ലോട്ടറിയുടെ യുക്തി നോക്കാം.

ഞങ്ങൾ ആദ്യം ചെയ്യേണ്ടത് സന്ദേശം പരിശോധിക്കുകയാണ് bounced അല്ലെങ്കിൽ ഇല്ലെങ്കിൽ bounced, അപ്പോൾ ഞങ്ങൾ അത് അവഗണിക്കുന്നു. bounced എന്തെങ്കിലും പിശക് സംഭവിച്ചാൽ കരാർ ഗ്രാം തിരികെ നൽകും എന്നാണ്. പെട്ടെന്ന് ഒരു പിശക് സംഭവിച്ചാൽ ഞങ്ങൾ ഗ്രാം തിരികെ നൽകില്ല.

ഞങ്ങൾ പരിശോധിക്കുന്നു, ബാലൻസ് അര ഗ്രാമിൽ കുറവാണെങ്കിൽ, ഞങ്ങൾ സന്ദേശം സ്വീകരിക്കുകയും അവഗണിക്കുകയും ചെയ്യുന്നു.

അടുത്തതായി, സന്ദേശം വന്ന സ്മാർട്ട് കരാറിന്റെ വിലാസം ഞങ്ങൾ പാഴ്‌സ് ചെയ്യുന്നു.

ഞങ്ങൾ സ്റ്റോറേജിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുകയും, അവയിൽ ഇരുപതിൽ കൂടുതൽ ഉണ്ടെങ്കിൽ ചരിത്രത്തിൽ നിന്ന് പഴയ പന്തയങ്ങൾ ഇല്ലാതാക്കുകയും ചെയ്യും. സൗകര്യാർത്ഥം, ഞാൻ മൂന്ന് അധിക ഫംഗ്ഷനുകൾ എഴുതി pack_order(), unpack_order(), remove_old_orders().

അടുത്തതായി, പേയ്‌മെന്റിന് ബാലൻസ് പര്യാപ്തമല്ലെങ്കിൽ ഞങ്ങൾ നോക്കുന്നു, ഇത് ഒരു പന്തയമല്ല, മറിച്ച് ഒരു നികത്തലാണെന്ന് ഞങ്ങൾ കണക്കാക്കുകയും വീണ്ടും നിറയ്ക്കുകയും ചെയ്യുന്നു orders.

പിന്നെ ഒടുവിൽ സ്മാർട്ട് കരാറിന്റെ സാരാംശം.

ആദ്യം, കളിക്കാരൻ തോറ്റാൽ, ഞങ്ങൾ അത് വാതുവെപ്പ് ചരിത്രത്തിൽ സംരക്ഷിക്കുകയും തുക 3 ഗ്രാമിൽ കൂടുതലാണെങ്കിൽ, സ്മാർട്ട് കരാറിന്റെ ഉടമയ്ക്ക് ഞങ്ങൾ 1/3 അയയ്ക്കുകയും ചെയ്യും.

കളിക്കാരൻ വിജയിക്കുകയാണെങ്കിൽ, ഞങ്ങൾ കളിക്കാരന്റെ വിലാസത്തിലേക്ക് ഇരട്ടി തുക അയയ്ക്കുകയും ചരിത്രത്തിൽ പന്തയത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ സംരക്ഷിക്കുകയും ചെയ്യും.

() recv_internal(int order_amount, cell in_msg_cell, slice in_msg) impure {
    var cs = in_msg_cell.begin_parse();
    int flags = cs~load_uint(4);  ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
    if (flags & 1) { ;; ignore bounced
        return ();
    }
    if (order_amount < 500000000) { ;; just receive grams without changing state 
        return ();
    }
    slice src_addr_slice = cs~load_msg_addr();
    (int src_wc, int src_addr) = parse_std_addr(src_addr_slice);
    (int stored_seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) = unpack_state();
    orders = remove_old_orders(orders, order_seqno);
    if (balance() < 2 * order_amount + 500000000) { ;; not enough grams to pay the bet back, so this is re-fill
        builder order = pack_order(order_seqno, 1, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        return ();
    }
    if (rand(10) >= 4) {
        builder order = pack_order(order_seqno, 3, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        if (order_amount > 3000000000) {
            send_grams(owner_wc, owner_account_id, order_amount / 3);
        }
        return ();
    }
    send_grams(src_wc, src_addr, 2 * order_amount);
    builder order = pack_order(order_seqno, 2, now(), order_amount, src_wc, src_addr);
    orders~udict_set_builder(32, order_seqno, order);
    set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins + 1, incoming_amount, outgoing_amount + 2 * order_amount, owner_wc, owner_account_id, orders));
}

അത്രമാത്രം. അനുബന്ധ പ്രതിബദ്ധത.

ഇപ്പോൾ അവശേഷിക്കുന്നതെല്ലാം ലളിതമാണ്, നമുക്ക് ഗെറ്റ്-മെത്തഡുകൾ സൃഷ്ടിക്കാം, അതുവഴി പുറം ലോകത്തിൽ നിന്ന് കരാറിന്റെ അവസ്ഥയെക്കുറിച്ചുള്ള വിവരങ്ങൾ നമുക്ക് ലഭിക്കും (വാസ്തവത്തിൽ, അവരുടെ സ്മാർട്ട് കരാർ സംഭരണത്തിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുക).

നമുക്ക് നേടുന്ന രീതികൾ ചേർക്കാം. ഒരു മികച്ച കരാറിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ എങ്ങനെ സ്വീകരിക്കാം എന്നതിനെക്കുറിച്ച് ഞങ്ങൾ ചുവടെ എഴുതും.

ഒരു സ്‌മാർട്ട് കരാർ പ്രസിദ്ധീകരിക്കുമ്പോൾ സംഭവിക്കുന്ന ആദ്യത്തെ അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യുന്ന കോഡ് ചേർക്കാനും ഞാൻ മറന്നു. അനുബന്ധ പ്രതിബദ്ധത. കൂടാതെ കൂടുതൽ തിരുത്തി തുകയുടെ 1/3 ഭാഗം ഉടമയുടെ അക്കൗണ്ടിലേക്ക് അയക്കുന്നതിലെ ബഗ്.

അടുത്ത ഘട്ടം സ്മാർട്ട് കരാർ പ്രസിദ്ധീകരിക്കുക എന്നതാണ്. നമുക്ക് ഒരു ഫോൾഡർ ഉണ്ടാക്കാം requests.

ഞാൻ പ്രസിദ്ധീകരണ കോഡ് ഒരു അടിസ്ഥാനമായി എടുത്തു simple-wallet-code.fc ഏത് കണ്ടെത്താനാകും ഔദ്യോഗിക സംഭരണിയിൽ.

ശ്രദ്ധിക്കേണ്ട കാര്യം. ഞങ്ങൾ ഒരു മികച്ച കരാർ സംഭരണവും ഒരു ഇൻപുട്ട് സന്ദേശവും സൃഷ്ടിക്കുന്നു. ഇതിനുശേഷം, സ്മാർട്ട് കരാറിന്റെ വിലാസം ജനറേറ്റുചെയ്യുന്നു, അതായത്, TON-ൽ പ്രസിദ്ധീകരിക്കുന്നതിന് മുമ്പുതന്നെ വിലാസം അറിയപ്പെടുന്നു. അടുത്തതായി, നിങ്ങൾ ഈ വിലാസത്തിലേക്ക് നിരവധി ഗ്രാം അയയ്‌ക്കേണ്ടതുണ്ട്, അതിനുശേഷം മാത്രമേ സ്‌മാർട്ട് കരാറുമായി തന്നെ ഒരു ഫയൽ അയയ്‌ക്കേണ്ടതുള്ളൂ, കാരണം സ്‌മാർട്ട് കരാറും അതിലെ പ്രവർത്തനങ്ങളും സംഭരിക്കുന്നതിന് നെറ്റ്‌വർക്ക് ഒരു കമ്മീഷൻ എടുക്കുന്നു (സ്മാർട്ട് സംഭരിക്കുകയും നിർവ്വഹിക്കുകയും ചെയ്യുന്ന വാലിഡേറ്റർമാർ. കരാറുകൾ). കോഡ് ഇവിടെ കാണാം.

അടുത്തതായി ഞങ്ങൾ പബ്ലിഷിംഗ് കോഡ് എക്സിക്യൂട്ട് ചെയ്യുകയും നേടുകയും ചെയ്യുന്നു lottery-query.boc സ്മാർട്ട് കരാർ ഫയലും വിലാസവും.

~/TON/build/crypto/fift -s requests/new-lottery.fif 0

സൃഷ്ടിച്ച ഫയലുകൾ സംരക്ഷിക്കാൻ മറക്കരുത്: lottery-query.boc, lottery.addr, lottery.pk.

മറ്റ് കാര്യങ്ങൾക്കൊപ്പം, എക്സിക്യൂഷൻ ലോഗുകളിൽ സ്മാർട്ട് കരാറിന്റെ വിലാസം ഞങ്ങൾ കാണും.

new wallet address = 0:044910149dbeaf8eadbb2b28722e7d6a2dc6e264ec2f1d9bebd6fb209079bc2a 
(Saving address to file lottery.addr)
Non-bounceable address (for init): 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd
Bounceable address (for later access): kQAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8KpFY

തമാശയ്ക്ക്, നമുക്ക് TON-നോട് ഒരു അഭ്യർത്ഥന നടത്താം

$ ./lite-client/lite-client -C ton-lite-client-test1.config.json 
getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ഈ വിലാസമുള്ള അക്കൗണ്ട് ശൂന്യമാണെന്ന് നമുക്ക് കാണാം.

account state is empty

ഞങ്ങൾ വിലാസത്തിലേക്ക് അയയ്ക്കുന്നു 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 ഗ്രാം, കുറച്ച് സെക്കൻഡുകൾക്ക് ശേഷം ഞങ്ങൾ അതേ കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഗ്രാം അയയ്ക്കാൻ ഞാൻ ഉപയോഗിക്കുന്നു ഔദ്യോഗിക വാലറ്റ്, കൂടാതെ നിങ്ങൾക്ക് ചാറ്റിൽ നിന്ന് ആരോടെങ്കിലും ടെസ്റ്റ് ഗ്രാം ആവശ്യപ്പെടാം, അത് ഞാൻ ലേഖനത്തിന്റെ അവസാനം സംസാരിക്കും.

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ആരംഭിക്കാത്തത് പോലെ തോന്നുന്നു (state:account_uninit) ഒരേ വിലാസവും 1 നാനോഗ്രാമുകളുമുള്ള ഒരു മികച്ച കരാർ.

account state is (account
  addr:(addr_std
    anycast:nothing workchain_id:0 address:x044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A)
  storage_stat:(storage_info
    used:(storage_used
      cells:(var_uint len:1 value:1)
      bits:(var_uint len:1 value:103)
      public_cells:(var_uint len:0 value:0)) last_paid:1583257959
    due_payment:nothing)
  storage:(account_storage last_trans_lt:3825478000002
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:4 value:2000000000))
      other:(extra_currencies
        dict:hme_empty))
    state:account_uninit))
x{C00044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A20259C2F2F4CB3800000DEAC10776091DCD650004_}
last transaction lt = 3825478000001 hash = B043616AE016682699477FFF01E6E903878CDFD6846042BA1BFC64775E7AC6C4
account balance is 2000000000ng

ഇപ്പോൾ നമുക്ക് സ്മാർട്ട് കരാർ പ്രസിദ്ധീകരിക്കാം. നമുക്ക് ലൈറ്റ്-ക്ലയന്റ് സമാരംഭിച്ച് എക്സിക്യൂട്ട് ചെയ്യാം.

> sendfile lottery-query.boc
[ 1][t 2][1583008371.631410122][lite-client.cpp:966][!testnode] sending query from file lottery-query.boc
[ 3][t 1][1583008371.828550100][lite-client.cpp:976][!query]    external message status is 1 

കരാർ പ്രസിദ്ധീകരിച്ചിട്ടുണ്ടോയെന്ന് പരിശോധിക്കാം.

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

നമുക്ക് ലഭിക്കുന്ന മറ്റ് കാര്യങ്ങളിൽ.

  storage:(account_storage last_trans_lt:3825499000002
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:4 value:1987150999))
      other:(extra_currencies
        dict:hme_empty))
    state:(account_active

ഞങ്ങൾ അത് കാണുന്നു account_active.

മാറ്റങ്ങളുമായി ബന്ധപ്പെട്ട പ്രതിബദ്ധത ഇവിടെ ഇതാ.

ഇപ്പോൾ സ്‌മാർട്ട് കരാറുമായി സംവദിക്കാൻ അഭ്യർത്ഥനകൾ സൃഷ്‌ടിക്കാം.

കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, ഒരു സ്വതന്ത്ര ജോലിയായി വിലാസം മാറ്റുന്നതിന് ഞങ്ങൾ ആദ്യത്തേത് ഉപേക്ഷിക്കും, ഉടമയുടെ വിലാസത്തിലേക്ക് ഗ്രാം അയയ്ക്കുന്നതിന് ഞങ്ങൾ രണ്ടാമത്തേത് ചെയ്യും. വാസ്തവത്തിൽ, ഗ്രാം അയയ്‌ക്കുന്നതിനുള്ള പരിശോധനയിലെ അതേ കാര്യം തന്നെ ഞങ്ങൾ ചെയ്യേണ്ടതുണ്ട്.

സ്‌മാർട്ട് കരാറിലേക്ക് ഞങ്ങൾ അയയ്‌ക്കുന്ന സന്ദേശം ഇതാണ് msg_seqno 165, action അയയ്ക്കുന്നതിന് 2, 9.5 ഗ്രാം.

<b 165 32 u, 2 7 u, 9500000000 Gram, b>

നിങ്ങളുടെ സ്വകാര്യ കീ ഉപയോഗിച്ച് സന്ദേശത്തിൽ ഒപ്പിടാൻ മറക്കരുത് lottery.pk, സ്മാർട്ട് കരാർ സൃഷ്ടിക്കുമ്പോൾ മുമ്പ് സൃഷ്ടിച്ചതാണ്. അനുബന്ധ പ്രതിബദ്ധത ഇതാ.

നേടുന്ന രീതികൾ ഉപയോഗിച്ച് ഒരു സ്മാർട്ട് കരാറിൽ നിന്ന് വിവരങ്ങൾ സ്വീകരിക്കുന്നു

സ്‌മാർട്ട് കോൺട്രാക്‌ട് നേടുന്ന രീതികൾ എങ്ങനെ പ്രവർത്തിപ്പിക്കാമെന്ന് നോക്കാം.

ലോഞ്ച് lite-client ഞങ്ങൾ എഴുതിയ ഗെറ്റ് രീതികൾ പ്രവർത്തിപ്പിക്കുക.

$ ./lite-client/lite-client -C ton-lite-client-test1.config.json
> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd balance
arguments:  [ 104128 ] 
result:  [ 64633878952 ] 
...

В result ഫംഗ്ഷൻ നൽകുന്ന മൂല്യം അടങ്ങിയിരിക്കുന്നു balance() ഞങ്ങളുടെ സ്മാർട്ട് കരാറിൽ നിന്ന്.
നിരവധി രീതികൾക്കായി ഞങ്ങൾ ഇത് ചെയ്യും.

> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd get_seqno
...
arguments:  [ 77871 ] 
result:  [ 1 ] 

നിങ്ങളുടെ പന്തയ ചരിത്രം ചോദിക്കാം.

> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd get_orders
...
arguments:  [ 67442 ] 
result:  [ ([0 1 1583258284 10000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308] [1 3 1583258347 4000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308] [2 1 1583259901 50000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308]) ] 

ഞങ്ങൾ ലൈറ്റ്-ക്ലയന്റ് ഉപയോഗിക്കുകയും സൈറ്റിലെ സ്മാർട്ട് കരാറിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിനുള്ള രീതികൾ നേടുകയും ചെയ്യും.

വെബ്‌സൈറ്റിൽ സ്മാർട്ട് കരാർ ഡാറ്റ പ്രദർശിപ്പിക്കുന്നു

സ്മാർട്ട് കരാറിൽ നിന്നുള്ള ഡാറ്റ സൗകര്യപ്രദമായ രീതിയിൽ പ്രദർശിപ്പിക്കാൻ ഞാൻ പൈത്തണിൽ ഒരു ലളിതമായ വെബ്‌സൈറ്റ് എഴുതി. ഇവിടെ ഞാൻ അതിൽ വിശദമായി വസിക്കില്ല, സൈറ്റ് പ്രസിദ്ധീകരിക്കും ഒരു പ്രതിബദ്ധതയിൽ.

TON-ലേക്കുള്ള അഭ്യർത്ഥനകൾ നിർമ്മിച്ചിരിക്കുന്നത് Python സഹായത്തോടെ lite-client. സൗകര്യാർത്ഥം, സൈറ്റ് ഡോക്കറിൽ പാക്കേജുചെയ്‌ത് Google ക്ലൗഡിൽ പ്രസിദ്ധീകരിക്കുന്നു. ലിങ്ക്.

ശ്രമിക്കുന്നു

ഇനി മുതൽ നികത്തുന്നതിന് ഗ്രാം അയക്കാൻ ശ്രമിക്കാം വാലറ്റ്. ഞങ്ങൾ 40 ഗ്രാം അയയ്ക്കും. വ്യക്തതയ്ക്കായി നമുക്ക് കുറച്ച് പന്തയങ്ങൾ ഉണ്ടാക്കാം. വാതുവെപ്പുകളുടെ ചരിത്രം, നിലവിലെ വിജയ ശതമാനം, മറ്റ് ഉപയോഗപ്രദമായ വിവരങ്ങൾ എന്നിവ സൈറ്റ് കാണിക്കുന്നത് ഞങ്ങൾ കാണുന്നു.

നാം കാണുന്നുഞങ്ങൾ ആദ്യം ജയിച്ചു, രണ്ടാമത്തേത് തോറ്റു.

Afterword

ലേഖനം ഞാൻ പ്രതീക്ഷിച്ചതിലും വളരെ ദൈർഘ്യമേറിയതായി മാറി, ഒരുപക്ഷേ അത് ചെറുതായിരിക്കാം, അല്ലെങ്കിൽ ടണിനെ കുറിച്ച് ഒന്നും അറിയാത്ത ഒരു വ്യക്തിക്ക് വേണ്ടി മാത്രം സംവദിക്കാനുള്ള കഴിവുള്ള അത്ര ലളിതമല്ലാത്ത ഒരു സ്മാർട്ട് കരാർ എഴുതാനും പ്രസിദ്ധീകരിക്കാനും ആഗ്രഹിക്കുന്നു. അത്. ഒരുപക്ഷേ ചില കാര്യങ്ങൾ കുറച്ചുകൂടി ലളിതമായി വിശദീകരിക്കാമായിരുന്നു.

ഒരുപക്ഷേ നടപ്പാക്കലിന്റെ ചില വശങ്ങൾ കൂടുതൽ കാര്യക്ഷമമായും ഭംഗിയായും ചെയ്യാമായിരുന്നു, എന്നാൽ ലേഖനം തയ്യാറാക്കാൻ കൂടുതൽ സമയമെടുക്കുമായിരുന്നു. എനിക്ക് എവിടെയെങ്കിലും തെറ്റ് പറ്റിയതാകാം അല്ലെങ്കിൽ എന്തെങ്കിലും മനസ്സിലായില്ലായിരിക്കാം, അതിനാൽ നിങ്ങൾ ഗൗരവമായി എന്തെങ്കിലും ചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾ ഔദ്യോഗിക ഡോക്യുമെന്റേഷനോ അല്ലെങ്കിൽ TON കോഡുള്ള ഔദ്യോഗിക ശേഖരണത്തെയോ ആശ്രയിക്കേണ്ടതുണ്ട്.

TON ഇപ്പോഴും വികസനത്തിന്റെ സജീവ ഘട്ടത്തിലായതിനാൽ, ഈ ലേഖനത്തിലെ ഏതെങ്കിലും ഘട്ടങ്ങളെ തകർക്കുന്ന മാറ്റങ്ങൾ സംഭവിക്കാം (ഞാൻ എഴുതുമ്പോൾ ഇത് സംഭവിച്ചു, ഇത് ഇതിനകം ശരിയാക്കിയിട്ടുണ്ട്), എന്നാൽ പൊതുവായ സമീപനം ഇതാണ് മാറാൻ സാധ്യതയില്ല.

TON ന്റെ ഭാവിയെക്കുറിച്ച് ഞാൻ സംസാരിക്കില്ല. ഒരുപക്ഷേ പ്ലാറ്റ്‌ഫോം വലുതായി മാറിയേക്കാം, ഞങ്ങൾ അത് പഠിക്കാൻ സമയം ചെലവഴിക്കുകയും ഇപ്പോൾ ഞങ്ങളുടെ ഉൽപ്പന്നങ്ങളിൽ ഒരു ഇടം നിറയ്ക്കുകയും വേണം.

TON-നേക്കാൾ വലിയ ഉപയോക്താക്കളുടെ സാധ്യതയുള്ള പ്രേക്ഷകരുള്ള Facebook-ൽ നിന്നുള്ള ലിബ്രയും ഉണ്ട്. തുലാം രാശിയെക്കുറിച്ച് എനിക്ക് ഒന്നും അറിയില്ല, ഫോറം വിലയിരുത്തുമ്പോൾ ടൺ കമ്മ്യൂണിറ്റിയിലേതിനേക്കാൾ കൂടുതൽ പ്രവർത്തനമുണ്ട്. TON-ന്റെ ഡെവലപ്പർമാരും കമ്മ്യൂണിറ്റിയും ഭൂഗർഭത്തെ പോലെയാണെങ്കിലും, അത് രസകരമാണ്.

റെഫറൻസുകൾ

1. ഔദ്യോഗിക TON ഡോക്യുമെന്റേഷൻ: https://test.ton.org
2. ഔദ്യോഗിക TON ശേഖരം: https://github.com/ton-blockchain/ton
3. വ്യത്യസ്ത പ്ലാറ്റ്ഫോമുകൾക്കുള്ള ഔദ്യോഗിക വാലറ്റ്: https://wallet.ton.org
4. ഈ ലേഖനത്തിൽ നിന്നുള്ള സ്മാർട്ട് കരാർ ശേഖരം: https://github.com/raiym/astonished
5. സ്മാർട്ട് കരാർ വെബ്സൈറ്റിലേക്കുള്ള ലിങ്ക്: https://ton-lottery.appspot.com
6. FunC-നുള്ള വിഷ്വൽ സ്റ്റുഡിയോ കോഡിനായുള്ള വിപുലീകരണത്തിനുള്ള ശേഖരം: https://github.com/raiym/func-visual-studio-plugin
7. ടെലിഗ്രാമിൽ TON-നെ കുറിച്ച് ചാറ്റ് ചെയ്യുക, ഇത് പ്രാരംഭ ഘട്ടത്തിൽ അത് കണ്ടെത്താൻ ശരിക്കും സഹായിച്ചു. TON ന് വേണ്ടി എന്തെങ്കിലും എഴുതിയവരെല്ലാം അവിടെ ഉണ്ടെന്ന് ഞാൻ പറഞ്ഞാൽ അത് തെറ്റായിരിക്കില്ലെന്ന് ഞാൻ കരുതുന്നു. നിങ്ങൾക്ക് അവിടെ ടെസ്റ്റ് ഗ്രാം ആവശ്യപ്പെടാം. https://t.me/tondev_ru
8. TON നെക്കുറിച്ചുള്ള മറ്റൊരു ചാറ്റ്, അതിൽ ഞാൻ ഉപയോഗപ്രദമായ വിവരങ്ങൾ കണ്ടെത്തി: https://t.me/TONgramDev
9. മത്സരത്തിന്റെ ആദ്യ ഘട്ടം: https://contest.com/blockchain
10. മത്സരത്തിന്റെ രണ്ടാം ഘട്ടം: https://contest.com/blockchain-2

അവലംബം: www.habr.com