TON میں سمارٹ کنٹریکٹ لکھنے اور شائع کرنے کے بارے میں

یہ مضمون کس بارے میں ہے؟

مضمون میں میں اس بارے میں بات کروں گا کہ کس طرح میں نے ٹیلی گرام بلاک چین کے پہلے (دو میں سے) مقابلے میں حصہ لیا، کوئی انعام نہیں لیا، اور اپنے تجربے کو ایک مضمون میں ریکارڈ کرنے کا فیصلہ کیا تاکہ یہ فراموشی میں نہ ڈوب جائے اور شاید، مدد کر سکے۔ کسی.

چونکہ میں تجریدی کوڈ نہیں لکھنا چاہتا تھا، لیکن کچھ کام کرنے کے لیے، اس مضمون کے لیے میں نے فوری لاٹری کے لیے ایک سمارٹ کنٹریکٹ لکھا اور ایک ایسی ویب سائٹ جو انٹرمیڈیٹ اسٹوریج استعمال کیے بغیر براہ راست TON سے سمارٹ کنٹریکٹ ڈیٹا دکھاتی ہے۔

مضمون ان لوگوں کے لیے کارآمد ہوگا جو TON میں اپنا پہلا سمارٹ معاہدہ کرنا چاہتے ہیں، لیکن نہیں جانتے کہ کہاں سے آغاز کرنا ہے۔

مثال کے طور پر لاٹری کا استعمال کرتے ہوئے، میں ماحول کو انسٹال کرنے سے لے کر ایک سمارٹ کنٹریکٹ شائع کرنے، اس کے ساتھ بات چیت کرنے، اور ڈیٹا حاصل کرنے اور شائع کرنے کے لیے ویب سائٹ لکھنے تک جاؤں گا۔

مقابلے میں شرکت کے بارے میں

گزشتہ اکتوبر میں، ٹیلیگرام نے نئی زبانوں کے ساتھ بلاک چین مقابلے کا اعلان کیا۔ Fift и FunC. پانچ مجوزہ سمارٹ معاہدوں میں سے کسی کو بھی لکھنا ضروری تھا۔ میں نے سوچا کہ کچھ مختلف کرنا اچھا ہو گا، کوئی زبان سیکھوں اور کچھ بناؤں، چاہے مجھے مستقبل میں کچھ اور نہ لکھنا پڑے۔ اس کے علاوہ، موضوع مسلسل ہونٹوں پر ہے.

یہ کہنا قابل ہے کہ مجھے سمارٹ معاہدوں کو تیار کرنے کا کوئی تجربہ نہیں تھا۔

میں نے آخر تک حصہ لینے کا ارادہ کیا جب تک کہ میں نہ کرسکا اور پھر ایک جائزہ مضمون لکھوں، لیکن میں فوراً پہلے ہی ناکام ہوگیا۔ میں ایک پرس لکھا کثیر دستخط کے ساتھ FunC اور یہ عام طور پر کام کرتا ہے. میں نے اسے ایک بنیاد کے طور پر لیا سالیڈیٹی پر سمارٹ معاہدہ.

اس وقت، میں نے سوچا کہ یہ یقینی طور پر کم از کم انعام کی جگہ لینے کے لیے کافی ہے۔ نتیجے کے طور پر، 40 میں سے تقریباً 60 شرکاء انعام یافتہ بن گئے اور میں ان میں شامل نہیں تھا۔ عام طور پر اس میں کوئی حرج نہیں لیکن ایک بات نے مجھے پریشان کیا۔ نتائج کے اعلان کے وقت، میرے معاہدے کے ٹیسٹ کا جائزہ نہیں لیا گیا تھا، میں نے چیٹ میں شریک افراد سے پوچھا کہ کیا کوئی اور ہے جس کے پاس نہیں ہے، وہاں کوئی نہیں تھا۔

