TONలో స్మార్ట్ ఒప్పందాన్ని ఎలా వ్రాయాలి మరియు ప్రచురించాలి అనే దాని గురించి

ఈ కథనం దేనికి సంబంధించినది?

వ్యాసంలో నేను మొదటి (రెండు) టెలిగ్రామ్ బ్లాక్‌చెయిన్ పోటీలో ఎలా పాల్గొన్నాను, బహుమతి తీసుకోలేదు మరియు నా అనుభవాన్ని ఒక వ్యాసంలో రికార్డ్ చేయాలని నిర్ణయించుకున్నాను, తద్వారా అది ఉపేక్షలో మునిగిపోకుండా మరియు బహుశా సహాయం చేస్తుంది. ఎవరైనా.

నేను వియుక్త కోడ్‌ను వ్రాయకూడదనుకుంటున్నాను, కానీ ఏదైనా పని చేయడానికి, కథనం కోసం నేను తక్షణ లాటరీ కోసం స్మార్ట్ కాంట్రాక్ట్ మరియు ఇంటర్మీడియట్ నిల్వను ఉపయోగించకుండా TON నుండి నేరుగా స్మార్ట్ కాంట్రాక్ట్ డేటాను చూపించే వెబ్‌సైట్‌ను వ్రాసాను.

TONలో వారి మొదటి స్మార్ట్ కాంట్రాక్టును చేసుకోవాలనుకునే వారికి వ్యాసం ఉపయోగకరంగా ఉంటుంది, కానీ ఎక్కడ ప్రారంభించాలో తెలియదు.

లాటరీని ఉదాహరణగా ఉపయోగించి, నేను పర్యావరణాన్ని ఇన్‌స్టాల్ చేయడం నుండి స్మార్ట్ ఒప్పందాన్ని ప్రచురించడం, దానితో పరస్పర చర్య చేయడం మరియు డేటాను స్వీకరించడం మరియు ప్రచురించడం కోసం వెబ్‌సైట్‌ను వ్రాయడం వరకు వెళ్తాను.

పోటీలో పాల్గొనడం గురించి

గత అక్టోబర్‌లో, టెలిగ్రామ్ కొత్త భాషలతో బ్లాక్‌చెయిన్ పోటీని ప్రకటించింది Fift и FunC. ఐదు ప్రతిపాదిత స్మార్ట్ కాంట్రాక్ట్‌లలో దేనినైనా రాయడం నుండి ఎంచుకోవాల్సిన అవసరం ఉంది. భవిష్యత్తులో ఇంకేమీ రాయాల్సిన అవసరం లేకపోయినా, ఏదైనా డిఫరెంట్‌గా చేసి, భాష నేర్చుకుని, ఏదైనా చేస్తే బాగుంటుందని అనుకున్నాను. అదనంగా, అంశం నిరంతరం పెదవులపై ఉంటుంది.

స్మార్ట్ ఒప్పందాలను అభివృద్ధి చేయడంలో నాకు అనుభవం లేదని చెప్పడం విలువ.

నేను చేయగలిగినంత వరకు చివరి వరకు పాల్గొని, ఆపై సమీక్ష కథనాన్ని వ్రాయాలని నేను ప్లాన్ చేసాను, కానీ మొదటిదానిలో నేను వెంటనే విఫలమయ్యాను. I ఒక పర్సు రాశాడు బహుళ సంతకంతో FunC మరియు ఇది సాధారణంగా పని చేస్తుంది. నేను దానిని ప్రాతిపదికగా తీసుకున్నాను సాలిడిటీపై స్మార్ట్ ఒప్పందం.

ఆ సమయంలో, కనీసం కొంత ప్రైజ్ ప్లేస్ తీసుకోవాలంటే ఇది ఖచ్చితంగా సరిపోతుందని నేను అనుకున్నాను. ఫలితంగా, పాల్గొన్న 40 మందిలో 60 మంది బహుమతి విజేతలుగా నిలిచారు మరియు నేను వారిలో లేను. సాధారణంగా, ఇందులో తప్పు ఏమీ లేదు, కానీ ఒక విషయం నన్ను బాధించింది. ఫలితాల ప్రకటన సమయంలో, నా కాంట్రాక్ట్ కోసం పరీక్ష యొక్క సమీక్ష జరగలేదు, నేను చాట్‌లో పాల్గొనేవారిని అది లేనివారు ఎవరైనా ఉన్నారా అని అడిగాను, ఎవరూ లేరు.

