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 ಅಧಿಕೃತ ಭಂಡಾರದಲ್ಲಿ, ಅಥವಾ ಅಧಿಕೃತ ದಸ್ತಾವೇಜನ್ನು ನೋಡಿ.

ಟೆಲಿಗ್ರಾಮ್ ಚಾಟ್‌ನಲ್ಲಿ ನಾನು ಆಗಾಗ್ಗೆ ಕೀವರ್ಡ್‌ಗಳನ್ನು ಹುಡುಕುತ್ತಿದ್ದೆ, ಅಲ್ಲಿ ಸ್ಪರ್ಧೆಯ ಎಲ್ಲಾ ಭಾಗವಹಿಸುವವರು ಮತ್ತು ಟೆಲಿಗ್ರಾಮ್ ಉದ್ಯೋಗಿಗಳು ಒಟ್ಟುಗೂಡಿದರು, ಸ್ಪರ್ಧೆಯ ಸಮಯದಲ್ಲಿ ಎಲ್ಲರೂ ಅಲ್ಲಿ ಒಟ್ಟುಗೂಡಿದರು ಮತ್ತು 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 ಗಾಗಿ ಕೋಡ್ ಹೈಲೈಟ್ ಮಾಡಿದ್ದೇನೆ, ಪ್ಲಗಿನ್ ಅನ್ನು ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋ ಕೋಡ್ ಹುಡುಕಾಟದಲ್ಲಿ ಕಾಣಬಹುದು ಮತ್ತು ಸ್ಥಾಪಿಸಬಹುದು, ನೀವು ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಏನನ್ನಾದರೂ ಸೇರಿಸಲು ಬಯಸಿದರೆ, ನಾನು ಪ್ಲಗಿನ್ ಅನ್ನು ಸಾರ್ವಜನಿಕ ಡೊಮೇನ್‌ನಲ್ಲಿ ಪೋಸ್ಟ್ ಮಾಡಿದ್ದೇನೆ. ಅಲ್ಲದೆ, ಈ ಹಿಂದೆ ಯಾರಾದರೂ Fift ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಪ್ಲಗಿನ್ ಅನ್ನು ಮಾಡಿದ್ದಾರೆ, ನೀವು ಅದನ್ನು ಸ್ಥಾಪಿಸಬಹುದು ಮತ್ತು 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 ನಾವು ಸಂದರ್ಭವನ್ನು ದಾಖಲಿಸುತ್ತೇವೆ, ಅಂದರೆ, ಟಿವಿಎಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಡೇಟಾ (ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಸ್ಥಿತಿ). ಸ್ಪರ್ಧೆಯ ಸಮಯದಲ್ಲಿಯೂ ಸಹ, ಡೆವಲಪರ್‌ಗಳಲ್ಲಿ ಒಬ್ಬರು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ತೋರಿಸಿದರು c7 ಮತ್ತು ನಾನು ಅದನ್ನು ನಕಲಿಸಿದ್ದೇನೆ. ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಬದಲಾಯಿಸಬೇಕಾಗಬಹುದು rand_seed ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಉತ್ಪಾದನೆಯು ಅದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ, ಪ್ರತಿ ಬಾರಿಯೂ ಅದೇ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

recv_internal и recv_external 0 ಮತ್ತು -1 ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಸ್ಥಿರಾಂಕಗಳು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಲ್ಲಿ ಅನುಗುಣವಾದ ಕಾರ್ಯಗಳನ್ನು ಕರೆಯಲು ಜವಾಬ್ದಾರರಾಗಿರುತ್ತವೆ.

ಈಗ ನಾವು ನಮ್ಮ ಖಾಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಕ್ಕಾಗಿ ಮೊದಲ ಪರೀಕ್ಷೆಯನ್ನು ರಚಿಸಲು ಸಿದ್ಧರಿದ್ದೇವೆ. ಸ್ಪಷ್ಟತೆಗಾಗಿ, ನಾವು ಇದೀಗ ಎಲ್ಲಾ ಪರೀಕ್ಷೆಗಳನ್ನು ಒಂದೇ ಫೈಲ್‌ಗೆ ಸೇರಿಸುತ್ತೇವೆ. lottery-test-suite.fif.

ಒಂದು ವೇರಿಯೇಬಲ್ ಅನ್ನು ರಚಿಸೋಣ. storage ಮತ್ತು ಅದರಲ್ಲಿ ಖಾಲಿ ಒಂದನ್ನು ಬರೆಯಿರಿ. cell, ಇದು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಸಂಗ್ರಹವಾಗಿರುತ್ತದೆ.

message ಹೊರಗಿನಿಂದ ಸ್ಮಾರ್ಟ್ ಸಂಪರ್ಕಕ್ಕೆ ನಾವು ರವಾನಿಸುವ ಸಂದೇಶ ಇದು. ನಾವು ಇದೀಗ ಅದನ್ನು ಖಾಲಿ ಬಿಡುತ್ತೇವೆ.

variable storage 
<b b> storage ! 

variable message 
<b b> message !

ನಾವು ಸ್ಥಿರಾಂಕಗಳು ಮತ್ತು ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಸಿದ್ಧಪಡಿಸಿದ ನಂತರ, ನಾವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು TVM ಅನ್ನು ಚಲಾಯಿಸುತ್ತೇವೆ. runvmctx ಮತ್ತು ರಚಿಸಿದ ನಿಯತಾಂಕಗಳನ್ನು ಇನ್‌ಪುಟ್‌ಗೆ ರವಾನಿಸಿ.

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

ಕೊನೆಯಲ್ಲಿ ನಾವು ಯಶಸ್ವಿಯಾಗುತ್ತೇವೆ ಹೀಗೆ ಮಧ್ಯಂತರ ಕೋಡ್ ಆನ್ ಆಗಿದೆ Fift.

ಈಗ ನಾವು ಫಲಿತಾಂಶದ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು.

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

ಪ್ರೋಗ್ರಾಂ ದೋಷಗಳಿಲ್ಲದೆ ರನ್ ಆಗಬೇಕು ಮತ್ತು ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ನಾವು ಎಕ್ಸಿಕ್ಯೂಶನ್ ಲಾಗ್ ಅನ್ನು ನೋಡುತ್ತೇವೆ:

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

ಅದ್ಭುತ, ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಮೊದಲ ಕಾರ್ಯನಿರತ ಆವೃತ್ತಿಯನ್ನು ಬರೆದಿದ್ದೇವೆ.

ಈಗ ನಾವು ಕಾರ್ಯವನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ. ಮೊದಲು, ಹೊರಗಿನ ಪ್ರಪಂಚದಿಂದ ಬರುವ ಸಂದೇಶಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸೋಣ recv_external()

ಒಪ್ಪಂದವು ಸ್ವೀಕರಿಸಬಹುದಾದ ಸಂದೇಶ ಸ್ವರೂಪವನ್ನು ಡೆವಲಪರ್ ಸ್ವತಃ ಆಯ್ಕೆ ಮಾಡುತ್ತಾರೆ.

ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ,

