സ്‌മാർട്ട് കരാറുകൾക്കായി ക്ലയന്റ് ടൺ (ടെലിഗ്രാം ഓപ്പൺ നെറ്റ്‌വർക്ക്), പുതിയ ഫിഫ്റ്റ് ഭാഷ എന്നിവ പരീക്ഷിക്കുക

ഒരു വർഷം മുമ്പ്, ടെലിഗ്രാം മെസഞ്ചറിന്റെ സ്വന്തം വികേന്ദ്രീകൃത നെറ്റ്‌വർക്ക് പുറത്തിറക്കാനുള്ള പദ്ധതികളെക്കുറിച്ച് അറിയപ്പെട്ടു. ടെലിഗ്രാം ഓപ്പൺ നെറ്റ്‌വർക്ക്. അപ്പോൾ ഒരു വലിയ സാങ്കേതിക പ്രമാണം ലഭ്യമായി, അത് നിക്കോളായ് ദുറോവ് എഴുതിയതാണെന്നും ഭാവി ശൃംഖലയുടെ ഘടന വിവരിച്ചുവെന്നും ആരോപിക്കപ്പെടുന്നു. ഇത് നഷ്‌ടമായവർക്കായി, ഈ പ്രമാണത്തിന്റെ എന്റെ പുനരാഖ്യാനം വായിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു (ഭാഗം 1, ഭാഗം 2; മൂന്നാം ഭാഗം, അയ്യോ, ഇപ്പോഴും ഡ്രാഫ്റ്റുകളിൽ പൊടി ശേഖരിക്കുന്നു).

അതിനുശേഷം, കുറച്ച് ദിവസങ്ങൾക്ക് മുമ്പ് വരെ TON വികസനത്തിന്റെ അവസ്ഥയെക്കുറിച്ച് കാര്യമായ വാർത്തകളൊന്നും ഉണ്ടായിട്ടില്ല (ഒന്നിൽ അനൌദ്യോഗിക ചാനലുകൾ) പേജിലേക്കുള്ള ലിങ്ക് ദൃശ്യമായില്ല https://test.ton.org/download.html, എവിടെയാണ് സ്ഥിതി ചെയ്യുന്നത്:
◦ ton-test-liteclient-full.tar.xz - TON ടെസ്റ്റ് നെറ്റ്‌വർക്കിനായുള്ള ഒരു ലൈറ്റ് ക്ലയന്റ് ഉറവിടങ്ങൾ;
◦ ton-lite-client-test1.config.json - ടെസ്റ്റ് നെറ്റ്‌വർക്കിലേക്ക് കണക്റ്റുചെയ്യുന്നതിനുള്ള കോൺഫിഗറേഷൻ ഫയൽ;
◦ വായിക്കുക - ക്ലയന്റ് നിർമ്മിക്കുന്നതിനും സമാരംഭിക്കുന്നതിനുമുള്ള വിവരങ്ങൾ;
◦ എങ്ങിനെ - ഒരു ക്ലയന്റ് ഉപയോഗിച്ച് ഒരു സ്മാർട്ട് കരാർ സൃഷ്ടിക്കുന്നതിനുള്ള ഘട്ടം ഘട്ടമായുള്ള നിർദ്ദേശങ്ങൾ;
◦ ton.pdf - TON നെറ്റ്‌വർക്കിന്റെ സാങ്കേതിക അവലോകനത്തോടുകൂടിയ അപ്‌ഡേറ്റ് ചെയ്‌ത പ്രമാണം (2 മാർച്ച് 2019 തീയതി);
◦ tvm.pdf — TVM ന്റെ സാങ്കേതിക വിവരണം (TON വെർച്വൽ മെഷീൻ, TON വെർച്വൽ മെഷീൻ);
◦ tblkch.pdf - TON ബ്ലോക്ക്ചെയിനിന്റെ സാങ്കേതിക വിവരണം;
◦ fifthbase.pdf - TON-ൽ സ്‌മാർട്ട് കരാറുകൾ സൃഷ്‌ടിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന പുതിയ ഫിഫ്‌റ്റ് ഭാഷയുടെ വിവരണം.

ഞാൻ ആവർത്തിക്കുന്നു, ടെലിഗ്രാമിൽ നിന്നുള്ള പേജിന്റെയും ഈ എല്ലാ രേഖകളുടെയും ഔദ്യോഗിക സ്ഥിരീകരണമൊന്നും ഉണ്ടായിരുന്നില്ല, എന്നാൽ ഈ മെറ്റീരിയലുകളുടെ അളവ് അവയെ തികച്ചും വിശ്വസനീയമാക്കുന്നു. പ്രസിദ്ധീകരിച്ച ക്ലയന്റ് സമാരംഭിക്കുക സ്വന്തം ഉത്തരവാദിത്തത്തിൽ.

ഒരു ടെസ്റ്റ് ക്ലയന്റ് നിർമ്മിക്കുന്നു

ആദ്യം, നമുക്ക് ഒരു ടെസ്റ്റ് ക്ലയന്റ് നിർമ്മിക്കാനും പ്രവർത്തിപ്പിക്കാനും ശ്രമിക്കാം - ഭാഗ്യവശാൽ, വായിക്കുക ഈ ലളിതമായ പ്രക്രിയ വിശദമായി വിവരിക്കുന്നു. ഉദാഹരണമായി MacOS 10.14.5 ഉപയോഗിച്ച് ഞാൻ ഇത് ചെയ്യും; മറ്റ് സിസ്റ്റങ്ങളിലെ ബിൽഡിന്റെ വിജയത്തിന് എനിക്ക് ഉറപ്പുനൽകാൻ കഴിയില്ല.

1. ഡൗൺലോഡ് ചെയ്ത് അൺപാക്ക് ചെയ്യുക ഉറവിട ആർക്കൈവ്. ഈ ഘട്ടത്തിൽ പിന്നോക്ക അനുയോജ്യത ഉറപ്പില്ലാത്തതിനാൽ ഏറ്റവും പുതിയ പതിപ്പ് ഡൗൺലോഡ് ചെയ്യേണ്ടത് പ്രധാനമാണ്.