స్పష్టంగా నా సందేశాలపై శ్రద్ధ చూపుతూ, రెండు రోజుల తర్వాత న్యాయమూర్తులు ఒక వ్యాఖ్యను ప్రచురించారు మరియు తీర్పు సమయంలో వారు అనుకోకుండా నా స్మార్ట్ ఒప్పందాన్ని కోల్పోయారా లేదా వ్యాఖ్యానించాల్సిన అవసరం లేదని అది చాలా చెడ్డదని అనుకున్నారా అని నాకు ఇప్పటికీ అర్థం కాలేదు. నేను పేజీలో ఒక ప్రశ్న అడిగాను, కానీ సమాధానం రాలేదు. ఎవరు తీర్పు చెప్పారనేది రహస్యం కానప్పటికీ, వ్యక్తిగత సందేశాలు రాయడం అనవసరమని నేను భావించాను.

అర్థం చేసుకోవడానికి చాలా సమయం కేటాయించబడింది, కాబట్టి ఇది ఒక వ్యాసం రాయాలని నిర్ణయించుకుంది. ఇంకా చాలా సమాచారం లేనందున, ఈ కథనం ఆసక్తి ఉన్న ప్రతి ఒక్కరికీ సమయాన్ని ఆదా చేయడంలో సహాయపడుతుంది.

TONలో స్మార్ట్ ఒప్పందాల భావన

మీరు ఏదైనా వ్రాసే ముందు, ఈ విషయాన్ని ఏ వైపు నుండి సంప్రదించాలో మీరు గుర్తించాలి. అందువల్ల, సిస్టమ్ ఏ భాగాలను కలిగి ఉందో ఇప్పుడు నేను మీకు చెప్తాను. మరింత ఖచ్చితంగా, కనీసం రకమైన పని ఒప్పందాన్ని వ్రాయడానికి మీరు ఏ భాగాలను తెలుసుకోవాలి.

మేము స్మార్ట్ ఒప్పందాన్ని వ్రాయడం మరియు పని చేయడంపై దృష్టి పెడతాము TON Virtual Machine (TVM), Fift и FunC, కాబట్టి వ్యాసం సాధారణ ప్రోగ్రామ్ యొక్క అభివృద్ధి యొక్క వివరణ వలె ఉంటుంది. ప్లాట్‌ఫారమ్ ఇక్కడ ఎలా పని చేస్తుందనే దానిపై మేము నివసించము.

ఇది ఎలా పని చేస్తుందో సాధారణంగా TVM మరియు భాష Fift మంచి అధికారిక డాక్యుమెంటేషన్ ఉంది. పోటీలో పాల్గొంటున్నప్పుడు మరియు ఇప్పుడు ప్రస్తుత ఒప్పందం వ్రాసేటప్పుడు, నేను తరచుగా ఆమె వైపు తిరిగాను.

స్మార్ట్ ఒప్పందాలు వ్రాయబడిన ప్రధాన భాష FunC. ప్రస్తుతానికి దానిపై డాక్యుమెంటేషన్ లేదు, కాబట్టి ఏదైనా వ్రాయడానికి మీరు అధికారిక రిపోజిటరీ నుండి స్మార్ట్ కాంట్రాక్టుల ఉదాహరణలను మరియు అక్కడ భాషను అమలు చేయడం గురించి అధ్యయనం చేయాలి, అలాగే మీరు గత రెండు నుండి స్మార్ట్ ఒప్పందాల ఉదాహరణలను చూడవచ్చు. పోటీలు. వ్యాసం చివర లింక్‌లు.

మేము ఇప్పటికే స్మార్ట్ కాంట్రాక్టును వ్రాసాము FunC, ఆ తర్వాత మేము కోడ్‌ను ఫిఫ్ట్ అసెంబ్లర్‌లో కంపైల్ చేస్తాము.