ಮೊದಲನೆಯದಾಗಿ, ನಮ್ಮ ಒಪ್ಪಂದವನ್ನು ಹೊರಗಿನ ಪ್ರಪಂಚದಿಂದ ರಕ್ಷಿಸಲು ಮತ್ತು ಒಪ್ಪಂದದ ಮಾಲೀಕರು ಮಾತ್ರ ಅದಕ್ಕೆ ಬಾಹ್ಯ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸುವಂತೆ ಮಾಡಲು ನಾವು ಬಯಸುತ್ತೇವೆ.
ಎರಡನೆಯದಾಗಿ, ನಾವು TON ಗೆ ಮಾನ್ಯವಾದ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಿದಾಗ, ಅದು ನಿಖರವಾಗಿ ಒಮ್ಮೆ ಆಗಬೇಕೆಂದು ನಾವು ಬಯಸುತ್ತೇವೆ ಮತ್ತು ನಾವು ಅದೇ ಸಂದೇಶವನ್ನು ಮತ್ತೆ ಕಳುಹಿಸಿದಾಗ, ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವು ಅದನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ ಬಹುತೇಕ ಪ್ರತಿಯೊಂದು ಒಪ್ಪಂದವು ಈ ಎರಡು ಸಮಸ್ಯೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತದೆ, ನಮ್ಮ ಒಪ್ಪಂದವು ಬಾಹ್ಯ ಸಂದೇಶಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದರಿಂದ, ನಾವು ಅದನ್ನೂ ಸಹ ನೋಡಿಕೊಳ್ಳಬೇಕು.

ನಾವು ಅದನ್ನು ಹಿಮ್ಮುಖ ಕ್ರಮದಲ್ಲಿ ಮಾಡುತ್ತೇವೆ. ಮೊದಲನೆಯದಾಗಿ, ನಾವು ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತೇವೆ, ಒಪ್ಪಂದವು ಈಗಾಗಲೇ ಅಂತಹ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಿ ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ್ದರೆ, ಅದು ಅದನ್ನು ಎರಡನೇ ಬಾರಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ. ತದನಂತರ ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತೇವೆ ಇದರಿಂದ ನಿರ್ದಿಷ್ಟ ವಲಯದ ಜನರು ಮಾತ್ರ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಕ್ಕೆ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಬಹುದು.

ನಕಲಿ ಸಂದೇಶಗಳೊಂದಿಗೆ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ವಿಭಿನ್ನ ಮಾರ್ಗಗಳಿವೆ. ನಾವು ಅದನ್ನು ಹೇಗೆ ಮಾಡುತ್ತೇವೆ ಎಂಬುದು ಇಲ್ಲಿದೆ. ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಲ್ಲಿ, ನಾವು ಸ್ವೀಕರಿಸಿದ ಸಂದೇಶಗಳ ಕೌಂಟರ್ ಅನ್ನು 0 ರ ಆರಂಭಿಕ ಮೌಲ್ಯದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ. ಪ್ರತಿ ಸಂದೇಶದಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಕ್ಕೆ, ನಾವು ಪ್ರಸ್ತುತ ಕೌಂಟರ್ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸುತ್ತೇವೆ. ಸಂದೇಶದಲ್ಲಿನ ಕೌಂಟರ್ ಮೌಲ್ಯವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಲ್ಲಿನ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ನಾವು ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದಿಲ್ಲ; ಅದು ಹಾಗೆ ಮಾಡಿದರೆ, ನಾವು ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತೇವೆ ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಲ್ಲಿ ಕೌಂಟರ್ ಅನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸುತ್ತೇವೆ.

ನಾವು ಹಿಂತಿರುಗುತ್ತಿದ್ದೇವೆ lottery-test-suite.fif ಮತ್ತು ಅದಕ್ಕೆ ಎರಡನೇ ಪರೀಕ್ಷೆಯನ್ನು ಸೇರಿಸಿ. ಅಮಾನ್ಯ ಸಂಖ್ಯೆಯನ್ನು ಕಳುಹಿಸಿ, ಕೋಡ್ ಒಂದು ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯಬೇಕು. ಉದಾಹರಣೆಗೆ, ಒಪ್ಪಂದದ ಡೇಟಾ 166 ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಎಂದು ಹೇಳೋಣ ಮತ್ತು ನಾವು 165 ಅನ್ನು ಕಳುಹಿಸುತ್ತೇವೆ.

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

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

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

ಪ್ರಾರಂಭಿಸೋಣ.

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

ಮತ್ತು ಪರೀಕ್ಷೆಯು ದೋಷದೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳ್ಳುವುದನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ.

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

ಈ ಹಂತದಲ್ಲಿ lottery-test-suite.fif ಹೇಗಿರಬೇಕು ಲಿಂಕ್.

ಈಗ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಕ್ಕೆ ಕೌಂಟರ್ ಲಾಜಿಕ್ ಅನ್ನು ಸೇರಿಸೋಣ lottery-code.fc.

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

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

В slice in_msg ನಾವು ಕಳುಹಿಸುವ ಸಂದೇಶ ಸುಳ್ಳು.

ನಾವು ಮಾಡುವ ಮೊದಲ ಕೆಲಸವೆಂದರೆ ಸಂದೇಶದಲ್ಲಿ ಡೇಟಾ ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು, ಇಲ್ಲದಿದ್ದರೆ, ನಾವು ನಿರ್ಗಮಿಸುತ್ತೇವೆ.

ಮುಂದೆ ನಾವು ಸಂದೇಶವನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತೇವೆ. in_msg~load_uint(32) 165, 32-ಬಿಟ್ ಸಂಖ್ಯೆಯನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ unsigned int ರವಾನೆಯಾದ ಸಂದೇಶದಿಂದ.

ಮುಂದೆ, ನಾವು ಸ್ಮಾರ್ಟ್ ಕಾಂಟ್ರಾಕ್ಟ್ ಸಂಗ್ರಹಣೆಯಿಂದ 32 ಬಿಟ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡುತ್ತೇವೆ. ಲೋಡ್ ಮಾಡಲಾದ ಸಂಖ್ಯೆಯು ರವಾನೆಯಾದ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ಇಲ್ಲದಿದ್ದರೆ, ನಾವು ಒಂದು ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯುತ್ತೇವೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಹೊಂದಿಕೆಯಾಗದಿರುವುದನ್ನು ರವಾನಿಸುತ್ತಿರುವುದರಿಂದ, ಒಂದು ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯಬೇಕು.

ಈಗ ಕಂಪೈಲ್ ಮಾಡೋಣ.

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

ಫಲಿತಾಂಶದ ಕೋಡ್ ಅನ್ನು ಇಲ್ಲಿಗೆ ನಕಲಿಸಿ lottery-test-suite.fif, ಕೊನೆಯ ಸಾಲನ್ನು ಬದಲಾಯಿಸಲು ಮರೆಯುವುದಿಲ್ಲ.

ಪರೀಕ್ಷೆಯು ಉತ್ತೀರ್ಣವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸೋಣ:

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

ಇಲ್ಲಿಯೇ ಪ್ರಸ್ತುತ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ನೀವು ಅನುಗುಣವಾದ ಬದ್ಧತೆಯನ್ನು ನೋಡಬಹುದು.

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಸಂಕಲಿಸಿದ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷೆಗಳೊಂದಿಗೆ ಫೈಲ್‌ಗೆ ನಿರಂತರವಾಗಿ ನಕಲಿಸುವುದು ಅನಾನುಕೂಲವಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ, ಆದ್ದರಿಂದ ನಾವು ಕೋಡ್ ಅನ್ನು ನಮಗಾಗಿ ಸ್ಥಿರವಾಗಿ ಬರೆಯುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯುತ್ತೇವೆ ಮತ್ತು ನಾವು ಕಂಪೈಲ್ ಮಾಡಿದ ಕೋಡ್ ಅನ್ನು ನಮ್ಮ ಪರೀಕ್ಷೆಗಳಿಗೆ ಸರಳವಾಗಿ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ. "include".

ಯೋಜನೆಯ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ, ಒಂದು ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ build.sh ಕೆಳಗಿನ ವಿಷಯದೊಂದಿಗೆ.