2. Make, cmake (പതിപ്പ് 3.0.2 അല്ലെങ്കിൽ അതിലും ഉയർന്നത്), OpenSSL (C ഹെഡ്ഡർ ഫയലുകൾ ഉൾപ്പെടെ), g++ അല്ലെങ്കിൽ clang എന്നിവയുടെ ഏറ്റവും പുതിയ പതിപ്പുകൾ സിസ്റ്റത്തിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. എനിക്ക് ഒന്നും ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതില്ല, എല്ലാം ഉടനടി ഒത്തുചേർന്നു.

3. ഉറവിടങ്ങൾ ഒരു ഫോൾഡറിലേക്ക് അൺപാക്ക് ചെയ്തിട്ടുണ്ടെന്ന് നമുക്ക് അനുമാനിക്കാം ~/lite-client. അതിൽ നിന്ന് പ്രത്യേകം, അസംബിൾ ചെയ്ത പ്രോജക്റ്റിനായി ഒരു ശൂന്യമായ ഫോൾഡർ സൃഷ്ടിക്കുക (ഉദാഹരണത്തിന്, ~/liteclient-build), അതിൽ നിന്ന് (cd ~/liteclient-build) കമാൻഡുകൾ വിളിക്കുക:

   cmake ~/lite-client
   cmake --build . --target test-lite-client

   
   
   സ്‌മാർട്ട് കരാറുകൾക്കായി ഫിഫ്റ്റ് ലാംഗ്വേജ് ഇന്റർപ്രെട്ടർ നിർമ്മിക്കുന്നതിന് (അതിനെക്കുറിച്ച് കൂടുതൽ താഴെ), ഞങ്ങളും വിളിക്കുന്നു

   cmake --build . --target fift

4. നിലവിലുള്ളത് ഡൗൺലോഡ് ചെയ്യുക കോൺഫിഗറേഷൻ ഫയൽ ടെസ്റ്റ് നെറ്റ്‌വർക്കിലേക്ക് കണക്റ്റുചെയ്‌ത് അസംബിൾ ചെയ്‌ത ക്ലയന്റിനൊപ്പം ഫോൾഡറിൽ ഇടുക.

5. ചെയ്‌തു, നിങ്ങൾക്ക് ക്ലയന്റ് ആരംഭിക്കാൻ കഴിയും:

   ./test-lite-client -C ton-lite-client-test1.config.json

എല്ലാം ശരിയായി ചെയ്തുവെങ്കിൽ, നിങ്ങൾ ഇതുപോലുള്ള ഒന്ന് കാണണം:

നമുക്ക് കാണാനാകുന്നതുപോലെ, ലഭ്യമായ കുറച്ച് കമാൻഡുകൾ ഉണ്ട്:
◦ help - ഈ കമാൻഡുകളുടെ പട്ടിക പ്രദർശിപ്പിക്കുക;
◦ quit - പുറത്തുപോകുക;
◦ time - സെർവറിലെ നിലവിലെ സമയം കാണിക്കുക;
◦ status - കണക്ഷനും പ്രാദേശിക ഡാറ്റാബേസ് നിലയും കാണിക്കുക;
◦ last — ബ്ലോക്ക്ചെയിനിന്റെ അവസ്ഥ അപ്ഡേറ്റ് ചെയ്യുക (അവസാന ബ്ലോക്ക് ഡൗൺലോഡ് ചെയ്യുക). നെറ്റ്‌വർക്കിന്റെ നിലവിലെ അവസ്ഥ നിങ്ങൾ കാണുന്നുവെന്ന് ഉറപ്പാക്കാൻ എന്തെങ്കിലും അഭ്യർത്ഥനകൾക്ക് മുമ്പ് ഈ കമാൻഡ് പ്രവർത്തിപ്പിക്കേണ്ടത് പ്രധാനമാണ്.
◦ sendfile <filename> - TON നെറ്റ്‌വർക്കിലേക്ക് ഒരു ലോക്കൽ ഫയൽ അപ്‌ലോഡ് ചെയ്യുക. നെറ്റ്‌വർക്കുമായുള്ള ഇടപെടൽ സംഭവിക്കുന്നത് ഇങ്ങനെയാണ് - ഉദാഹരണത്തിന്, പുതിയ സ്മാർട്ട് കരാറുകൾ സൃഷ്ടിക്കുന്നതും അക്കൗണ്ടുകൾക്കിടയിൽ ഫണ്ട് കൈമാറുന്നതിനുള്ള അഭ്യർത്ഥനകളും ഉൾപ്പെടെ;
◦ getaccount <address> - കറന്റ് കാണിക്കുക (കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്ത സമയത്ത്) last) നിർദ്ദിഷ്ട വിലാസമുള്ള അക്കൗണ്ടിന്റെ നില;
◦ privkey <filename> — ഒരു പ്രാദേശിക ഫയലിൽ നിന്ന് സ്വകാര്യ കീ ലോഡ് ചെയ്യുക.

ക്ലയന്റ് ആരംഭിക്കുമ്പോൾ, ഓപ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾ അതിലേക്ക് ഒരു ഫോൾഡർ കൈമാറുകയാണെങ്കിൽ -D, അപ്പോൾ അവൻ അതിൽ മാസ്റ്റർചെയിനിന്റെ അവസാന ബ്ലോക്ക് ചേർക്കും:

./test-lite-client -C ton-lite-client-test1.config.json -D ~/ton-db-dir

ഇപ്പോൾ നമുക്ക് കൂടുതൽ രസകരമായ കാര്യങ്ങളിലേക്ക് പോകാം - ഫിഫ്റ്റ് ഭാഷ പഠിക്കുക, ഒരു സ്മാർട്ട് കരാർ കംപൈൽ ചെയ്യാൻ ശ്രമിക്കുക (ഉദാഹരണത്തിന്, ഒരു ടെസ്റ്റ് വാലറ്റ് സൃഷ്ടിക്കുക), അത് നെറ്റ്വർക്കിലേക്ക് അപ്ലോഡ് ചെയ്ത് അക്കൗണ്ടുകൾക്കിടയിൽ ഫണ്ട് ട്രാൻസ്ഫർ ചെയ്യാൻ ശ്രമിക്കുക.

ഭാഷ ഫിഫ്റ്റ്

പ്രമാണത്തിൽ നിന്ന് fifthbase.pdf സ്‌മാർട്ട് കരാറുകൾ സൃഷ്‌ടിക്കാൻ ടെലിഗ്രാം ടീം ഒരു പുതിയ സ്റ്റാക്ക് ഭാഷ സൃഷ്‌ടിച്ചതായി നിങ്ങൾക്ക് കണ്ടെത്താനാകും അഞ്ച് (പ്രത്യക്ഷമായും അക്കത്തിൽ നിന്ന് അഞ്ചാമത്തെ, ഫോർത്തിന് സമാനമാണ്, ഫിഫ്‌തുമായി വളരെയധികം സാമ്യമുള്ള ഒരു ഭാഷ).