సంకలనం చేయబడిన స్మార్ట్ కాంట్రాక్ట్ ప్రచురించబడవలసి ఉంది. దీన్ని చేయడానికి, మీరు ఒక ఫంక్షన్‌ని వ్రాయాలి Fift, ఇది స్మార్ట్ కాంట్రాక్ట్ కోడ్ మరియు కొన్ని ఇతర పారామితులను ఇన్‌పుట్‌గా తీసుకుంటుంది మరియు అవుట్‌పుట్ పొడిగింపుతో కూడిన ఫైల్ అవుతుంది .boc (దీని అర్థం "కణాల బ్యాగ్"), మరియు, మనం దీన్ని ఎలా వ్రాస్తాము అనేదానిపై ఆధారపడి, స్మార్ట్ కాంట్రాక్ట్ కోడ్ ఆధారంగా రూపొందించబడే ప్రైవేట్ కీ మరియు చిరునామా. మీరు ఇప్పటికే పబ్లిష్ చేయని స్మార్ట్ కాంట్రాక్ట్ చిరునామాకు గ్రాములు పంపవచ్చు.

TONలో స్మార్ట్ ఒప్పందాన్ని ప్రచురించడానికి స్వీకరించబడింది .boc ఫైల్‌ను లైట్ క్లయింట్‌ని ఉపయోగించి బ్లాక్‌చెయిన్‌కు పంపవలసి ఉంటుంది (క్రింద ఉన్న వాటిపై మరిన్ని). కానీ ప్రచురించే ముందు, మీరు సృష్టించిన చిరునామాకు గ్రాములను బదిలీ చేయాలి, లేకపోతే స్మార్ట్ ఒప్పందం ప్రచురించబడదు. ప్రచురణ తర్వాత, మీరు స్మార్ట్ కాంట్రాక్ట్‌కు బయటి నుండి (ఉదాహరణకు, తేలికపాటి క్లయింట్‌ని ఉపయోగించి) లేదా లోపలి నుండి సందేశాలను పంపడం ద్వారా దానితో పరస్పర చర్య చేయవచ్చు (ఉదాహరణకు, ఒక స్మార్ట్ ఒప్పందం TON లోపల మరొక సందేశాన్ని పంపుతుంది).

కోడ్ ఎలా ప్రచురించబడుతుందో అర్థం చేసుకున్న తర్వాత, అది సులభం అవుతుంది. మేము ఏమి వ్రాయాలనుకుంటున్నాము మరియు మా ప్రోగ్రామ్ ఎలా పని చేస్తుందో మాకు సుమారుగా తెలుసు. మరియు వ్రాస్తున్నప్పుడు, ఇప్పటికే ఉన్న స్మార్ట్ కాంట్రాక్టులలో ఇది ఎలా అమలు చేయబడిందో మేము చూస్తాము లేదా మేము అమలు కోడ్‌ను పరిశీలిస్తాము Fift и FunC అధికారిక రిపోజిటరీలో లేదా అధికారిక డాక్యుమెంటేషన్‌లో చూడండి.

చాలా తరచుగా నేను టెలిగ్రామ్ చాట్‌లో కీలకపదాల కోసం శోధించాను, అక్కడ పోటీలో పాల్గొనేవారు మరియు టెలిగ్రామ్ ఉద్యోగులు అందరూ సమావేశమయ్యారు మరియు పోటీ సమయంలో అందరూ అక్కడ గుమిగూడి ఫిఫ్ట్ మరియు ఫన్‌సి గురించి చర్చించడం ప్రారంభించారు. వ్యాసం చివర లింక్.

ఇది సిద్ధాంతం నుండి అభ్యాసానికి వెళ్ళే సమయం.

TONతో పని చేయడానికి వాతావరణాన్ని సిద్ధం చేస్తోంది

MacOS గురించిన వ్యాసంలో వివరించబోయే ప్రతిదాన్ని నేను చేశాను మరియు దానిని ఒక క్లీన్ సిస్టమ్‌లో రెండుసార్లు తనిఖీ చేశాను. Ubuntu డాకర్‌పై 18.04 LTS.

మీరు చేయవలసిన మొదటి విషయం డౌన్‌లోడ్ చేసి ఇన్‌స్టాల్ చేయడం lite-client దీనితో మీరు TONకి అభ్యర్థనలను పంపవచ్చు.