#!/bin/bash

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

ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಂತೆ ಮಾಡೋಣ.

chmod +x ./build.sh

ಈಗ, ಒಪ್ಪಂದವನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸಿದರೆ ಸಾಕು. ಆದರೆ ಅದರ ಜೊತೆಗೆ, ನಾವು ಅದನ್ನು ಸ್ಥಿರಾಂಕವಾಗಿ ಬರೆಯಬೇಕಾಗಿದೆ. codeಆದ್ದರಿಂದ ನಾವು ಹೊಸ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ. lotter-compiled-for-test.fif, ಇದನ್ನು ನಾವು ಫೈಲ್‌ನಲ್ಲಿ ಸೇರಿಸುತ್ತೇವೆ lottery-test-suite.fif.

sh ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಕೆಲವು ಕೋಡ್‌ಗಳನ್ನು ಸೇರಿಸೋಣ, ಅದು ಕಂಪೈಲ್ ಮಾಡಿದ ಫೈಲ್ ಅನ್ನು ಸರಳವಾಗಿ ನಕಲು ಮಾಡುತ್ತದೆ. lotter-compiled-for-test.fif ಮತ್ತು ಅದರಲ್ಲಿರುವ ಕೊನೆಯ ಸಾಲನ್ನು ಬದಲಾಯಿಸಿ.

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

ಈಗ, ಪರಿಶೀಲಿಸಲು, ಫಲಿತಾಂಶದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡೋಣ ಮತ್ತು ಫೈಲ್ ಜನರೇಟ್ ಆಗುತ್ತದೆ. lottery-compiled-for-test.fif, ಇದನ್ನು ನಾವು ನಮ್ಮ lottery-test-suite.fif

В lottery-test-suite.fif ಒಪ್ಪಂದ ಕೋಡ್ ಅನ್ನು ಅಳಿಸಿ ಮತ್ತು ಒಂದು ಸಾಲನ್ನು ಸೇರಿಸಿ. "lottery-compiled-for-test.fif" include.

ಅವರು ಉತ್ತೀರ್ಣರಾಗುತ್ತಾರೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ನಾವು ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುತ್ತೇವೆ.

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

ಅದ್ಭುತವಾಗಿದೆ, ಈಗ ಪರೀಕ್ಷೆಗಳ ಚಾಲನೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ನಾವು ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ. test.sh, ಇದು ಮೊದಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ build.sh, ತದನಂತರ ಪರೀಕ್ಷೆಗಳನ್ನು ಚಲಾಯಿಸಿ.

touch test.sh
chmod +x test.sh

ನಾವು ಒಳಗೆ ಬರೆಯುತ್ತೇವೆ

./build.sh 

echo "nCompilation completedn"

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

ಮಾಡೋಣ test.sh ಮತ್ತು ಪರೀಕ್ಷೆಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿವೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅದನ್ನು ಚಲಾಯಿಸಿ.

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

ಒಪ್ಪಂದವು ಸಂಕಲಿಸಲ್ಪಟ್ಟಿದೆಯೇ ಮತ್ತು ಪರೀಕ್ಷೆಗಳು ನಡೆಯುತ್ತಿವೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ.

ಅದ್ಭುತ, ಈಗ ಪ್ರಾರಂಭದಲ್ಲಿದೆ test.sh ಪರೀಕ್ಷೆಗಳನ್ನು ಸಂಕಲಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣವೇ ನಡೆಸಲಾಗುತ್ತದೆ. ಇಲ್ಲಿ ಲಿಂಕ್ ಇದೆ ಒಪ್ಪಿಸುತ್ತೇನೆ.

ಸರಿ, ಮುಂದುವರಿಯುವ ಮೊದಲು, ಅನುಕೂಲಕ್ಕಾಗಿ ಇನ್ನೊಂದು ಕೆಲಸ ಮಾಡೋಣ.

ಫೋಲ್ಡರ್ ಅನ್ನು ರಚಿಸೋಣ. build ಅಲ್ಲಿ ನಾವು ಸಂಕಲಿಸಿದ ಒಪ್ಪಂದವನ್ನು ಮತ್ತು ಅದರ ಕ್ಲೋನ್ ಅನ್ನು ಸ್ಥಿರಾಂಕಕ್ಕೆ ಬರೆಯುತ್ತೇವೆ. lottery-compiled.fif, lottery-compiled-for-test.fif. ನಾವು ಒಂದು ಫೋಲ್ಡರ್ ಅನ್ನು ಸಹ ರಚಿಸುತ್ತೇವೆ test ಪರೀಕ್ಷಾ ಫೈಲ್ ಅನ್ನು ಎಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ lottery-test-suite.fif ಮತ್ತು ಸಂಭಾವ್ಯವಾಗಿ ಇತರ ಪೋಷಕ ಫೈಲ್‌ಗಳು. ಸಂಬಂಧಿತ ಬದಲಾವಣೆಗಳಿಗೆ ಲಿಂಕ್.

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದನ್ನು ಮುಂದುವರಿಸೋಣ.

ಮುಂದೆ ನಾವು ಸರಿಯಾದ ಸಂಖ್ಯೆಯನ್ನು ಕಳುಹಿಸಿದಾಗ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಲಾಗಿದೆಯೇ ಮತ್ತು ಕೌಂಟರ್ ಅನ್ನು ನವೀಕರಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಪರೀಕ್ಷೆ ಇರಬೇಕು. ಆದರೆ ನಾವು ಅದನ್ನು ನಂತರ ಮಾಡುತ್ತೇವೆ.

ಈಗ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಲ್ಲಿ ಯಾವ ಡೇಟಾ ರಚನೆ ಮತ್ತು ಯಾವ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ಯೋಚಿಸೋಣ.

ನಾವು ಸಂಗ್ರಹಿಸುವ ಎಲ್ಲವನ್ನೂ ನಾನು ವಿವರಿಸುತ್ತೇನೆ.

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

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

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

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

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

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

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

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

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

ಮುಂದೆ, ನೀವು ಎರಡು ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಬೇಕು. ನಾವು ಮೊದಲನೆಯದನ್ನು ಕರೆಯುತ್ತೇವೆ. pack_state(), ಇದು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ನಂತರದ ಸಂಗ್ರಹಣೆಗಾಗಿ ಡೇಟಾವನ್ನು ಪ್ಯಾಕ್ ಮಾಡುತ್ತದೆ. ಎರಡನೆಯದನ್ನು, ನಾವು ಕರೆಯುತ್ತೇವೆ unpack_state() ಸಂಗ್ರಹಣೆಯಿಂದ ಡೇಟಾವನ್ನು ಓದಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

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

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

ನಾವು ಈ ಎರಡು ಕಾರ್ಯಗಳನ್ನು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಆರಂಭಕ್ಕೆ ಸೇರಿಸುತ್ತೇವೆ. ನಮಗೆ ಸಿಗುತ್ತದೆ ಹೀಗೆ ಮಧ್ಯಂತರ ಫಲಿತಾಂಶ.

ಡೇಟಾವನ್ನು ಉಳಿಸಲು ನೀವು ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯವನ್ನು ಕರೆಯಬೇಕಾಗುತ್ತದೆ set_data() ಮತ್ತು ಅದು ಡೇಟಾವನ್ನು ದಾಖಲಿಸುತ್ತದೆ pack_state() ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ.

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

ಈಗ ನಾವು ಡೇಟಾವನ್ನು ಬರೆಯಲು ಮತ್ತು ಓದಲು ಅನುಕೂಲಕರ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ, ನಾವು ಮುಂದುವರಿಯಬಹುದು.