പ്രമാണം വളരെ വലുതാണ്, 87 പേജുകൾ, ഈ ലേഖനത്തിന്റെ ചട്ടക്കൂടിനുള്ളിൽ ഞാൻ അതിന്റെ ഉള്ളടക്കങ്ങൾ വിശദമായി പറയില്ല (കുറഞ്ഞത് ഞാൻ ഇത് സ്വയം വായിച്ച് പൂർത്തിയാക്കാത്തതിനാൽ :). ഞാൻ പ്രധാന പോയിന്റുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുകയും ഈ ഭാഷയിൽ രണ്ട് കോഡ് ഉദാഹരണങ്ങൾ നൽകുകയും ചെയ്യും.

അടിസ്ഥാന തലത്തിൽ, ഫിഫ്റ്റിന്റെ വാക്യഘടന വളരെ ലളിതമാണ്: അതിന്റെ കോഡ് അടങ്ങിയിരിക്കുന്നു വാക്കുകൾ, സാധാരണയായി സ്‌പെയ്‌സുകളോ ലൈൻ ബ്രേക്കുകളോ ഉപയോഗിച്ച് വേർതിരിക്കുന്നു (പ്രത്യേക സന്ദർഭം: ചില വാക്കുകൾക്ക് ഒരു സെപ്പറേറ്റർ ആവശ്യമില്ല). ഏതെങ്കിലും വചനം ഒരു നിശ്ചിതമായ പ്രതീകങ്ങളുടെ ഒരു കേസ്-സെൻസിറ്റീവ് സീക്വൻസാണ് ദൃഢനിശ്ചയം (ഏകദേശം, ഈ വാക്ക് അഭിമുഖീകരിക്കുമ്പോൾ വ്യാഖ്യാതാവ് എന്തുചെയ്യണം). ഒരു വാക്കിന് നിർവചനം ഇല്ലെങ്കിൽ, വ്യാഖ്യാതാവ് അതിനെ ഒരു സംഖ്യയായി പാഴ്സ് ചെയ്ത് സ്റ്റാക്കിൽ ഇടാൻ ശ്രമിക്കുന്നു. വഴിയിൽ, ഇവിടെയുള്ള സംഖ്യകൾ - പെട്ടെന്ന് - 257-ബിറ്റ് പൂർണ്ണസംഖ്യകളാണ്, കൂടാതെ ഭിന്നസംഖ്യകളൊന്നുമില്ല - കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, അവ ഉടനടി ഒരു ജോടി പൂർണ്ണസംഖ്യകളായി മാറുന്നു, ഇത് ഒരു യുക്തിസഹമായ ഭിന്നസംഖ്യയുടെ ന്യൂമറേറ്ററും ഡിനോമിനേറ്ററും ഉണ്ടാക്കുന്നു.