بظاہر میرے پیغامات پر دھیان دیتے ہوئے، دو دن بعد ججز نے ایک تبصرہ شائع کیا اور مجھے ابھی تک یہ سمجھ نہیں آئی کہ آیا انہوں نے فیصلہ کے دوران غلطی سے میرا سمارٹ کنٹریکٹ چھوٹ دیا یا صرف یہ سوچا کہ یہ اتنا برا تھا کہ اس پر تبصرہ کی ضرورت نہیں تھی۔ میں نے صفحہ پر ایک سوال پوچھا، لیکن جواب نہیں ملا۔ اگرچہ یہ کوئی راز نہیں ہے کہ فیصلہ کس نے کیا، میں نے ذاتی پیغامات لکھنا غیر ضروری سمجھا۔

افہام و تفہیم میں کافی وقت صرف ہوا، اس لیے مضمون لکھنے کا فیصلہ ہوا۔ چونکہ ابھی تک بہت زیادہ معلومات نہیں ہیں، اس لیے یہ مضمون ہر دلچسپی رکھنے والے کے لیے وقت بچانے میں مدد کرے گا۔

TON میں سمارٹ معاہدوں کا تصور

اس سے پہلے کہ آپ کچھ بھی لکھیں، آپ کو یہ معلوم کرنا ہوگا کہ اس چیز کو کس طرف سے جانا ہے۔ اس لیے اب میں آپ کو بتاؤں گا کہ سسٹم کن حصوں پر مشتمل ہے۔ زیادہ واضح طور پر، کم از کم کسی قسم کا ورکنگ کنٹریکٹ لکھنے کے لیے آپ کو کن حصوں کو جاننے کی ضرورت ہے۔

ہم ایک سمارٹ معاہدہ لکھنے اور اس کے ساتھ کام کرنے پر توجہ مرکوز کریں گے۔ TON Virtual Machine (TVM), Fift и FunC، لہذا مضمون ایک باقاعدہ پروگرام کی ترقی کی وضاحت کی طرح ہے۔ ہم اس بات پر غور نہیں کریں گے کہ پلیٹ فارم خود یہاں کیسے کام کرتا ہے۔

عام طور پر یہ کیسے کام کرتا ہے۔ TVM اور زبان Fift اچھی سرکاری دستاویزات موجود ہیں۔ مقابلے میں حصہ لیتے ہوئے اور اب موجودہ معاہدہ لکھتے ہوئے میں اکثر اس کی طرف متوجہ ہوتا تھا۔

مرکزی زبان جس میں سمارٹ معاہدے لکھے جاتے ہیں۔ FunC. اس وقت اس پر کوئی دستاویز نہیں ہے، اس لیے کچھ لکھنے کے لیے آپ کو سرکاری ذخیرے سے سمارٹ معاہدوں کی مثالوں کا مطالعہ کرنے کی ضرورت ہے اور وہاں خود زبان کے نفاذ کے علاوہ آپ پچھلے دو سمارٹ معاہدوں کی مثالیں بھی دیکھ سکتے ہیں۔ مقابلے مضمون کے آخر میں لنکس۔

ہم کہتے ہیں کہ ہم نے پہلے ہی ایک سمارٹ معاہدہ لکھا ہے۔ FunCاس کے بعد ہم کوڈ کو ففٹ اسمبلر میں مرتب کرتے ہیں۔

مرتب شدہ سمارٹ معاہدہ شائع ہونا باقی ہے۔ ایسا کرنے کے لیے آپ کو ایک فنکشن لکھنا ہوگا۔ Fift، جو سمارٹ کنٹریکٹ کوڈ اور کچھ دوسرے پیرامیٹرز کو ان پٹ کے طور پر لے گا، اور آؤٹ پٹ ایکسٹینشن والی فائل ہو گی۔ .boc (جس کا مطلب ہے "خلیوں کا تھیلا")، اور، اس بات پر منحصر ہے کہ ہم اسے کیسے لکھتے ہیں، ایک نجی کلید اور پتہ، جو سمارٹ کنٹریکٹ کوڈ کی بنیاد پر تیار کیا جاتا ہے۔ آپ پہلے ہی ایک سمارٹ کنٹریکٹ کے پتے پر گرام بھیج سکتے ہیں جو ابھی تک شائع نہیں ہوا ہے۔