అధికారిక వెబ్‌సైట్‌లోని సూచనలు, కొన్ని వివరాలను వదిలివేసి, ఇన్‌స్టాలేషన్ ప్రక్రియను చాలా క్షుణ్ణంగా మరియు స్పష్టంగా వివరిస్తాయి. ఇక్కడ మనం ఆ సూచనలను అనుసరిస్తూ, మధ్యలో ఏవైనా లోపించిన డిపెండెన్సీలను ఇన్‌స్టాల్ చేస్తాము. నేను ప్రతి ప్రాజెక్ట్‌ను స్వయంగా కంపైల్ చేయలేదు మరియు అధికారిక రిపోజిటరీ నుండి ఇన్‌స్టాల్ చేసాను. Ubuntu 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 కోసం కోడ్‌ను హైలైట్ చేసాను; విజువల్ స్టూడియో కోడ్ శోధనలో ప్లగ్ఇన్ కనుగొనబడుతుంది మరియు ఇన్‌స్టాల్ చేయబడుతుంది; మీరు అకస్మాత్తుగా ఏదైనా జోడించాలనుకుంటే, నేను ప్లగిన్‌ను పబ్లిక్‌గా అందుబాటులో ఉంచాను. అలాగే, ఎవరైనా ఇంతకుముందు ఫిఫ్ట్‌తో పనిచేయడానికి ప్లగ్ఇన్ చేసారు, మీరు దీన్ని ఇన్‌స్టాల్ చేసి 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. దీన్ని చేయడానికి, ఇంటరాక్టివ్ మోడ్‌లో ఫిఫ్ట్‌ను ప్రారంభిద్దాం మరియు నాలుగు ఆదేశాలను అమలు చేయండి.

`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 భవిష్యత్తు గురించి మాట్లాడను. బహుశా ప్లాట్‌ఫారమ్ ఏదో పెద్దదిగా మారవచ్చు మరియు మేము దానిని అధ్యయనం చేయడానికి సమయాన్ని వెచ్చించాలి మరియు ఇప్పుడు మా ఉత్పత్తులతో సముచిత స్థానాన్ని నింపాలి.

Facebook నుండి తులం కూడా ఉంది, ఇది TON కంటే ఎక్కువ వినియోగదారుల సంభావ్య ప్రేక్షకులను కలిగి ఉంది. తులారాశి గురించి నాకు దాదాపు ఏమీ తెలియదు, ఫోరమ్‌ని బట్టి చూస్తే TON కమ్యూనిటీలో కంటే చాలా ఎక్కువ కార్యాచరణ ఉంది. TON యొక్క డెవలపర్‌లు మరియు కమ్యూనిటీ భూగర్భంలో ఉన్నప్పటికీ, ఇది కూడా బాగుంది.

సూచనలు

అధికారిక TON డాక్యుమెంటేషన్: https://test.ton.org
అధికారిక TON రిపోజిటరీ: https://github.com/ton-blockchain/ton
వివిధ ప్లాట్‌ఫారమ్‌ల కోసం అధికారిక వాలెట్: https://wallet.ton.org
ఈ కథనం నుండి స్మార్ట్ కాంట్రాక్ట్ రిపోజిటరీ: https://github.com/raiym/astonished
స్మార్ట్ కాంట్రాక్ట్ వెబ్‌సైట్‌కి లింక్: https://ton-lottery.appspot.com
FunC కోసం విజువల్ స్టూడియో కోడ్ కోసం పొడిగింపు కోసం రిపోజిటరీ: https://github.com/raiym/func-visual-studio-plugin
టెలిగ్రామ్‌లో TON గురించి చాట్ చేయండి, ఇది ప్రారంభ దశలో దాన్ని గుర్తించడంలో నిజంగా సహాయపడింది. TON కోసం ఏదైనా వ్రాసిన ప్రతి ఒక్కరూ అక్కడ ఉన్నారని నేను చెబితే అది తప్పు కాదని నేను భావిస్తున్నాను. మీరు అక్కడ టెస్ట్ గ్రాములను కూడా అడగవచ్చు. https://t.me/tondev_ru
TON గురించి మరొక చాట్‌లో నేను ఉపయోగకరమైన సమాచారాన్ని కనుగొన్నాను: https://t.me/TONgramDev
పోటీ మొదటి దశ: https://contest.com/blockchain
పోటీ రెండవ దశ: https://contest.com/blockchain-2