വാക്കുകൾ സ്റ്റാക്കിന്റെ മുകളിലുള്ള മൂല്യങ്ങളുമായി ഇടപഴകുന്നു. ഒരു പ്രത്യേക തരം വാക്കുകൾ - ഉപസർഗ്ഗം — സ്റ്റാക്ക് ഉപയോഗിക്കുന്നില്ല, സോഴ്സ് ഫയലിൽ നിന്നുള്ള തുടർന്നുള്ള പ്രതീകങ്ങൾ. ഉദാഹരണത്തിന്, സ്ട്രിംഗ് ലിറ്ററലുകൾ നടപ്പിലാക്കുന്നത് ഇങ്ങനെയാണ് - ഉദ്ധരണി പ്രതീകം (") അടുത്ത (ക്ലോസിംഗ്) ഉദ്ധരണിക്കായി തിരയുന്ന ഒരു പ്രിഫിക്‌സ് പദമാണ്, അവയ്‌ക്കിടയിലുള്ള സ്ട്രിംഗ് സ്റ്റാക്കിലേക്ക് തള്ളുന്നു. വൺ-ലൈനറുകൾ അതേ രീതിയിൽ പെരുമാറുന്നു (//) കൂടാതെ മൾട്ടിലൈൻ (/*) അഭിപ്രായങ്ങൾ.

ഭാഷയുടെ ഏതാണ്ട് മുഴുവൻ ആന്തരിക ഘടനയും അവസാനിക്കുന്നത് ഇവിടെയാണ്. മറ്റെല്ലാം (നിയന്ത്രണ നിർമ്മാണങ്ങൾ ഉൾപ്പെടെ) വാക്കുകളായി നിർവചിച്ചിരിക്കുന്നു (ഒന്നുകിൽ ആന്തരിക, ഗണിത പ്രവർത്തനങ്ങൾ, പുതിയ പദങ്ങളുടെ നിർവചനം; അല്ലെങ്കിൽ "സ്റ്റാൻഡേർഡ് ലൈബ്രറി"യിൽ നിർവചിച്ചിരിക്കുന്നത് Fift.fif, ഫോൾഡറിലുള്ളത് crypto/fift ഉറവിടങ്ങളിൽ).

ഫിഫ്റ്റിലെ ഒരു ലളിതമായ ഉദാഹരണ പ്രോഗ്രാം:

{ dup =: x dup * =: y } : setxy
3 setxy x . y . x y + .
7 setxy x . y . x y + .

ആദ്യ വരി ഒരു പുതിയ വാക്ക് നിർവചിക്കുന്നു setxy (പ്രിഫിക്സ് ശ്രദ്ധിക്കുക {, അടയ്ക്കുന്നതിന് മുമ്പ് ഒരു ബ്ലോക്ക് സൃഷ്ടിക്കുന്നു } പ്രിഫിക്സും :, ഇത് യഥാർത്ഥത്തിൽ വാക്ക് നിർവചിക്കുന്നു). setxy സ്റ്റാക്കിന്റെ മുകളിൽ നിന്ന് ഒരു സംഖ്യ എടുക്കുന്നു, അത് ആഗോളമായി നിർവചിക്കുന്നു (അല്ലെങ്കിൽ പുനർ നിർവചിക്കുന്നു). സ്ഥിരമായ x, ഈ സംഖ്യയുടെ വർഗ്ഗം ഒരു സ്ഥിരാങ്കം y (സ്ഥിരതകളുടെ മൂല്യങ്ങൾ പുനർനിർവചിക്കാൻ കഴിയുമെന്നതിനാൽ, ഞാൻ അവയെ വേരിയബിളുകൾ എന്ന് വിളിക്കും, പക്ഷേ ഞാൻ ഭാഷയിലെ നാമകരണ കൺവെൻഷൻ പിന്തുടരുന്നു).

അടുത്ത രണ്ട് വരികൾ സ്റ്റാക്കിൽ ഒരു നമ്പർ ഇട്ടു വിളിക്കുക setxy, തുടർന്ന് സ്ഥിരാങ്കങ്ങളുടെ മൂല്യങ്ങൾ പ്രദർശിപ്പിക്കും x, y (ഈ വാക്ക് ഔട്ട്പുട്ടിനായി ഉപയോഗിക്കുന്നു .), രണ്ട് സ്ഥിരാങ്കങ്ങളും സ്റ്റാക്കിൽ സ്ഥാപിക്കുകയും സംഗ്രഹിക്കുകയും ഫലവും അച്ചടിക്കുകയും ചെയ്യുന്നു. ഫലമായി നമ്മൾ കാണും:

3 9 12 ok
7 49 56 ok

(ഇന്ററാക്ടീവ് ഇൻപുട്ട് മോഡിൽ നിലവിലെ ലൈൻ പ്രോസസ്സ് ചെയ്യുന്നത് പൂർത്തിയാകുമ്പോൾ "ശരി" എന്ന ലൈൻ ഇന്റർപ്രെറ്റർ പ്രിന്റ് ചെയ്യുന്നു)

ശരി, ഒരു പൂർണ്ണ കോഡ് ഉദാഹരണം:

"Asm.fif" include

-1 constant wc  // create a wallet in workchain -1 (masterchain)

// Create new simple wallet
<{  SETCP0 DUP IFNOTRET INC 32 THROWIF  // return if recv_internal, fail unless recv_external
    512 INT LDSLICEX DUP 32 PLDU   // sign cs cnt
    c4 PUSHCTR CTOS 32 LDU 256 LDU ENDS  // sign cs cnt cnt' pubk
    s1 s2 XCPU            // sign cs cnt pubk cnt' cnt
    EQUAL 33 THROWIFNOT   // ( seqno mismatch? )
    s2 PUSH HASHSU        // sign cs cnt pubk hash
    s0 s4 s4 XC2PU        // pubk cs cnt hash sign pubk
    CHKSIGNU              // pubk cs cnt ?
    34 THROWIFNOT         // signature mismatch
    ACCEPT
    SWAP 32 LDU NIP 
    DUP SREFS IF:<{
      8 LDU LDREF         // pubk cnt mode msg cs
      s0 s2 XCHG SENDRAWMSG  // pubk cnt cs ; ( message sent )
    }>
    ENDS
    INC NEWC 32 STU 256 STU ENDC c4 POPCTR
}>c
// code
<b 0 32 u, 
   newkeypair swap dup constant wallet_pk 
   "new-wallet.pk" B>file
   B, 
b> // data
// no libraries
<b b{00110} s, rot ref, swap ref, b>  // create StateInit
dup ."StateInit: " <s csr. cr
dup hash dup constant wallet_addr
."new wallet address = " wc . .": " dup x. cr
wc over 7 smca>$ type cr
256 u>B "new-wallet.addr" B>file
<b 0 32 u, b>
dup ."signing message: " <s csr. cr
dup hash wallet_pk ed25519_sign_uint rot
<b b{1000100} s, wc 8 i, wallet_addr 256 u, b{000010} s, swap <s s, b{0} s, swap B, swap <s s, b>
dup ."External message for initialization is " <s csr. cr
2 boc+>B dup Bx. cr
"new-wallet-query.boc" tuck B>file
."(Saved to file " type .")" cr

ഭയപ്പെടുത്തുന്ന ഈ ഫയൽ ഒരു സ്‌മാർട്ട് കരാർ സൃഷ്‌ടിക്കുന്നതിനുള്ളതാണ് - ഇത് ഒരു ഫയലിൽ സ്ഥാപിക്കും new-wallet-query.boc വധശിക്ഷയ്ക്ക് ശേഷം. TON വെർച്വൽ മെഷീനായി മറ്റൊരു അസംബ്ലി ഭാഷയാണ് ഇവിടെ ഉപയോഗിച്ചിരിക്കുന്നത് (ഞാൻ അതിൽ വിശദമായി വസിക്കില്ല), അതിന്റെ നിർദ്ദേശങ്ങൾ ബ്ലോക്ക്ചെയിനിൽ സ്ഥാപിക്കും.

അതിനാൽ, ടിവിഎമ്മിനായുള്ള അസംബ്ലർ ഫിഫ്റ്റിൽ എഴുതിയിരിക്കുന്നു - ഈ അസംബ്ലറിന്റെ ഉറവിടങ്ങൾ ഫയലിലുണ്ട് crypto/fift/Asm.fif മുകളിൽ പറഞ്ഞിരിക്കുന്ന കോഡിന്റെ തുടക്കത്തിൽ ബന്ധിപ്പിച്ചിരിക്കുന്നു.

എനിക്ക് എന്ത് പറയാൻ കഴിയും, പ്രത്യക്ഷത്തിൽ നിക്കോളായ് ദുറോവ് പുതിയ പ്രോഗ്രാമിംഗ് ഭാഷകൾ സൃഷ്ടിക്കാൻ ഇഷ്ടപ്പെടുന്നു :)

ഒരു മികച്ച കരാർ സൃഷ്ടിക്കുകയും TON-മായി സംവദിക്കുകയും ചെയ്യുന്നു

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

TON-ലെ അക്കൗണ്ടുകൾ