ಹೊರಗಿನಿಂದ ಬರುವ ಸಂದೇಶವನ್ನು ಒಪ್ಪಂದದ ಮಾಲೀಕರು (ಅಥವಾ ಖಾಸಗಿ ಕೀಲಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುವ ಇನ್ನೊಬ್ಬ ಬಳಕೆದಾರರು) ಸಹಿ ಮಾಡಿದ್ದಾರೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬೇಕು.

ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಪ್ರಕಟಿಸಿದಾಗ, ನಮಗೆ ಅಗತ್ಯವಿರುವ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಉಳಿಸುವ ಮೂಲಕ ಅದನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ಒಳಬರುವ ಸಂದೇಶದ ಸಹಿಯನ್ನು ಅನುಗುಣವಾದ ಖಾಸಗಿ ಕೀಲಿಯಿಂದ ಮಾಡಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ನಾವು ಅಲ್ಲಿ ಸಾರ್ವಜನಿಕ ಕೀಲಿಯನ್ನು ಬರೆಯುತ್ತೇವೆ.

ಮುಂದುವರಿಯುವ ಮೊದಲು, ಖಾಸಗಿ ಕೀಲಿಯನ್ನು ರಚಿಸಿ ಅದನ್ನು ಬರೆಯೋಣ test/keys/owner.pkಇದನ್ನು ಮಾಡಲು, ನಾವು Fift ಅನ್ನು ಸಂವಾದಾತ್ಮಕ ಮೋಡ್‌ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಮತ್ತು ನಾಲ್ಕು ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ.

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

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

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

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

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

ಫೋಲ್ಡರ್ ಅನ್ನು ರಚಿಸೋಣ. keys ಫೋಲ್ಡರ್ ಒಳಗೆ test ಮತ್ತು ನಾವು ಅಲ್ಲಿ ಖಾಸಗಿ ಕೀಲಿಯನ್ನು ಬರೆಯುತ್ತೇವೆ.

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

ನಾವು ಪ್ರಸ್ತುತ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ನೋಡುತ್ತೇವೆ. owner.pk.

ನಾವು ಸಾರ್ವಜನಿಕ ಕೀಲಿಯನ್ನು ಸ್ಟ್ಯಾಕ್‌ನಿಂದ ತೆಗೆದುಹಾಕುತ್ತೇವೆ ಮತ್ತು ಅಗತ್ಯವಿದ್ದಾಗ ಅದನ್ನು ಖಾಸಗಿ ಒಂದರಿಂದ ಪಡೆಯಬಹುದು.

ಈಗ ನಾವು ಸಹಿ ಪರಿಶೀಲನೆಯನ್ನು ಬರೆಯಬೇಕಾಗಿದೆ. ಪರೀಕ್ಷೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ಮೊದಲು, ನಾವು ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಫೈಲ್‌ನಿಂದ ಖಾಸಗಿ ಕೀಲಿಯನ್ನು ಓದುತ್ತೇವೆ. file>B ಮತ್ತು ಅದನ್ನು ಒಂದು ವೇರಿಯೇಬಲ್ ಆಗಿ ಬರೆಯಿರಿ. owner_private_key, ನಂತರ ಕಾರ್ಯವನ್ನು ಬಳಸಿ priv>pub ಖಾಸಗಿ ಕೀಲಿಯನ್ನು ಸಾರ್ವಜನಿಕ ಕೀಲಿಯಾಗಿ ಪರಿವರ್ತಿಸಿ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಬರೆಯಿರಿ owner_public_key.

variable owner_private_key
variable owner_public_key 

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

ನಮಗೆ ಎರಡೂ ಕೀಲಿಗಳು ಬೇಕಾಗುತ್ತವೆ.

ಕಾರ್ಯದಲ್ಲಿರುವಂತೆಯೇ ಅದೇ ಅನುಕ್ರಮದಲ್ಲಿ ಅನಿಯಂತ್ರಿತ ಡೇಟಾದೊಂದಿಗೆ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ ಸಂಗ್ರಹಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿ. pack_state()ಮತ್ತು ಅದನ್ನು ಒಂದು ವೇರಿಯೇಬಲ್ ಆಗಿ ಬರೆಯಿರಿ. storage.

variable owner_private_key
variable owner_public_key 
variable orders
variable owner_wc
variable owner_account_id

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

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

ಮುಂದೆ, ನಾವು ಸಹಿ ಮಾಡಿದ ಸಂದೇಶವನ್ನು ರಚಿಸುತ್ತೇವೆ, ಅದು ಸಹಿ ಮತ್ತು ಕೌಂಟರ್ ಮೌಲ್ಯವನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಮೊದಲು ನಾವು ರವಾನಿಸಲು ಬಯಸುವ ಡೇಟಾವನ್ನು ರಚಿಸುತ್ತೇವೆ, ನಂತರ ಅದನ್ನು ಖಾಸಗಿ ಕೀಲಿಯೊಂದಿಗೆ ಸಹಿ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಾವು ಸಹಿ ಮಾಡಿದ ಸಂದೇಶವನ್ನು ರೂಪಿಸುತ್ತೇವೆ.

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

ಪರಿಣಾಮವಾಗಿ, ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಕ್ಕೆ ಕಳುಹಿಸುವ ಸಂದೇಶವನ್ನು ವೇರಿಯೇಬಲ್ ಆಗಿ ಬರೆಯಲಾಗುತ್ತದೆ message_to_send, ಕಾರ್ಯಗಳ ಬಗ್ಗೆ hashu, ed25519_sign_uint ನೀವು ಓದಬಹುದು ಐದನೇ ದಸ್ತಾವೇಜನ್ನು.

ಮತ್ತು ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸಲು ನಾವು ಅದನ್ನು ಮತ್ತೆ ಕರೆಯುತ್ತೇವೆ.

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

ಇಲ್ಲಿ ಈ ಹಂತದಲ್ಲಿ ಪರೀಕ್ಷಾ ಫೈಲ್ ಈ ರೀತಿ ಇರಬೇಕು.

ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸೋಣ ಮತ್ತು ಅದು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ ಈ ಸ್ವರೂಪದ ಸಂದೇಶಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ಮತ್ತು ಸಹಿಯನ್ನು ಪರಿಶೀಲಿಸಲು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಬದಲಾಯಿಸೋಣ.

ಮೊದಲು, ನಾವು ಸಂದೇಶದಿಂದ ಸಹಿಯ 512 ಬಿಟ್‌ಗಳನ್ನು ಓದುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳನ್ನು ವೇರಿಯೇಬಲ್‌ಗೆ ಬರೆಯುತ್ತೇವೆ, ನಂತರ ನಾವು ಕೌಂಟರ್ ವೇರಿಯೇಬಲ್‌ನ 32 ಬಿಟ್‌ಗಳನ್ನು ಓದುತ್ತೇವೆ.

ಸ್ಮಾರ್ಟ್ ಕಾಂಟ್ರಾಕ್ಟ್ ಸಂಗ್ರಹಣೆಯಿಂದ ಡೇಟಾವನ್ನು ಓದಲು ನಮಗೆ ಒಂದು ಕಾರ್ಯವಿರುವುದರಿಂದ, ನಾವು ಅದನ್ನು ಬಳಸುತ್ತೇವೆ.

ಮುಂದೆ, ಸಂಗ್ರಹಣೆಯೊಂದಿಗೆ ವರ್ಗಾಯಿಸಲಾದ ಕೌಂಟರ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಸಹಿಯನ್ನು ಪರಿಶೀಲಿಸಿ. ಏನಾದರೂ ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ಅನುಗುಣವಾದ ಕೋಡ್‌ನೊಂದಿಗೆ ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯಿರಿ.

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

