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 સાથે કામ કરવા માટે વાતાવરણ તૈયાર કરવું

મેં મેકઓએસ પરના લેખમાં વર્ણવેલ બધું જ કર્યું અને તેને ડોકર પર સ્વચ્છ ઉબુન્ટુ 18.04 એલટીએસમાં બે વાર ચેક કર્યું.

તમારે પ્રથમ વસ્તુ ડાઉનલોડ અને ઇન્સ્ટોલ કરવાની જરૂર છે lite-client જેની મદદથી તમે TON ને વિનંતીઓ મોકલી શકો છો.

અધિકૃત વેબસાઇટ પરની સૂચનાઓ ઇન્સ્ટોલેશન પ્રક્રિયાને ખૂબ વિગતવાર અને સ્પષ્ટ રીતે વર્ણવે છે અને કેટલીક વિગતોને છોડી દે છે. અહીં અમે સૂચનાઓનું પાલન કરીએ છીએ, રસ્તામાં ખૂટતી અવલંબનને ઇન્સ્ટોલ કરીએ છીએ. મેં દરેક પ્રોજેક્ટ જાતે કમ્પાઈલ કર્યો નથી અને સત્તાવાર ઉબુન્ટુ રિપોઝીટરીમાંથી ઇન્સ્ટોલ કર્યું નથી (મેકઓએસ પર મેં ઉપયોગ કર્યો હતો 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 માટે કોડ હાઇલાઇટ કર્યો છે; પ્લગઇન વિઝ્યુઅલ સ્ટુડિયો કોડ શોધમાં શોધી અને ઇન્સ્ટોલ કરી શકાય છે; જો તમે અચાનક કંઈક ઉમેરવા માંગતા હો, તો મેં પ્લગઇનને સાર્વજનિક રૂપે ઉપલબ્ધ કરાવ્યું છે. ઉપરાંત, કોઈએ અગાઉ ફિફ્ટ સાથે કામ કરવા માટે પ્લગઇન બનાવ્યું હતું, તમે તેને ઇન્સ્ટોલ પણ કરી શકો છો અને તેને VSC માં શોધી શકો છો.

ચાલો તરત જ એક રીપોઝીટરી બનાવીએ જ્યાં આપણે મધ્યવર્તી પરિણામો આપીશું.

આપણું જીવન સરળ બનાવવા માટે, અમે સ્માર્ટ કોન્ટ્રાક્ટ લખીશું અને જ્યાં સુધી તે તૈયાર ન થાય ત્યાં સુધી સ્થાનિક સ્તરે તેનું પરીક્ષણ કરીશું. તે પછી જ અમે તેને 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

અત્યાર સુધી તે સ્પષ્ટ જણાય છે, હવે ચાલો એ જ ફાઇલમાં કોડ ઉમેરીએ જેનો ઉપયોગ આપણે TVM લોન્ચ કરવા માટે કરીશું.

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 અમે સંદર્ભ રેકોર્ડ કરીએ છીએ, એટલે કે, ડેટા કે જેની સાથે TVM (અથવા નેટવર્ક સ્થિતિ) લોન્ચ કરવામાં આવશે. સ્પર્ધા દરમિયાન પણ, એક વિકાસકર્તાએ કેવી રીતે બનાવવું તે બતાવ્યું 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 ! 

અમે સ્થિરાંકો અને ચલો તૈયાર કર્યા પછી, અમે આદેશનો ઉપયોગ કરીને TVM શરૂ કરીએ છીએ 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. આ કરવા માટે, ચાલો Fift ને ઇન્ટરેક્ટિવ મોડમાં લોંચ કરીએ અને ચાર આદેશો ચલાવીએ.

`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 ગ્રામ મોકલીશું. અને ચાલો સ્પષ્ટતા માટે બે બેટ્સ બનાવીએ. અમે જોઈએ છીએ કે સાઇટ બેટ્સનો ઇતિહાસ, વર્તમાન જીતની ટકાવારી અને અન્ય ઉપયોગી માહિતી દર્શાવે છે.

આપણે જોઈએ છીએકે અમે પહેલો જીત્યો, બીજો હારી ગયો.

ઉચ્ચારણ

લેખ મારી ધારણા કરતાં ઘણો લાંબો નીકળ્યો, કદાચ તે ટૂંકો હોઈ શકે, અથવા કદાચ માત્ર એવી વ્યક્તિ માટે કે જે TON વિશે કશું જ જાણતા નથી અને સાથે ક્રિયાપ્રતિક્રિયા કરવાની ક્ષમતા સાથેનો-એટલો સરળ સ્માર્ટ કરાર લખવા અને પ્રકાશિત કરવા માંગે છે. તે કદાચ કેટલીક બાબતો વધુ સરળ રીતે સમજાવી શકાઈ હોત.

કદાચ અમલીકરણના કેટલાક પાસાઓ વધુ કાર્યક્ષમ અને સુંદર રીતે કરવામાં આવ્યા હોત, પરંતુ તે પછી લેખ તૈયાર કરવામાં વધુ સમય લાગ્યો હોત. તે પણ શક્ય છે કે મેં ક્યાંક ભૂલ કરી હોય અથવા કંઈક સમજાયું ન હોય, તેથી જો તમે કંઈક ગંભીર કરી રહ્યાં છો, તો તમારે સત્તાવાર દસ્તાવેજો અથવા TON કોડ સાથેના સત્તાવાર ભંડાર પર આધાર રાખવાની જરૂર છે.

એ નોંધવું જોઇએ કે TON પોતે હજી વિકાસના સક્રિય તબક્કામાં છે, ફેરફારો આવી શકે છે જે આ લેખના કોઈપણ પગલાને તોડી નાખશે (જે હું લખતો હતો ત્યારે થયું હતું, તે પહેલાથી જ સુધારેલ છે), પરંતુ સામાન્ય અભિગમ છે. ફેરફાર થવાની શક્યતા નથી.

હું TON ના ભવિષ્ય વિશે વાત કરીશ નહીં. કદાચ પ્લેટફોર્મ કંઈક મોટું બનશે અને આપણે તેનો અભ્યાસ કરવા માટે સમય પસાર કરવો જોઈએ અને હવે અમારા ઉત્પાદનો સાથે વિશિષ્ટ સ્થાન ભરવું જોઈએ.

ફેસબુક તરફથી તુલા રાશિ પણ છે, જેમાં TON કરતા મોટા વપરાશકર્તાઓના સંભવિત પ્રેક્ષકો છે. હું તુલા રાશિ વિશે લગભગ કંઈ જાણતો નથી, ફોરમ દ્વારા નક્કી કરવામાં આવે છે કે ત્યાં TON સમુદાય કરતાં ઘણી વધુ પ્રવૃત્તિ છે. જોકે 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