ഞാൻ വിവരിച്ചതുപോലെ ടൺ അവലോകനം, ഈ നെറ്റ്‌വർക്കിൽ ഒന്നിലധികം ബ്ലോക്ക്‌ചെയിൻ അടങ്ങിയിരിക്കുന്നു - പൊതുവായ ഒന്ന് ഉണ്ട്, വിളിക്കപ്പെടുന്ന ഒന്ന്. "മാസ്റ്റർ ചെയിൻ", കൂടാതെ ഒരു 32-ബിറ്റ് നമ്പർ ഉപയോഗിച്ച് തിരിച്ചറിയുന്ന അധിക "വർക്ക് ചെയിനുകളുടെ" അനിയന്ത്രിതമായ സംഖ്യ. മാസ്റ്റർചെയിനിന് -1-ന്റെ ഒരു ഐഡന്റിഫയർ ഉണ്ട്; അതിനുപുറമെ, 0-ന്റെ ഐഡന്റിഫയർ ഉള്ള ഒരു "ബേസ്" വർക്ക്ചെയിനും ഉപയോഗിക്കാം. ഓരോ വർക്ക്ചെയിനിനും അതിന്റേതായ കോൺഫിഗറേഷൻ ഉണ്ടായിരിക്കും. ആന്തരികമായി, ഓരോ വർക്ക്ചെയിനും ഷാർഡ്ചെയിനുകളായി തിരിച്ചിരിക്കുന്നു, എന്നാൽ ഇത് ഒരു നടപ്പാക്കൽ വിശദാംശമാണ്, അത് മനസ്സിൽ സൂക്ഷിക്കേണ്ടതില്ല.

ഒരു വർക്ക്ചെയിനിൽ, സ്വന്തം account_id ഐഡന്റിഫയറുകൾ ഉള്ള നിരവധി അക്കൗണ്ടുകൾ സംഭരിച്ചിരിക്കുന്നു. മാസ്റ്റർ ചെയിൻ, സീറോ വർക്ക് ചെയിൻ എന്നിവയ്ക്ക് 256 ബിറ്റുകൾ നീളമുണ്ട്. അതിനാൽ, അക്കൗണ്ട് ഐഡന്റിഫയർ എഴുതിയിരിക്കുന്നു, ഉദാഹരണത്തിന്, ഇതുപോലെ:

-1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

ഇതാണ് "റോ" ഫോർമാറ്റ്: ആദ്യം വർക്ക്ചെയിൻ ഐഡി, പിന്നെ ഒരു കോളൻ, ഹെക്സാഡെസിമൽ നൊട്ടേഷനിലുള്ള അക്കൗണ്ട് ഐഡി.

കൂടാതെ, ചുരുക്കിയ ഒരു ഫോർമാറ്റ് ഉണ്ട് - വർക്ക്ചെയിൻ നമ്പറും അക്കൗണ്ട് വിലാസവും ബൈനറി രൂപത്തിൽ എൻകോഡ് ചെയ്‌തിരിക്കുന്നു, അവയിൽ ഒരു ചെക്ക്‌സം ചേർത്തു, ഇതെല്ലാം Base64-ൽ എൻകോഡ് ചെയ്‌തിരിക്കുന്നു:

Ef+BVndbeTJeXWLnQtm5bDC2UVpc0vH2TF2ksZPAPwcODSkb

ഈ റെക്കോർഡ് ഫോർമാറ്റ് അറിയുന്നതിലൂടെ, കമാൻഡ് ഉപയോഗിച്ച് ഒരു ടെസ്റ്റ് ക്ലയന്റ് മുഖേന നമുക്ക് ഒരു അക്കൗണ്ടിന്റെ നിലവിലെ അവസ്ഥ അഭ്യർത്ഥിക്കാം

getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

ഞങ്ങൾക്ക് ഇതുപോലുള്ള ഒന്ന് ലഭിക്കും:

[ 3][t 2][1558746708.815218925][test-lite-client.cpp:631][!testnode]    requesting account state for -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D
[ 3][t 2][1558746708.858564138][test-lite-client.cpp:652][!testnode]    got account state for -1:8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D with respect to blocks (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F and (-1,8000000000000000,72355):F566005749C1B97F18EDE013EBA7A054B9014961BC1AD91F475B9082919A2296:1BD5DE54333164025EE39D389ECE2E93DA2871DA616D488253953E52B50DC03F
account state is (account
  addr:(addr_std
    anycast:nothing workchain_id:-1 address:x8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D)
  storage_stat:(storage_info
    used:(storage_used
      cells:(var_uint len:1 value:3)
      bits:(var_uint len:2 value:539)
      public_cells:(var_uint len:0 value:0)) last_paid:0
    due_payment:nothing)
  storage:(account_storage last_trans_lt:74208000003
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:7 value:999928362430000))
      other:(extra_currencies
        dict:hme_empty))
    state:(account_active
      (
        split_depth:nothing
        special:nothing
        code:(just
          value:(raw@^Cell 
            x{}
             x{FF0020DDA4F260D31F01ED44D0D31FD166BAF2A1F80001D307D4D1821804A817C80073FB0201FB00A4C8CB1FC9ED54}
            ))
        data:(just
          value:(raw@^Cell 
            x{}
             x{0000000D}
            ))
        library:hme_empty))))
x{CFF8156775B79325E5D62E742D9B96C30B6515A5CD2F1F64C5DA4B193C03F070E0D2068086C000000000000000451C90E00DC0E35B7DB5FB8C134_}
 x{FF0020DDA4F260D31F01ED44D0D31FD166BAF2A1F80001D307D4D1821804A817C80073FB0201FB00A4C8CB1FC9ED54}
 x{0000000D}

നിർദ്ദിഷ്ട വർക്ക്ചെയിനിന്റെ ഡിഎച്ച്ടിയിൽ സംഭരിച്ചിരിക്കുന്ന ഘടന ഞങ്ങൾ കാണുന്നു. ഉദാഹരണത്തിന്, വയലിൽ storage.balance കറന്റ് അക്കൗണ്ട് ബാലൻസ് ആണ് storage.state.code - സ്മാർട്ട് കരാർ കോഡ്, ഒപ്പം storage.state.data - അതിന്റെ നിലവിലെ ഡാറ്റ. TON ഡാറ്റ സംഭരണം - സെൽ, സെല്ലുകൾ - വൃക്ഷം പോലെയാണ്, ഓരോ സെല്ലിനും അതിന്റേതായ ഡാറ്റയും ചൈൽഡ് സെല്ലുകളും ഉണ്ടായിരിക്കാം. ഇത് അവസാന വരികളിൽ ഇൻഡന്റേഷനായി കാണിച്ചിരിക്കുന്നു.

ഒരു സ്മാർട്ട് കരാർ നിർമ്മിക്കുന്നു