ಅನುಗುಣವಾದ ಬದ್ಧತೆ ಇಲ್ಲಿಯೇ.

ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸೋಣ ಮತ್ತು ಎರಡನೇ ಪರೀಕ್ಷೆಯು ವಿಫಲವಾಗಿದೆಯೇ ಎಂದು ನೋಡೋಣ. ಎರಡು ಕಾರಣಗಳಿಗಾಗಿ, ಸಂದೇಶವು ಬಿಟ್‌ಗಳಿಂದ ಹೊರಗಿದೆ ಮತ್ತು ಸಂಗ್ರಹಣೆಯು ಬಿಟ್‌ಗಳಿಂದ ಹೊರಗಿದೆ, ಆದ್ದರಿಂದ ಪಾರ್ಸಿಂಗ್ ಮಾಡುವಾಗ ಕೋಡ್ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. ನಾವು ಕಳುಹಿಸುವ ಸಂದೇಶಕ್ಕೆ ಸಹಿಯನ್ನು ಸೇರಿಸಬೇಕು ಮತ್ತು ಕೊನೆಯ ಪರೀಕ್ಷೆಯಿಂದ ಸಂಗ್ರಹಣೆಯನ್ನು ನಕಲಿಸಬೇಕು.

ಎರಡನೇ ಪರೀಕ್ಷೆಯಲ್ಲಿ, ನಾವು ಸಂದೇಶ ಸಹಿಯನ್ನು ಸೇರಿಸುತ್ತೇವೆ ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ ಸಂಗ್ರಹಣೆಯನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ. ಇಲ್ಲಿ ಈ ಸಮಯದಲ್ಲಿ ಪರೀಕ್ಷಾ ಫೈಲ್ ಹೇಗಿದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ.

ನಾಲ್ಕನೇ ಪರೀಕ್ಷೆಯನ್ನು ಬರೆಯೋಣ, ಅದರಲ್ಲಿ ನಾವು ಬೇರೆಯವರ ಖಾಸಗಿ ಕೀಲಿಯಿಂದ ಸಹಿ ಮಾಡಲಾದ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸುತ್ತೇವೆ. ಇನ್ನೊಂದು ಖಾಸಗಿ ಕೀಲಿಯನ್ನು ರಚಿಸಿ ಅದನ್ನು ಫೈಲ್‌ಗೆ ಉಳಿಸೋಣ. not-owner.pk. ನಾವು ಈ ಖಾಸಗಿ ಕೀಲಿಯೊಂದಿಗೆ ಸಂದೇಶಕ್ಕೆ ಸಹಿ ಮಾಡುತ್ತೇವೆ. ನಾವು ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುತ್ತೇವೆ ಮತ್ತು ಎಲ್ಲಾ ಪರೀಕ್ಷೆಗಳು ಉತ್ತೀರ್ಣವಾಗುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತೇವೆ. ಬದ್ಧತೆ ಈ ಕ್ಷಣದಲ್ಲಿ.

ಈಗ ನಾವು ಅಂತಿಮವಾಗಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮುಂದುವರಿಯಬಹುದು.
В recv_external() ನಾವು ಎರಡು ರೀತಿಯ ಸಂದೇಶಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ.

ನಮ್ಮ ಒಪ್ಪಂದವು ಆಟಗಾರರ ನಷ್ಟವನ್ನು ಸಂಗ್ರಹಿಸುವುದರಿಂದ, ಈ ಹಣವನ್ನು ಲಾಟರಿಯ ಸೃಷ್ಟಿಕರ್ತರಿಗೆ ವರ್ಗಾಯಿಸಬೇಕು. ಒಪ್ಪಂದವನ್ನು ರಚಿಸುವಾಗ ಲಾಟರಿಯ ಸೃಷ್ಟಿಕರ್ತನ ವ್ಯಾಲೆಟ್ ವಿಳಾಸವನ್ನು ಸಂಗ್ರಹಣೆಗೆ ಬರೆಯಲಾಗುತ್ತದೆ.

ಒಂದು ವೇಳೆ, ಸೋತವರ ಗ್ರಾಂಗಳನ್ನು ಕಳುಹಿಸಬೇಕಾದ ವಿಳಾಸವನ್ನು ಬದಲಾಯಿಸುವ ಸಾಮರ್ಥ್ಯ ನಮಗೆ ಬೇಕಾಗುತ್ತದೆ. ಲಾಟರಿ ಗ್ರಾಂಗಳನ್ನು ಮಾಲೀಕರ ವಿಳಾಸಕ್ಕೆ ಕಳುಹಿಸುವ ಸಾಮರ್ಥ್ಯವೂ ನಮಗೆ ಬೇಕಾಗುತ್ತದೆ.

ಮೊದಲನೆಯದರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ. ಮೊದಲು, ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಿದ ನಂತರ, ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವು ಹೊಸ ವಿಳಾಸವನ್ನು ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಉಳಿಸಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಪರೀಕ್ಷೆಯನ್ನು ನಾವು ಬರೆಯುತ್ತೇವೆ. ಕೌಂಟರ್ ಮತ್ತು ಹೊಸ ವಿಳಾಸದ ಜೊತೆಗೆ, ನಾವು ಸಹ ಕಳುಹಿಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ action 7-ಬಿಟ್ ಋಣಾತ್ಮಕವಲ್ಲದ ಪೂರ್ಣಾಂಕ, ಅದನ್ನು ಅವಲಂಬಿಸಿ, ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಲ್ಲಿ ಸಂದೇಶವನ್ನು ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬೇಕೆಂದು ನಾವು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ.

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

ಪರೀಕ್ಷೆಯಲ್ಲಿ ನೀವು ಸ್ಮಾರ್ಟ್ ಕಾಂಟ್ರಾಕ್ಟ್ ಸಂಗ್ರಹಣೆಯ ಡಿಸೀರಿಯಲೈಸೇಶನ್ ಹೇಗೆ ಸಂಭವಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡಬಹುದು. storage ಫಿಫ್ಟ್ ದಸ್ತಾವೇಜನ್ನು. ವೇರಿಯೇಬಲ್‌ಗಳ ಡಿಸೀರಿಯಲೈಸೇಶನ್ ಅನ್ನು ಫಿಫ್ಟ್ ದಸ್ತಾವೇಜನ್ನು ವಿವರಿಸಲಾಗಿದೆ.

ಕಮಿಟ್‌ಗೆ ಲಿಂಕ್ ಮಾಡಿ ಹಿಟ್ಟನ್ನು ಸೇರಿಸುವುದರೊಂದಿಗೆ.

ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸಿ ಅದು ಕ್ರ್ಯಾಶ್ ಆಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳೋಣ. ಈಗ ಲಾಟರಿ ಮಾಲೀಕರ ವಿಳಾಸವನ್ನು ಬದಲಾಯಿಸಲು ತರ್ಕವನ್ನು ಸೇರಿಸೋಣ.

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಲ್ಲಿ ನಾವು ಪಾರ್ಸ್ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತೇವೆ message, ನಾವು ಓದುತ್ತೇವೆ action. ನಮಗೆ ಎರಡು ಇರುತ್ತದೆ ಎಂದು ನಿಮಗೆ ನೆನಪಿಸೋಣ action: ವಿಳಾಸ ಬದಲಾವಣೆ ಮತ್ತು ಗ್ರಾಂ ಕಳುಹಿಸುವುದು.