موصولہ TON میں ایک سمارٹ معاہدہ شائع کرنے کے لیے .boc فائل کو ہلکے کلائنٹ کا استعمال کرتے ہوئے بلاکچین کو بھیجنے کی ضرورت ہوگی (نیچے اس پر مزید)۔ لیکن شائع کرنے سے پہلے، آپ کو گرام کو پیدا کردہ ایڈریس پر منتقل کرنے کی ضرورت ہے، ورنہ سمارٹ معاہدہ شائع نہیں کیا جائے گا۔ اشاعت کے بعد، آپ سمارٹ کنٹریکٹ کے ساتھ باہر سے پیغامات بھیج کر (مثال کے طور پر ہلکے کلائنٹ کا استعمال کرتے ہوئے) یا اندر سے بات چیت کر سکتے ہیں (مثال کے طور پر، ایک سمارٹ کنٹریکٹ دوسرے کو TON کے اندر پیغام بھیجتا ہے)۔

ایک بار جب ہم سمجھ لیں کہ کوڈ کیسے شائع ہوتا ہے، تو یہ آسان ہو جاتا ہے۔ ہم تقریباً جانتے ہیں کہ ہم کیا لکھنا چاہتے ہیں اور ہمارا پروگرام کیسے کام کرے گا۔ اور لکھتے وقت، ہم دیکھتے ہیں کہ یہ موجودہ سمارٹ معاہدوں میں پہلے سے کیسے لاگو ہوتا ہے، یا ہم نفاذ کوڈ کو دیکھتے ہیں۔ Fift и FunC سرکاری ذخیرہ میں، یا سرکاری دستاویزات میں دیکھیں۔

میں اکثر ٹیلیگرام چیٹ میں کلیدی الفاظ تلاش کرتا تھا جہاں مقابلے کے تمام شرکاء اور ٹیلی گرام کے ملازمین جمع ہوتے تھے، اور ایسا ہوا کہ مقابلے کے دوران سب وہاں جمع ہو گئے اور ففٹ اور فن سی پر بحث شروع کر دی۔ مضمون کے آخر میں لنک۔

یہ تھیوری سے پریکٹس کی طرف جانے کا وقت ہے۔

TON کے ساتھ کام کرنے کے لیے ماحول کی تیاری

میں نے وہ سب کچھ کیا جو MacOS پر مضمون میں بیان کیا جائے گا اور Docker پر کلین Ubuntu 18.04 LTS میں اسے ڈبل چیک کیا۔

سب سے پہلے آپ کو ڈاؤن لوڈ اور انسٹال کرنے کی ضرورت ہے۔ 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 Blockchain میں ذخیرہ شدہ تمام ڈیٹا ایک مجموعہ ہے۔ 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، یہ ففٹ اسمبلر کے لیے Fift میں لکھا ہوا کوڈ ہے۔

چونکہ ہم سمارٹ کنٹریکٹ کو مقامی طور پر چلانا اور جانچنا چاہتے ہیں، اس لیے ہم ایک فائل بنائیں گے۔ 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. سہولت کے لیے، سائٹ کو ڈوکر میں پیک کیا گیا ہے اور گوگل کلاؤڈ پر شائع کیا گیا ہے۔ لنک.

کوشش کرتے ہیں

اب یہاں سے دوبارہ بھرنے کے لیے گرام بھیجنے کی کوشش کرتے ہیں۔ پرس. ہم 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. فن سی کے لیے بصری اسٹوڈیو کوڈ کی توسیع کے لیے ذخیرہ: 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