ഇനി നമുക്ക് അത്തരമൊരു ഘടന സ്വയം സൃഷ്ടിക്കാം (അതിനെ BOC എന്ന് വിളിക്കുന്നു - കോശങ്ങളുടെ ബാഗ്) അഞ്ചാമത്തെ ഭാഷ ഉപയോഗിക്കുന്നു. ഭാഗ്യവശാൽ, നിങ്ങൾ സ്വയം ഒരു മികച്ച കരാർ എഴുതേണ്ടതില്ല - ഫോൾഡറിൽ crypto/block ഉറവിട ആർക്കൈവിൽ നിന്ന് ഒരു ഫയൽ ഉണ്ട് new-wallet.fif, ഇത് ഒരു പുതിയ വാലറ്റ് സൃഷ്ടിക്കാൻ ഞങ്ങളെ സഹായിക്കും. സമാഹരിച്ച ക്ലയന്റുള്ള ഫോൾഡറിലേക്ക് ഇത് പകർത്താം (~/liteclient-build, നിങ്ങൾ മുകളിലുള്ള നിർദ്ദേശങ്ങൾ പാലിച്ചാൽ). ഫിഫ്റ്റിലെ കോഡിന്റെ ഉദാഹരണമായി ഞാൻ അതിന്റെ ഉള്ളടക്കങ്ങൾ മുകളിൽ ഉദ്ധരിച്ചു.

ഈ ഫയൽ ഇനിപ്പറയുന്ന രീതിയിൽ നടപ്പിലാക്കുക:

./crypto/fift -I"<source-directory>/crypto/fift" new-wallet.fif

ഇത് <source-directory> പാക്ക് ചെയ്യാത്ത ഉറവിടങ്ങളിലേക്കുള്ള പാത ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കേണ്ടതാണ് ("~" ചിഹ്നം, നിർഭാഗ്യവശാൽ, ഇവിടെ ഉപയോഗിക്കാൻ കഴിയില്ല, മുഴുവൻ പാതയും ആവശ്യമാണ്). ഒരു കീ ഉപയോഗിക്കുന്നതിന് പകരം -I നിങ്ങൾക്ക് ഒരു പരിസ്ഥിതി വേരിയബിൾ നിർവചിക്കാം FIFTPATH ഈ പാത അതിൽ ഇടുക.

ഞങ്ങൾ ഫയൽ നാമത്തിൽ ഫിഫ്റ്റ് സമാരംഭിച്ചതിനാൽ new-wallet.fif, അത് എക്സിക്യൂട്ട് ചെയ്ത് പുറത്തുകടക്കും. നിങ്ങൾ ഫയലിന്റെ പേര് ഒഴിവാക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഇന്റർപ്രെറ്ററുമായി സംവേദനാത്മകമായി കളിക്കാം.

നിർവ്വഹിച്ചതിന് ശേഷം, ഇതുപോലുള്ള ഒന്ന് കൺസോളിൽ പ്രദർശിപ്പിക്കണം:

StateInit: x{34_}
 x{FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED54}
 x{0000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B}

new wallet address = -1 : 4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 
0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ
signing message: x{00000000}

External message for initialization is x{89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001_}
 x{FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED54}
 x{0000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B}

B5EE9C724104030100000000D60002CF89FEE120E20C7E953E31546F64C23CD654002C1AA919ADD24DB12DDF85C6F3B58AE41198A28AD8DAF3B9588E7A629252BA3DB88F030D00BC1016110B2073359EAC3C13823C53245B65D056F2C070B940CDA09789585935C7ABA4D2AD4BED139281CFA1200000001001020084FF0020DDA4F260810200D71820D70B1FED44D0D31FD3FFD15112BAF2A122F901541044F910F2A2F80001D31F3120D74A96D307D402FB00DED1A4C8CB1FCBFFC9ED5400480000000055375F730EDC2292E8CB15C42E8036EE9C25AA958EE002D2DE48A205E3A3426B6290698B
(Saved to file new-wallet-query.boc)

ഇതിനർത്ഥം ഐഡി ഉള്ള വാലറ്റ് എന്നാണ് -1:4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2 (അല്ലെങ്കിൽ, എന്താണ് അതേ, 0f9PzVILj8yglrVn1zS-NSjtxr7QBfaTCp7JrBqnFPIR8nhZ) വിജയകരമായി സൃഷ്ടിച്ചു. അനുബന്ധ കോഡ് ഫയലിലുണ്ടാകും new-wallet-query.boc, അവന്റെ വിലാസം എന്നതിലാണ് new-wallet.addr, കൂടാതെ സ്വകാര്യ കീ അകത്തുണ്ട് new-wallet.pk (ശ്രദ്ധിക്കുക - സ്ക്രിപ്റ്റ് വീണ്ടും പ്രവർത്തിപ്പിക്കുന്നത് ഈ ഫയലുകളെ തിരുത്തിയെഴുതും).

തീർച്ചയായും, ഈ വാലറ്റിനെക്കുറിച്ച് TON നെറ്റ്‌വർക്കിന് ഇതുവരെ അറിയില്ല; ഇത് ഈ ഫയലുകളുടെ രൂപത്തിൽ മാത്രമേ സംഭരിച്ചിട്ടുള്ളൂ. ഇപ്പോൾ അത് നെറ്റ്‌വർക്കിലേക്ക് അപ്‌ലോഡ് ചെയ്യേണ്ടതുണ്ട്. എന്നിരുന്നാലും, ഒരു സ്മാർട്ട് കരാർ സൃഷ്ടിക്കുന്നതിന് നിങ്ങൾ ഒരു കമ്മീഷൻ നൽകേണ്ടതുണ്ട് എന്നതാണ് പ്രശ്നം, നിങ്ങളുടെ അക്കൗണ്ട് ബാലൻസ് ഇപ്പോഴും പൂജ്യമാണ്.

വർക്കിംഗ് മോഡിൽ, എക്സ്ചേഞ്ചിൽ ഗ്രാം വാങ്ങുന്നതിലൂടെ (അല്ലെങ്കിൽ മറ്റൊരു വാലറ്റിൽ നിന്ന് കൈമാറ്റം ചെയ്യുന്നതിലൂടെ) ഈ പ്രശ്നം പരിഹരിക്കപ്പെടും. ശരി, നിലവിലെ ടെസ്റ്റ് മോഡിൽ, ഒരു പ്രത്യേക സ്മാർട്ട് കരാർ സൃഷ്ടിച്ചു, അതിൽ നിന്ന് നിങ്ങൾക്ക് 20 ഗ്രാം വരെ ആവശ്യപ്പെടാം.