ನಂತರ ನಾವು ಒಪ್ಪಂದದ ಮಾಲೀಕರ ಹೊಸ ವಿಳಾಸವನ್ನು ಓದುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಉಳಿಸುತ್ತೇವೆ.
ನಾವು ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುತ್ತೇವೆ ಮತ್ತು ಮೂರನೇ ಪರೀಕ್ಷೆಯು ವಿಫಲವಾಗುವುದನ್ನು ನೋಡುತ್ತೇವೆ. ಒಪ್ಪಂದವು ಈಗ ಹೆಚ್ಚುವರಿಯಾಗಿ ಸಂದೇಶದಿಂದ 7 ಬಿಟ್‌ಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದರಿಂದ ಅದು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ, ಅವುಗಳು ಪರೀಕ್ಷೆಯಲ್ಲಿ ಕಾಣೆಯಾಗಿವೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಒಂದನ್ನು ಸೇರಿಸೋಣ. action. ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸಿ ಅವರೆಲ್ಲರೂ ಉತ್ತೀರ್ಣರಾಗುವಂತೆ ನೋಡೋಣ. ಇಲ್ಲಿ ಬದಲಾವಣೆಗಳಿಗೆ ಬದ್ಧರಾಗಿರಿ. ಅದ್ಭುತ.

ಈಗ ಈ ಹಿಂದೆ ಉಳಿಸಿದ ವಿಳಾಸಕ್ಕೆ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಗ್ರಾಂಗಳನ್ನು ಕಳುಹಿಸುವ ತರ್ಕವನ್ನು ಬರೆಯೋಣ.

ಮೊದಲು, ಒಂದು ಪರೀಕ್ಷೆ ಬರೆಯೋಣ. ನಾವು ಎರಡು ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುತ್ತೇವೆ, ಒಂದು ಸಮತೋಲನ ಸಾಕಷ್ಟಿಲ್ಲದಿದ್ದಾಗ, ಎರಡನೆಯದು ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ನಡೆಯಬೇಕಾದಾಗ. ನೀವು ಪರೀಕ್ಷೆಗಳನ್ನು ನೋಡಬಹುದು. ಈ ಕಮಿಟ್‌ನಲ್ಲಿ.

ಈಗ ಕೋಡ್ ಅನ್ನು ಮುಗಿಸೋಣ. ಮೊದಲು, ಎರಡು ಸಹಾಯಕ ವಿಧಾನಗಳನ್ನು ಬರೆಯೋಣ. ಮೊದಲ ಗೆಟ್ ವಿಧಾನವೆಂದರೆ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಪ್ರಸ್ತುತ ಸಮತೋಲನವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು.

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

ಮತ್ತು ಎರಡನೆಯದು ಮತ್ತೊಂದು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಕ್ಕೆ ಗ್ರಾಂಗಳನ್ನು ಕಳುಹಿಸುವುದಕ್ಕಾಗಿ. ನಾನು ಈ ವಿಧಾನವನ್ನು ಮತ್ತೊಂದು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ನಕಲಿಸಿದ್ದೇನೆ.

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

ಈ ಎರಡು ವಿಧಾನಗಳನ್ನು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಕ್ಕೆ ಸೇರಿಸಿ ತರ್ಕವನ್ನು ಬರೆಯೋಣ. ಮೊದಲು, ಸಂದೇಶದಿಂದ ಗ್ರಾಂಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪಾರ್ಸ್ ಮಾಡಿ. ನಂತರ ಬ್ಯಾಲೆನ್ಸ್ ಪರಿಶೀಲಿಸಿ, ಸಾಕಷ್ಟು ಇಲ್ಲದಿದ್ದರೆ, ಒಂದು ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯಿರಿ. ಎಲ್ಲವೂ ಸರಿಯಾಗಿದ್ದರೆ, ಗ್ರಾಂಗಳನ್ನು ಉಳಿಸಿದ ವಿಳಾಸಕ್ಕೆ ಕಳುಹಿಸಿ ಮತ್ತು ಕೌಂಟರ್ ಅನ್ನು ನವೀಕರಿಸಿ.

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

ಇಲ್ಲಿ ಈ ಸಮಯದಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವು ಹೀಗಿದೆ. ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸಿ ಅವು ಉತ್ತೀರ್ಣವಾಗುವಂತೆ ನೋಡಿಕೊಳ್ಳೋಣ.

ಅಂದಹಾಗೆ, ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವು ಸಂದೇಶವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದಾಗಲೆಲ್ಲಾ ಆಯೋಗವನ್ನು ಕಡಿತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವು ವಿನಂತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಮೂಲಭೂತ ಪರಿಶೀಲನೆಗಳ ನಂತರ, ನೀವು ಕರೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ accept_message().

ಈಗ ಆಂತರಿಕ ಸಂದೇಶ ಕಳುಹಿಸುವಿಕೆಗೆ ಹೋಗೋಣ. ವಾಸ್ತವವಾಗಿ, ನಾವು ಗ್ರಾಂಗಳನ್ನು ಮಾತ್ರ ಸ್ವೀಕರಿಸುತ್ತೇವೆ ಮತ್ತು ಆಟಗಾರನು ಗೆದ್ದರೆ ಅದರ ಎರಡು ಪಟ್ಟು ಮೊತ್ತವನ್ನು ಮತ್ತು ಅವನು ಸೋತರೆ ಮಾಲೀಕರಿಗೆ ಮೂರನೇ ಒಂದು ಭಾಗವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.

ಮೊದಲು, ಒಂದು ಸರಳ ಪರೀಕ್ಷೆಯನ್ನು ಬರೆಯೋಣ. ಇದಕ್ಕಾಗಿ, ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಕ್ಕೆ ಗ್ರಾಂಗಳನ್ನು ಕಳುಹಿಸುವ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಪರೀಕ್ಷಾ ವಿಳಾಸದ ಅಗತ್ಯವಿದೆ.

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ವಿಳಾಸವು ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ವರ್ಕ್‌ಚೈನ್‌ಗೆ ಜವಾಬ್ದಾರರಾಗಿರುವ 32-ಬಿಟ್ ಪೂರ್ಣಾಂಕ ಮತ್ತು ಈ ವರ್ಕ್‌ಚೈನ್‌ನಲ್ಲಿರುವ 256-ಬಿಟ್ ನಕಾರಾತ್ಮಕವಲ್ಲದ ಪೂರ್ಣಾಂಕ ಅನನ್ಯ ಖಾತೆ ಸಂಖ್ಯೆ. ಉದಾಹರಣೆಗೆ, -1 ಮತ್ತು 12345, ಈ ವಿಳಾಸ ಮತ್ತು ಫೈಲ್‌ಗೆ ಉಳಿಸಿ.

ವಿಳಾಸವನ್ನು ಉಳಿಸಲು ನಾನು ಕಾರ್ಯವನ್ನು ನಕಲಿಸಿದ್ದೇನೆ TonUtil.fif.

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

ಈ ಕಾರ್ಯವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ, ಇದು Fift ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಬಗ್ಗೆ ತಿಳುವಳಿಕೆಯನ್ನು ನೀಡುತ್ತದೆ. Fift ಅನ್ನು ಸಂವಾದಾತ್ಮಕ ಮೋಡ್‌ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸಿ.

~/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 ಇದು ಹುಡುಕಬಹುದು ಅಧಿಕೃತ ಭಂಡಾರದಲ್ಲಿ.