മറ്റൊരാളുടെ സ്‌മാർട്ട് കരാറിലേക്ക് ഒരു അഭ്യർത്ഥന സൃഷ്‌ടിക്കുന്നു

ഇതുപോലെ ഇടത്തോട്ടും വലത്തോട്ടും ഗ്രാം വിതരണം ചെയ്യുന്ന ഒരു സ്‌മാർട്ട് കരാറിലേക്ക് ഞങ്ങൾ ഒരു അഭ്യർത്ഥന നടത്തുന്നു. ഒരേ ഫോൾഡറിൽ crypto/block ഫയൽ കണ്ടെത്തുക testgiver.fif:

// "testgiver.addr" file>B 256 B>u@ 
0x8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d
dup constant wallet_addr ."Test giver address = " x. cr

0x4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2
constant dest_addr

-1 constant wc
0x00000011 constant seqno

1000000000 constant Gram
{ Gram swap */ } : Gram*/

6.666 Gram*/ constant amount

// b x --> b'  ( serializes a Gram amount )
{ -1 { 1+ 2dup 8 * ufits } until
  rot over 4 u, -rot 8 * u, } : Gram, 

// create a message (NB: 01b00.., b = bounce)
<b b{010000100} s, wc 8 i, dest_addr 256 u, amount Gram, 0 9 64 32 + + 1+ 1+ u, "GIFT" $, b>
<b seqno 32 u, 1 8 u, swap ref, b>
dup ."enveloping message: " <s csr. cr
<b b{1000100} s, wc 8 i, wallet_addr 256 u, 0 Gram, b{00} s,
   swap <s s, b>
dup ."resulting external message: " <s csr. cr
2 boc+>B dup Bx. cr
"wallet-query.boc" B>file

ഞങ്ങൾ അത് അസംബിൾ ചെയ്ത ക്ലയന്റിനൊപ്പം ഫോൾഡറിലും സംരക്ഷിക്കും, പക്ഷേ ഞങ്ങൾ അഞ്ചാമത്തെ വരി ശരിയാക്കും - വരിക്ക് മുമ്പ് "constant dest_addr". നിങ്ങൾ മുമ്പ് സൃഷ്ടിച്ച വാലറ്റിന്റെ വിലാസം ഉപയോഗിച്ച് ഇത് മാറ്റിസ്ഥാപിക്കാം (പൂർണ്ണമായി, ചുരുക്കിയതല്ല). തുടക്കത്തിൽ “-1:” എന്ന് എഴുതേണ്ട ആവശ്യമില്ല, പകരം തുടക്കത്തിൽ “0x” ഇടുക.

നിങ്ങൾക്ക് ലൈൻ മാറ്റാനും കഴിയും 6.666 Gram*/ constant amount - ഇത് നിങ്ങൾ അഭ്യർത്ഥിക്കുന്ന ഗ്രാമിലെ തുകയാണ് (20-ൽ കൂടരുത്). നിങ്ങൾ ഒരു പൂർണ്ണ സംഖ്യ വ്യക്തമാക്കിയാലും, ദശാംശ പോയിന്റ് വിടുക.

അവസാനമായി, നിങ്ങൾ ലൈൻ ശരിയാക്കേണ്ടതുണ്ട് 0x00000011 constant seqno. ഗ്രാം ഇഷ്യൂ ചെയ്യുന്ന അക്കൗണ്ടിൽ സംഭരിച്ചിരിക്കുന്ന നിലവിലെ സീക്വൻസ് നമ്പറാണ് ഇവിടെ ആദ്യ നമ്പർ. എനിക്ക് അത് എവിടെ നിന്ന് ലഭിക്കും? മുകളിൽ പറഞ്ഞതുപോലെ, ക്ലയന്റ് ആരംഭിച്ച് പ്രവർത്തിപ്പിക്കുക:

last
getaccount -1:8156775b79325e5d62e742d9b96c30b6515a5cd2f1f64c5da4b193c03f070e0d

അവസാനം, സ്മാർട്ട് കരാർ ഡാറ്റ അടങ്ങിയിരിക്കും

...
x{FF0020DDA4F260D31F01ED44D0D31FD166BAF2A1F80001D307D4D1821804A817C80073FB0201FB00A4C8CB1FC9ED54}
 x{0000000D}

0000000D എന്ന സംഖ്യയാണ് (നിങ്ങളുടേത് വലുതായിരിക്കും) പകരം വയ്ക്കേണ്ട സീക്വൻസ് നമ്പറാണ് testgiver.fif.

അത്രയേയുള്ളൂ, ഫയൽ സേവ് ചെയ്ത് പ്രവർത്തിപ്പിക്കുക (./crypto/fift testgiver.fif). ഔട്ട്പുട്ട് ഒരു ഫയൽ ആയിരിക്കും wallet-query.boc. ഇതാണ് രൂപപ്പെടുന്നത് സന്ദേശം മറ്റൊരാളുടെ മികച്ച കരാറിലേക്ക് - ഒരു അഭ്യർത്ഥന "അത്തരം അക്കൗണ്ടിലേക്ക് നിരവധി ഗ്രാം ട്രാൻസ്ഫർ ചെയ്യുക."

ക്ലയന്റ് ഉപയോഗിച്ച്, ഞങ്ങൾ അത് നെറ്റ്‌വർക്കിലേക്ക് അപ്‌ലോഡ് ചെയ്യുന്നു:

> sendfile wallet-query.boc
[ 1][t 1][1558747399.456575155][test-lite-client.cpp:577][!testnode]    sending query from file wallet-query.boc
[ 3][t 2][1558747399.500236034][test-lite-client.cpp:587][!query]   external message status is 1

ഇപ്പോൾ വിളിച്ചാൽ last, തുടർന്ന് ഞങ്ങൾ ഗ്രാം ആവശ്യപ്പെട്ട അക്കൗണ്ടിന്റെ സ്റ്റാറ്റസ് വീണ്ടും അഭ്യർത്ഥിക്കുക, തുടർന്ന് അതിന്റെ സീക്വൻസ് നമ്പർ ഒന്നായി വർദ്ധിച്ചതായി കാണണം - ഇതിനർത്ഥം അത് നമ്മുടെ അക്കൗണ്ടിലേക്ക് പണം അയച്ചുവെന്നാണ്.