ಗಮನ ಕೊಡುವುದು ಯೋಗ್ಯವಾಗಿದೆ. ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಸಂಗ್ರಹಣೆ ಮತ್ತು ಇನ್‌ಪುಟ್ ಸಂದೇಶವನ್ನು ರೂಪಿಸುತ್ತೇವೆ. ಅದರ ನಂತರ, ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ವಿಳಾಸವನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಟನ್‌ನಲ್ಲಿ ಪ್ರಕಟಿಸುವ ಮೊದಲೇ ವಿಳಾಸವು ತಿಳಿದಿರುತ್ತದೆ. ನಂತರ ನೀವು ಈ ವಿಳಾಸಕ್ಕೆ ಹಲವಾರು ಗ್ರಾಂಗಳನ್ನು ಕಳುಹಿಸಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ನಂತರವೇ ನೀವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದೊಂದಿಗೆ ಫೈಲ್ ಅನ್ನು ಕಳುಹಿಸಬೇಕಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ನೆಟ್‌ವರ್ಕ್ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಆಯೋಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ (ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೌಲ್ಯಮಾಪಕರು). ಕೋಡ್ ಅನ್ನು ಇಲ್ಲಿ ವೀಕ್ಷಿಸಬಹುದು..

ಮುಂದೆ ನಾವು ಪಬ್ಲಿಷಿಂಗ್ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ ಮತ್ತು ಪಡೆಯುತ್ತೇವೆ lottery-query.boc ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಫೈಲ್ ಮತ್ತು ವಿಳಾಸ.

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

ರಚಿಸಿದ ಫೈಲ್‌ಗಳನ್ನು ಉಳಿಸಲು ಮರೆಯಬೇಡಿ: lottery-query.boc, lottery.addr, lottery.pk.

ಇತರ ವಿಷಯಗಳ ಜೊತೆಗೆ, ನಾವು ಮರಣದಂಡನೆ ದಾಖಲೆಗಳಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ವಿಳಾಸವನ್ನು ನೋಡುತ್ತೇವೆ.

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

ವಿನೋದಕ್ಕಾಗಿ, TON ಗೆ ಒಂದು ವಿನಂತಿಯನ್ನು ಮಾಡೋಣ

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

ಮತ್ತು ಈ ವಿಳಾಸವಿರುವ ಖಾತೆಯು ಖಾಲಿಯಾಗಿರುವುದನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ.

account state is empty

ನಾವು ವಿಳಾಸಕ್ಕೆ ಕಳುಹಿಸುತ್ತೇವೆ. 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 ಗ್ರಾಂ ಮತ್ತು ಕೆಲವು ಸೆಕೆಂಡುಗಳ ನಂತರ ಅದೇ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ. ಗ್ರಾಂಗಳನ್ನು ಕಳುಹಿಸಲು ನಾನು ಬಳಸುತ್ತೇನೆ ಅಧಿಕೃತ ಕೈಚೀಲ, ಮತ್ತು ನೀವು ಚಾಟ್‌ನಿಂದ ಯಾರೊಂದಿಗಾದರೂ ಪರೀಕ್ಷಾ ಗ್ರಾಂಗಳನ್ನು ಕೇಳಬಹುದು, ಅದರ ಬಗ್ಗೆ ನಾನು ಲೇಖನದ ಕೊನೆಯಲ್ಲಿ ಮಾತನಾಡುತ್ತೇನೆ.

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ಪ್ರಾರಂಭಿಸದವರಂತೆ ಕಾಣುತ್ತಿದೆ (ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಕಾಣಿಸಿಕೊಂಡಿದೆ)state:account_uninit) ಅಂತಹ ವಿಳಾಸ ಮತ್ತು 1 ನ್ಯಾನೊಗ್ರಾಂಗಳ ಬಾಕಿ ಮೊತ್ತದೊಂದಿಗೆ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ.

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

ಈಗ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಪ್ರಕಟಿಸೋಣ. ಲೈಟ್-ಕ್ಲೈಂಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಿ.

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

ಒಪ್ಪಂದ ಪ್ರಕಟವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸೋಣ.

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ಇತರ ವಿಷಯಗಳ ಜೊತೆಗೆ, ನಾವು ಸ್ವೀಕರಿಸುತ್ತೇವೆ.

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

ನಾವು ಅದನ್ನು ನೋಡುತ್ತೇವೆ account_active.

ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ಅನುಗುಣವಾದ ಬದ್ಧತೆ ಇಲ್ಲಿಯೇ.

ಈಗ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ವಿನಂತಿಗಳನ್ನು ರಚಿಸೋಣ.

ಹೆಚ್ಚು ನಿಖರವಾಗಿ ಹೇಳುವುದಾದರೆ, ವಿಳಾಸವನ್ನು ಬದಲಾಯಿಸಲು ನಾವು ಮೊದಲನೆಯದನ್ನು ಸ್ವತಂತ್ರ ಕೆಲಸವಾಗಿ ಬಿಡುತ್ತೇವೆ ಮತ್ತು ಎರಡನೆಯದನ್ನು ಮಾಲೀಕರ ವಿಳಾಸಕ್ಕೆ ಗ್ರಾಂಗಳನ್ನು ಕಳುಹಿಸಲು ಮಾಡುತ್ತೇವೆ. ವಾಸ್ತವವಾಗಿ, ಗ್ರಾಂಗಳನ್ನು ಕಳುಹಿಸುವ ಪರೀಕ್ಷೆಯಲ್ಲಿರುವಂತೆಯೇ ನಾವು ಮಾಡಬೇಕಾಗುತ್ತದೆ.

ಇದು ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಕ್ಕೆ ಕಳುಹಿಸುವ ಸಂದೇಶ, ಅಲ್ಲಿ msg_seqno 165, action ಸಾಗಣೆಗೆ 2 ಮತ್ತು 9.5 ಗ್ರಾಂ.

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

ಸಂದೇಶಕ್ಕೆ ಖಾಸಗಿ ಕೀಲಿಯೊಂದಿಗೆ ಸಹಿ ಮಾಡಲು ಮರೆಯಬೇಡಿ. lottery.pk, ಇದು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ರಚಿಸುವಾಗ ಮೊದಲೇ ರಚಿಸಲ್ಪಟ್ಟಿತು. ಸಂಬಂಧಿತ ಸಮಿತಿ ಇಲ್ಲಿದೆ.

ಗೆಟ್ ವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಿಂದ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುವುದು

ಈಗ ಸ್ಮಾರ್ಟ್ ಕಾಂಟ್ರಾಕ್ಟ್ ಗೆಟ್ ವಿಧಾನಗಳನ್ನು ಹೇಗೆ ನಡೆಸುವುದು ಎಂದು ನೋಡೋಣ.

ಆರಂಭ lite-client ಮತ್ತು ನಾವು ಬರೆದ ಗೆಟ್ ವಿಧಾನಗಳನ್ನು ಚಲಾಯಿಸಿ.

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

В result ಕಾರ್ಯವು ಹಿಂದಿರುಗಿಸುವ ಮೌಲ್ಯವನ್ನು ಒಳಗೊಂಡಿದೆ balance() ನಮ್ಮ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಿಂದ.
ನಾವು ಇನ್ನೂ ಹಲವಾರು ವಿಧಾನಗಳಿಗೂ ಇದೇ ರೀತಿ ಮಾಡುತ್ತೇವೆ.

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

ಬೆಟ್ಟಿಂಗ್ ಇತಿಹಾಸವನ್ನು ವಿನಂತಿಸೋಣ.

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