അവസാന ഘട്ടം അവശേഷിക്കുന്നു - ഞങ്ങളുടെ വാലറ്റിന്റെ കോഡ് ഡൗൺലോഡ് ചെയ്യുക (അതിന്റെ ബാലൻസ് ഇതിനകം നിറച്ചിട്ടുണ്ട്, എന്നാൽ സ്മാർട്ട് കരാർ കോഡ് ഇല്ലാതെ ഞങ്ങൾക്ക് അത് കൈകാര്യം ചെയ്യാൻ കഴിയില്ല). ഞങ്ങൾ നടപ്പിലാക്കുന്നു sendfile new-wallet-query.boc - അത്രയേയുള്ളൂ, നിങ്ങൾക്ക് TON നെറ്റ്‌വർക്കിൽ നിങ്ങളുടെ സ്വന്തം വാലറ്റ് ഉണ്ട് (ഇത് ഇപ്പോൾ ഒരു പരീക്ഷണം മാത്രമാണെങ്കിൽ പോലും).

ഔട്ട്ഗോയിംഗ് ഇടപാടുകൾ സൃഷ്ടിക്കുന്നു

സൃഷ്ടിച്ച അക്കൗണ്ടിന്റെ ബാലൻസിൽ നിന്ന് പണം കൈമാറാൻ, ഒരു ഫയൽ ഉണ്ട് crypto/block/wallet.fif, ഇത് കൂടിച്ചേർന്ന ക്ലയന്റിനൊപ്പം ഫോൾഡറിൽ സ്ഥാപിക്കേണ്ടതുണ്ട്.

മുമ്പത്തെ ഘട്ടങ്ങൾക്ക് സമാനമായി, നിങ്ങൾ കൈമാറ്റം ചെയ്യുന്ന തുക, സ്വീകർത്താവിന്റെ വിലാസം (dest_addr), നിങ്ങളുടെ വാലറ്റിന്റെ സെക്നോ എന്നിവ ക്രമീകരിക്കേണ്ടതുണ്ട് (വാലറ്റ് ആരംഭിച്ചതിന് ശേഷം ഇത് 1 ന് തുല്യമാണ്, ഓരോ ഔട്ട്‌ഗോയിംഗ് ഇടപാടിന് ശേഷവും 1 വർദ്ധിപ്പിക്കും - നിങ്ങൾക്ക് കഴിയും നിങ്ങളുടെ അക്കൗണ്ടിന്റെ നില അഭ്യർത്ഥിച്ചുകൊണ്ട് അത് കാണുക) . പരിശോധനകൾക്കായി, നിങ്ങൾക്ക് ഉപയോഗിക്കാം, ഉദാഹരണത്തിന്, എന്റെ വാലറ്റ് - 0x4fcd520b8fcca096b567d734be3528edc6bed005f6930a9ec9ac1aa714f211f2.

തുടക്കത്തിൽ (./crypto/fift wallet.fif) സ്ക്രിപ്റ്റ് നിങ്ങളുടെ വാലറ്റിന്റെ വിലാസവും (നിങ്ങൾ കൈമാറുന്നിടത്ത് നിന്ന്) അതിന്റെ സ്വകാര്യ കീയും ഫയലുകളിൽ നിന്ന് എടുക്കും new-wallet.addr и new-wallet.pk, കൂടാതെ സ്വീകരിച്ച സന്ദേശം എഴുതപ്പെടും new-wallet-query.boc.

മുമ്പത്തെപ്പോലെ, നേരിട്ട് ഇടപാട് നടത്താൻ, വിളിക്കുക sendfile new-wallet-query.boc ക്ലയന്റിൽ. ഇതിനുശേഷം, ബ്ലോക്ക്ചെയിനിന്റെ അവസ്ഥ അപ്ഡേറ്റ് ചെയ്യാൻ മറക്കരുത് (last) കൂടാതെ ഞങ്ങളുടെ വാലറ്റിന്റെ ബാലൻസും സെക്നോയും മാറിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക (getaccount <account_id>).

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

രജിസ്റ്റർ ചെയ്ത ഉപയോക്താക്കൾക്ക് മാത്രമേ സർവേയിൽ പങ്കെടുക്കാൻ കഴിയൂ. സൈൻ ഇൻദയവായി.

TON, TVM, Fif എന്നിവയുടെ വിശകലനത്തോടെ ലേഖനങ്ങൾ തുടരാൻ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടോ?

• അതെ, TON-ന്റെ പൊതുവായ അവലോകനമുള്ള ലേഖനങ്ങളുടെ പരമ്പരയുടെ പൂർത്തീകരണത്തിനായി ഞാൻ കാത്തിരിക്കുകയാണ്

• അതെ, ഫിഫ്റ്റ് ഭാഷയെക്കുറിച്ച് കൂടുതൽ വായിക്കുന്നത് രസകരമാണ്

• അതെ, TON വെർച്വൽ മെഷീനിനെക്കുറിച്ചും അതിനുള്ള അസംബ്ലറെക്കുറിച്ചും കൂടുതലറിയാൻ ഞാൻ ആഗ്രഹിക്കുന്നു

• ഇല്ല, ഇതൊന്നും രസകരമല്ല

39 ഉപയോക്താക്കൾ വോട്ട് ചെയ്തു. 12 ഉപയോക്താക്കൾ വിട്ടുനിന്നു.

TON സമാരംഭിക്കാനുള്ള ടെലിഗ്രാമിന്റെ പദ്ധതികളെക്കുറിച്ച് നിങ്ങൾ എന്താണ് ചിന്തിക്കുന്നത്?

• ഈ പ്രോജക്ടിൽ എനിക്ക് വലിയ പ്രതീക്ഷയുണ്ട്

• ഞാൻ അതിന്റെ വികസനം താൽപ്പര്യത്തോടെ പിന്തുടരുന്നു.

• അതിന്റെ വിജയത്തിൽ എനിക്ക് സംശയവും സംശയവുമാണ്.

• ഈ സംരംഭം ഒരു പരാജയവും വിശാലമായ ജനവിഭാഗങ്ങൾക്ക് ആവശ്യമില്ലാത്തതുമാണെന്ന് കണക്കാക്കാൻ ഞാൻ ചായ്വുള്ളവനാണ്

47 ഉപയോക്താക്കൾ വോട്ട് ചെയ്തു. 12 ഉപയോക്താക്കൾ വിട്ടുനിന്നു.

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