ಸೈಟ್‌ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ನಾವು ಲೈಟ್-ಕ್ಲೈಂಟ್ ಮತ್ತು ಗೆಟ್-ವಿಧಾನಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.

ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಡೇಟಾವನ್ನು ತೋರಿಸಲಾಗುತ್ತಿದೆ

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ ಡೇಟಾವನ್ನು ಅನುಕೂಲಕರ ರೀತಿಯಲ್ಲಿ ತೋರಿಸಲು ನಾನು ಸರಳವಾದ ಪೈಥಾನ್ ವೆಬ್‌ಸೈಟ್ ಅನ್ನು ಬರೆದಿದ್ದೇನೆ. ನಾನು ಇಲ್ಲಿ ವಿವರವಾಗಿ ಹೋಗುವುದಿಲ್ಲ ಮತ್ತು ವೆಬ್‌ಸೈಟ್ ಅನ್ನು ಪ್ರಕಟಿಸುತ್ತೇನೆ. ಒಂದೇ ಕಮಿಟ್‌ನಲ್ಲಿ.

TON ಗೆ ವಿನಂತಿಗಳನ್ನು ಇವರಿಂದ ಮಾಡಲಾಗುತ್ತದೆ Python ಸಹಾಯದಿಂದ lite-clientಅನುಕೂಲಕ್ಕಾಗಿ, ಸೈಟ್ ಅನ್ನು ಡಾಕರ್‌ನಲ್ಲಿ ಪ್ಯಾಕ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು Google ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಪ್ರಕಟಿಸಲಾಗಿದೆ. ಲಿಂಕ್.

ಪ್ರಯತ್ನಿಸುತ್ತಿದೆ

ಈಗ ಅಲ್ಲಿಗೆ ಗ್ರಾಂ ಕಳುಹಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ ಇದರಿಂದ ನೀರು ಮತ್ತೆ ತುಂಬುತ್ತದೆ ಕೈಚೀಲ. ನಾವು 40 ಗ್ರಾಂ ಕಳುಹಿಸುತ್ತೇವೆ. ಮತ್ತು ಸ್ಪಷ್ಟತೆಗಾಗಿ ಒಂದೆರಡು ಪಂತಗಳನ್ನು ಮಾಡುತ್ತೇವೆ. ಸೈಟ್ ಬೆಟ್ಟಿಂಗ್ ಇತಿಹಾಸ, ಪ್ರಸ್ತುತ ಗೆಲುವಿನ ಶೇಕಡಾವಾರು ಮತ್ತು ಇತರ ಉಪಯುಕ್ತ ಮಾಹಿತಿಯನ್ನು ತೋರಿಸುತ್ತದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ.

ನಾವು ನೋಡುತ್ತೇವೆ, ನಾವು ಮೊದಲನೆಯದನ್ನು ಗೆದ್ದೆವು ಮತ್ತು ಎರಡನೆಯದನ್ನು ಸೋತೆವು.

ನಂತರದ

ಲೇಖನವು ನಾನು ನಿರೀಕ್ಷಿಸಿದ್ದಕ್ಕಿಂತ ಹೆಚ್ಚು ಉದ್ದವಾಗಿದೆ, ಬಹುಶಃ ಅದು ಚಿಕ್ಕದಾಗಿರಬಹುದು, ಅಥವಾ ಬಹುಶಃ ಅದು TON ಬಗ್ಗೆ ಏನೂ ತಿಳಿದಿಲ್ಲದ ಮತ್ತು ಅದರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಸಾಮರ್ಥ್ಯವಿರುವ ಸರಳವಲ್ಲದ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಬರೆದು ಪ್ರಕಟಿಸಲು ಬಯಸುವ ವ್ಯಕ್ತಿಗೆ ಮಾತ್ರ ಆಗಿರಬಹುದು. ಬಹುಶಃ ಕೆಲವು ವಿಷಯಗಳನ್ನು ಇನ್ನೂ ಸರಳವಾಗಿ ವಿವರಿಸಬಹುದಿತ್ತು.

ಬಹುಶಃ ಅನುಷ್ಠಾನದ ಕೆಲವು ಅಂಶಗಳನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮತ್ತು ಸೊಗಸಾಗಿ ಮಾಡಬಹುದಿತ್ತು, ಆದರೆ ಆಗ ಲೇಖನವನ್ನು ತಯಾರಿಸಲು ಇನ್ನೂ ಹೆಚ್ಚಿನ ಸಮಯ ಬೇಕಾಗುತ್ತಿತ್ತು. ನಾನು ಎಲ್ಲೋ ತಪ್ಪು ಮಾಡಿದ್ದೇನೆ ಅಥವಾ ಏನನ್ನಾದರೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳದೆ ಇರುವ ಸಾಧ್ಯತೆಯೂ ಇದೆ, ಆದ್ದರಿಂದ ನೀವು ಏನಾದರೂ ಗಂಭೀರವಾದ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತಿದ್ದರೆ, ನೀವು ಅಧಿಕೃತ ದಸ್ತಾವೇಜನ್ನು ಅಥವಾ TON ಕೋಡ್‌ನೊಂದಿಗೆ ಅಧಿಕೃತ ಭಂಡಾರವನ್ನು ಅವಲಂಬಿಸಬೇಕಾಗುತ್ತದೆ.

TON ಇನ್ನೂ ಸಕ್ರಿಯ ಅಭಿವೃದ್ಧಿ ಹಂತದಲ್ಲಿರುವುದರಿಂದ, ಈ ಲೇಖನದ ಯಾವುದೇ ಹಂತಗಳನ್ನು ಮುರಿಯುವ ಬದಲಾವಣೆಗಳು ಸಂಭವಿಸಬಹುದು (ನಾನು ಬರೆಯುತ್ತಿರುವಾಗ ಅದು ಸಂಭವಿಸಿದೆ, ನಾನು ಅದನ್ನು ಈಗಾಗಲೇ ಸರಿಪಡಿಸಿದ್ದೇನೆ), ಆದರೆ ಸಾಮಾನ್ಯ ವಿಧಾನವು ಬದಲಾಗುವ ಸಾಧ್ಯತೆಯಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಬೇಕು.

ನಾನು TON ನ ಭವಿಷ್ಯದ ಬಗ್ಗೆ ಊಹಿಸುವುದಿಲ್ಲ. ಬಹುಶಃ ವೇದಿಕೆ ದೊಡ್ಡದಾಗಬಹುದು ಮತ್ತು ನಾವು ಅದನ್ನು ಅಧ್ಯಯನ ಮಾಡಲು ಮತ್ತು ನಮ್ಮ ಉತ್ಪನ್ನಗಳೊಂದಿಗೆ ಒಂದು ಸ್ಥಾನವನ್ನು ಪಡೆದುಕೊಳ್ಳಲು ಸಮಯವನ್ನು ಕಳೆಯಬೇಕು.

ಫೇಸ್‌ಬುಕ್‌ನಿಂದ ಲಿಬ್ರಾ ಕೂಡ ಇದೆ, ಇದು TON ಗಿಂತ ಹೆಚ್ಚಿನ ಬಳಕೆದಾರರ ಸಂಭಾವ್ಯ ಪ್ರೇಕ್ಷಕರನ್ನು ಹೊಂದಿದೆ. ನನಗೆ ಲಿಬ್ರಾ ಬಗ್ಗೆ ಏನೂ ತಿಳಿದಿಲ್ಲ, ವೇದಿಕೆಯ ಮೂಲಕ ನಿರ್ಣಯಿಸಿದರೆ, TON ಸಮುದಾಯಕ್ಕಿಂತ ಅಲ್ಲಿ ಹೆಚ್ಚಿನ ಚಟುವಟಿಕೆ ಇದೆ. ಡೆವಲಪರ್‌ಗಳು ಮತ್ತು TON ಸಮುದಾಯವು ಭೂಗತದಂತೆ ಇದ್ದರೂ, ಅದು ಕೂಡ ತಂಪಾಗಿದೆ.

ಉಲ್ಲೇಖಗಳು

ಅಧಿಕೃತ 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