TON ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಹೇಗೆ ಬರೆಯುವುದು ಮತ್ತು ಪ್ರಕಟಿಸುವುದು ಎಂಬುದರ ಕುರಿತು

ಈ ಲೇಖನ ಯಾವುದರ ಬಗ್ಗೆ?

ಲೇಖನದಲ್ಲಿ ನಾನು ಮೊದಲ (ಎರಡರಲ್ಲಿ) ಟೆಲಿಗ್ರಾಮ್ ಬ್ಲಾಕ್‌ಚೈನ್ ಸ್ಪರ್ಧೆಯಲ್ಲಿ ಹೇಗೆ ಭಾಗವಹಿಸಿದೆ ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡುತ್ತೇನೆ, ಬಹುಮಾನವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲಿಲ್ಲ ಮತ್ತು ನನ್ನ ಅನುಭವವನ್ನು ಲೇಖನದಲ್ಲಿ ದಾಖಲಿಸಲು ನಿರ್ಧರಿಸಿದೆ ಇದರಿಂದ ಅದು ಮರೆವುಗೆ ಮುಳುಗುವುದಿಲ್ಲ ಮತ್ತು ಬಹುಶಃ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಯಾರಾದರೂ.

ನಾನು ಅಮೂರ್ತ ಕೋಡ್ ಬರೆಯಲು ಬಯಸುವುದಿಲ್ಲ, ಆದರೆ ಏನಾದರೂ ಕೆಲಸ ಮಾಡಲು, ಲೇಖನಕ್ಕಾಗಿ ನಾನು ತ್ವರಿತ ಲಾಟರಿಗಾಗಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಮತ್ತು ಮಧ್ಯಂತರ ಸಂಗ್ರಹಣೆಯನ್ನು ಬಳಸದೆಯೇ TON ನಿಂದ ನೇರವಾಗಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಡೇಟಾವನ್ನು ತೋರಿಸುವ ವೆಬ್‌ಸೈಟ್ ಅನ್ನು ಬರೆದಿದ್ದೇನೆ.

TON ನಲ್ಲಿ ತಮ್ಮ ಮೊದಲ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಮಾಡಲು ಬಯಸುವವರಿಗೆ ಲೇಖನವು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ, ಆದರೆ ಎಲ್ಲಿ ಪ್ರಾರಂಭಿಸಬೇಕು ಎಂದು ತಿಳಿದಿಲ್ಲ.

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

ಸ್ಪರ್ಧೆಯಲ್ಲಿ ಭಾಗವಹಿಸುವ ಬಗ್ಗೆ

ಕಳೆದ ಅಕ್ಟೋಬರ್‌ನಲ್ಲಿ, ಟೆಲಿಗ್ರಾಮ್ ಹೊಸ ಭಾಷೆಗಳೊಂದಿಗೆ ಬ್ಲಾಕ್‌ಚೈನ್ ಸ್ಪರ್ಧೆಯನ್ನು ಘೋಷಿಸಿತು Fift и FunC. ಐದು ಪ್ರಸ್ತಾವಿತ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳಲ್ಲಿ ಯಾವುದನ್ನಾದರೂ ಬರೆಯುವುದರಿಂದ ಆಯ್ಕೆ ಮಾಡುವುದು ಅಗತ್ಯವಾಗಿತ್ತು. ಮುಂದೆ ಇನ್ನೇನನ್ನೂ ಬರೆಯಬೇಕಿಲ್ಲದಿದ್ದರೂ ಬೇರೆಯದ್ದೇನಾದರೂ ಮಾಡಿ, ಭಾಷೆ ಕಲಿತು ಏನಾದರೂ ಮಾಡಿದರೆ ಚೆನ್ನ ಎಂದುಕೊಂಡೆ. ಜೊತೆಗೆ, ವಿಷಯವು ನಿರಂತರವಾಗಿ ತುಟಿಗಳ ಮೇಲೆ ಇರುತ್ತದೆ.

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಲ್ಲಿ ನನಗೆ ಯಾವುದೇ ಅನುಭವವಿಲ್ಲ ಎಂದು ಹೇಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ.

ನಾನು ಕೊನೆಯವರೆಗೂ ಭಾಗವಹಿಸಲು ಮತ್ತು ನಂತರ ವಿಮರ್ಶೆ ಲೇಖನವನ್ನು ಬರೆಯಲು ಯೋಜಿಸಿದೆ, ಆದರೆ ಮೊದಲನೆಯದರಲ್ಲಿ ನಾನು ಈಗಿನಿಂದಲೇ ವಿಫಲನಾದೆ. I ಒಂದು ಕೈಚೀಲವನ್ನು ಬರೆದರು ಬಹು-ಸಹಿಯೊಂದಿಗೆ FunC ಮತ್ತು ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಕೆಲಸ ಮಾಡಿದೆ. ನಾನು ಅದನ್ನು ಆಧಾರವಾಗಿ ತೆಗೆದುಕೊಂಡೆ ಘನತೆಯ ಮೇಲೆ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ.

ಆ ಸಮಯದಲ್ಲಿ, ಕನಿಷ್ಠ ಬಹುಮಾನದ ಸ್ಥಾನವನ್ನು ಪಡೆಯಲು ಇದು ಖಂಡಿತವಾಗಿಯೂ ಸಾಕು ಎಂದು ನಾನು ಭಾವಿಸಿದೆ. ಪರಿಣಾಮವಾಗಿ, ಭಾಗವಹಿಸಿದ 40 ರಲ್ಲಿ ಸುಮಾರು 60 ಜನರು ಬಹುಮಾನ ವಿಜೇತರಾದರು ಮತ್ತು ನಾನು ಅವರಲ್ಲಿ ಇರಲಿಲ್ಲ. ಸಾಮಾನ್ಯವಾಗಿ, ಇದರಲ್ಲಿ ಯಾವುದೇ ತಪ್ಪಿಲ್ಲ, ಆದರೆ ಒಂದು ವಿಷಯ ನನ್ನನ್ನು ಕಾಡಿತು. ಫಲಿತಾಂಶಗಳ ಪ್ರಕಟಣೆಯ ಸಮಯದಲ್ಲಿ, ನನ್ನ ಒಪ್ಪಂದದ ಪರೀಕ್ಷೆಯ ಪರಿಶೀಲನೆಯನ್ನು ಮಾಡಲಾಗಿಲ್ಲ, ನಾನು ಚಾಟ್‌ನಲ್ಲಿ ಭಾಗವಹಿಸುವವರಿಗೆ ಅದನ್ನು ಹೊಂದಿಲ್ಲದ ಯಾರಾದರೂ ಇದ್ದಾರೆಯೇ ಎಂದು ಕೇಳಿದೆ, ಯಾರೂ ಇಲ್ಲ.

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

ತಿಳುವಳಿಕೆಗಾಗಿ ಸಾಕಷ್ಟು ಸಮಯ ಕಳೆದಿದೆ, ಆದ್ದರಿಂದ ಲೇಖನವನ್ನು ಬರೆಯಲು ನಿರ್ಧರಿಸಲಾಯಿತು. ಇನ್ನೂ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯಿಲ್ಲದ ಕಾರಣ, ಈ ಲೇಖನವು ಆಸಕ್ತಿ ಹೊಂದಿರುವ ಪ್ರತಿಯೊಬ್ಬರಿಗೂ ಸಮಯವನ್ನು ಉಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

TON ನಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳ ಪರಿಕಲ್ಪನೆ

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

ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಬರೆಯಲು ಮತ್ತು ಕೆಲಸ ಮಾಡಲು ಗಮನಹರಿಸುತ್ತೇವೆ TON Virtual Machine (TVM), Fift и FunC, ಆದ್ದರಿಂದ ಲೇಖನವು ಸಾಮಾನ್ಯ ಕಾರ್ಯಕ್ರಮದ ಅಭಿವೃದ್ಧಿಯ ವಿವರಣೆಯಂತಿದೆ. ವೇದಿಕೆಯು ಇಲ್ಲಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನಾವು ವಾಸಿಸುವುದಿಲ್ಲ.

ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ಸಾಮಾನ್ಯವಾಗಿ TVM ಮತ್ತು ಭಾಷೆ Fift ಉತ್ತಮ ಅಧಿಕೃತ ದಾಖಲೆಗಳಿವೆ. ಸ್ಪರ್ಧೆಯಲ್ಲಿ ಭಾಗವಹಿಸುವಾಗ ಮತ್ತು ಈಗ ಪ್ರಸ್ತುತ ಒಪ್ಪಂದವನ್ನು ಬರೆಯುವಾಗ, ನಾನು ಆಗಾಗ್ಗೆ ಅವಳ ಕಡೆಗೆ ತಿರುಗಿದೆ.

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳನ್ನು ಬರೆಯುವ ಮುಖ್ಯ ಭಾಷೆ FunC. ಈ ಸಮಯದಲ್ಲಿ ಅದರ ಮೇಲೆ ಯಾವುದೇ ದಾಖಲಾತಿಗಳಿಲ್ಲ, ಆದ್ದರಿಂದ ಏನನ್ನಾದರೂ ಬರೆಯಲು ನೀವು ಅಧಿಕೃತ ರೆಪೊಸಿಟರಿಯಿಂದ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳ ಉದಾಹರಣೆಗಳನ್ನು ಮತ್ತು ಅಲ್ಲಿ ಭಾಷೆಯ ಅನುಷ್ಠಾನವನ್ನು ಅಧ್ಯಯನ ಮಾಡಬೇಕಾಗುತ್ತದೆ, ಜೊತೆಗೆ ನೀವು ಹಿಂದಿನ ಎರಡು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡಬಹುದು. ಸ್ಪರ್ಧೆಗಳು. ಲೇಖನದ ಕೊನೆಯಲ್ಲಿ ಲಿಂಕ್‌ಗಳು.

ನಾವು ಈಗಾಗಲೇ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಬರೆದಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ FunC, ಅದರ ನಂತರ ನಾವು ಕೋಡ್ ಅನ್ನು ಫಿಫ್ಟ್ ಅಸೆಂಬ್ಲರ್ ಆಗಿ ಕಂಪೈಲ್ ಮಾಡುತ್ತೇವೆ.

ಕಂಪೈಲ್ ಮಾಡಿದ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಪ್ರಕಟಿಸಲು ಉಳಿದಿದೆ. ಇದನ್ನು ಮಾಡಲು, ನೀವು ಒಂದು ಕಾರ್ಯವನ್ನು ಬರೆಯಬೇಕು Fift, ಇದು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಕೋಡ್ ಮತ್ತು ಕೆಲವು ಇತರ ನಿಯತಾಂಕಗಳನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಔಟ್ಪುಟ್ ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ಫೈಲ್ ಆಗಿರುತ್ತದೆ .boc (ಅಂದರೆ "ಕೋಶಗಳ ಚೀಲ"), ಮತ್ತು, ನಾವು ಅದನ್ನು ಹೇಗೆ ಬರೆಯುತ್ತೇವೆ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ, ಖಾಸಗಿ ಕೀ ಮತ್ತು ವಿಳಾಸವನ್ನು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಕೋಡ್ ಆಧರಿಸಿ ರಚಿಸಲಾಗಿದೆ. ಇನ್ನೂ ಪ್ರಕಟಿಸದಿರುವ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ವಿಳಾಸಕ್ಕೆ ನೀವು ಈಗಾಗಲೇ ಗ್ರಾಂಗಳನ್ನು ಕಳುಹಿಸಬಹುದು.

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

ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಪ್ರಕಟಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನಾವು ಅರ್ಥಮಾಡಿಕೊಂಡ ನಂತರ, ಅದು ಸುಲಭವಾಗುತ್ತದೆ. ನಾವು ಏನನ್ನು ಬರೆಯಲು ಬಯಸುತ್ತೇವೆ ಮತ್ತು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನಮಗೆ ಸ್ಥೂಲವಾಗಿ ತಿಳಿದಿದೆ. ಮತ್ತು ಬರೆಯುವಾಗ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳಲ್ಲಿ ಇದನ್ನು ಈಗಾಗಲೇ ಹೇಗೆ ಅಳವಡಿಸಲಾಗಿದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ ಅಥವಾ ನಾವು ಅನುಷ್ಠಾನ ಕೋಡ್ ಅನ್ನು ನೋಡುತ್ತೇವೆ Fift и FunC ಅಧಿಕೃತ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ, ಅಥವಾ ಅಧಿಕೃತ ದಾಖಲೆಯಲ್ಲಿ ನೋಡಿ.

ಆಗಾಗ್ಗೆ ನಾನು ಟೆಲಿಗ್ರಾಮ್ ಚಾಟ್‌ನಲ್ಲಿ ಎಲ್ಲಾ ಸ್ಪರ್ಧೆಯಲ್ಲಿ ಭಾಗವಹಿಸುವವರು ಮತ್ತು ಟೆಲಿಗ್ರಾಮ್ ಉದ್ಯೋಗಿಗಳು ಒಟ್ಟುಗೂಡುವ ಕೀವರ್ಡ್‌ಗಳನ್ನು ಹುಡುಕುತ್ತಿದ್ದೆ ಮತ್ತು ಸ್ಪರ್ಧೆಯ ಸಮಯದಲ್ಲಿ ಎಲ್ಲರೂ ಅಲ್ಲಿ ಒಟ್ಟುಗೂಡಿದರು ಮತ್ತು ಫಿಫ್ಟ್ ಮತ್ತು ಫನ್‌ಸಿ ಕುರಿತು ಚರ್ಚಿಸಲು ಪ್ರಾರಂಭಿಸಿದರು. ಲೇಖನದ ಕೊನೆಯಲ್ಲಿ ಲಿಂಕ್.

ಇದು ಸಿದ್ಧಾಂತದಿಂದ ಅಭ್ಯಾಸಕ್ಕೆ ಚಲಿಸುವ ಸಮಯ.

TON ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಪರಿಸರವನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು

MacOS ನಲ್ಲಿನ ಲೇಖನದಲ್ಲಿ ವಿವರಿಸುವ ಎಲ್ಲವನ್ನೂ ನಾನು ಮಾಡಿದ್ದೇನೆ ಮತ್ತು ಡಾಕರ್‌ನಲ್ಲಿ ಕ್ಲೀನ್ ಉಬುಂಟು 18.04 LTS ನಲ್ಲಿ ಅದನ್ನು ಎರಡು ಬಾರಿ ಪರಿಶೀಲಿಸಿದ್ದೇನೆ.

ನೀವು ಮಾಡಬೇಕಾದ ಮೊದಲನೆಯದು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಸ್ಥಾಪಿಸುವುದು lite-client ಇದರೊಂದಿಗೆ ನೀವು TON ಗೆ ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಬಹುದು.

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

ನಾವು ಮಧ್ಯಂತರ ಫಲಿತಾಂಶಗಳನ್ನು ಮಾಡುವ ಭಂಡಾರವನ್ನು ತಕ್ಷಣವೇ ರಚಿಸೋಣ.

ನಮ್ಮ ಜೀವನವನ್ನು ಸುಲಭಗೊಳಿಸಲು, ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಬರೆಯುತ್ತೇವೆ ಮತ್ತು ಅದು ಸಿದ್ಧವಾಗುವವರೆಗೆ ಅದನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಪರೀಕ್ಷಿಸುತ್ತೇವೆ. ಅದರ ನಂತರವೇ ನಾವು ಅದನ್ನು TON ನಲ್ಲಿ ಪ್ರಕಟಿಸುತ್ತೇವೆ.

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವು ಪ್ರವೇಶಿಸಬಹುದಾದ ಎರಡು ಬಾಹ್ಯ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ. ಪ್ರಥಮ, recv_external() ಒಪ್ಪಂದಕ್ಕೆ ವಿನಂತಿಯು ಹೊರಗಿನ ಪ್ರಪಂಚದಿಂದ ಬಂದಾಗ ಈ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ, TON ನಿಂದ ಅಲ್ಲ, ಉದಾಹರಣೆಗೆ, ನಾವೇ ಸಂದೇಶವನ್ನು ರಚಿಸಿದಾಗ ಮತ್ತು ಅದನ್ನು ಲೈಟ್-ಕ್ಲೈಂಟ್ ಮೂಲಕ ಕಳುಹಿಸಿದಾಗ. ಎರಡನೇ, recv_internal() ಇದು TON ನಲ್ಲಿಯೇ, ಯಾವುದೇ ಒಪ್ಪಂದವು ನಮ್ಮದನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನೀವು ಕಾರ್ಯಕ್ಕೆ ನಿಯತಾಂಕಗಳನ್ನು ರವಾನಿಸಬಹುದು.

ಪ್ರಕಟಿಸಿದರೆ ಕೆಲಸ ಮಾಡುವ ಸರಳ ಉದಾಹರಣೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ, ಆದರೆ ಅದರಲ್ಲಿ ಯಾವುದೇ ಕ್ರಿಯಾತ್ಮಕ ಹೊರೆ ಇಲ್ಲ.

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

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

ಅದು ಏನೆಂದು ಇಲ್ಲಿ ನಾವು ವಿವರಿಸಬೇಕಾಗಿದೆ slice. TON ಬ್ಲಾಕ್‌ಚೈನ್‌ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಎಲ್ಲಾ ಡೇಟಾ ಸಂಗ್ರಹವಾಗಿದೆ TVM cell ಅಥವಾ ಕೇವಲ cell, ಅಂತಹ ಸೆಲ್‌ನಲ್ಲಿ ನೀವು 1023 ಬಿಟ್‌ಗಳ ಡೇಟಾವನ್ನು ಮತ್ತು ಇತರ ಸೆಲ್‌ಗಳಿಗೆ 4 ಲಿಂಕ್‌ಗಳವರೆಗೆ ಸಂಗ್ರಹಿಸಬಹುದು.

TVM cell slice ಅಥವಾ slice ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಒಂದು ಭಾಗವಾಗಿದೆ cell ಅದನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ, ಅದು ನಂತರ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ. ನಮಗೆ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ನಾವು ವರ್ಗಾವಣೆ ಮಾಡಬಹುದು slice ಮತ್ತು ಸಂದೇಶದ ಪ್ರಕಾರವನ್ನು ಅವಲಂಬಿಸಿ, ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ recv_external() ಅಥವಾ recv_internal().

impure - ಕಾರ್ಯವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಡೇಟಾವನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ ಎಂದು ಸೂಚಿಸುವ ಕೀವರ್ಡ್.

ಒಪ್ಪಂದದ ಕೋಡ್ ಅನ್ನು ಉಳಿಸೋಣ lottery-code.fc ಮತ್ತು ಕಂಪೈಲ್.

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

ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಧ್ವಜಗಳ ಅರ್ಥವನ್ನು ವೀಕ್ಷಿಸಬಹುದು

~/TON/build/crypto/func -help

ನಾವು ಫಿಫ್ಟ್ ಅಸೆಂಬ್ಲರ್ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಿದ್ದೇವೆ lottery-compiled.fif:

// lottery-compiled.fif

"Asm.fif" include
// automatically generated from `/Users/rajymbekkapisev/TON/ton/crypto/smartcont/stdlib.fc` `./lottery-code.fc` 
PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>c

ಇದನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಪ್ರಾರಂಭಿಸಬಹುದು, ಇದಕ್ಕಾಗಿ ನಾವು ಪರಿಸರವನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತೇವೆ.

ಮೊದಲ ಸಾಲು ಸಂಪರ್ಕಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ Asm.fif, ಇದು ಫಿಫ್ಟ್ ಅಸೆಂಬ್ಲರ್‌ಗಾಗಿ ಫಿಫ್ಟ್‌ನಲ್ಲಿ ಬರೆಯಲಾದ ಕೋಡ್ ಆಗಿದೆ.

ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಚಲಾಯಿಸಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಬಯಸುವ ಕಾರಣ, ನಾವು ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ lottery-test-suite.fif ಮತ್ತು ಅಲ್ಲಿ ಕಂಪೈಲ್ ಮಾಡಿದ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿ, ಅದರಲ್ಲಿ ಕೊನೆಯ ಸಾಲನ್ನು ಬದಲಿಸಿ, ಅದು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಕೋಡ್ ಅನ್ನು ಸ್ಥಿರವಾಗಿ ಬರೆಯುತ್ತದೆ codeನಂತರ ಅದನ್ನು ವರ್ಚುವಲ್ ಯಂತ್ರಕ್ಕೆ ವರ್ಗಾಯಿಸಲು:

"TonUtil.fif" include
"Asm.fif" include

PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>s constant code

ಇಲ್ಲಿಯವರೆಗೆ ಇದು ಸ್ಪಷ್ಟವಾಗಿ ತೋರುತ್ತದೆ, ಈಗ ನಾವು TVM ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಬಳಸುವ ಕೋಡ್ ಅನ್ನು ಅದೇ ಫೈಲ್‌ಗೆ ಸೇರಿಸೋಣ.

0 tuple 0x076ef1ea , // magic
0 , 0 , // actions msg_sents
1570998536 , // unix_time
1 , 1 , 3 , // block_lt, trans_lt, rand_seed
0 tuple 100000000000000 , dictnew , , // remaining balance
0 , dictnew , // contract_address, global_config
1 tuple // wrap to another tuple
constant c7

0 constant recv_internal // to run recv_internal() 
-1 constant recv_external // to invoke recv_external()

В c7 ನಾವು ಸಂದರ್ಭವನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡುತ್ತೇವೆ, ಅಂದರೆ, TVM (ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಸ್ಥಿತಿ) ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಡೇಟಾ. ಸ್ಪರ್ಧೆಯ ಸಮಯದಲ್ಲಿ ಸಹ, ಡೆವಲಪರ್‌ಗಳಲ್ಲಿ ಒಬ್ಬರು ಹೇಗೆ ರಚಿಸಬೇಕೆಂದು ತೋರಿಸಿದರು c7 ಮತ್ತು ನಾನು ನಕಲು ಮಾಡಿದೆ. ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಬದಲಾಯಿಸಬೇಕಾಗಬಹುದು rand_seed ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ ಉತ್ಪಾದನೆಯು ಅದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುವುದರಿಂದ ಮತ್ತು ಬದಲಾಯಿಸದಿದ್ದರೆ, ಅದೇ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿ ಬಾರಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

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

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

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

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

variable storage 
<b b> storage ! 

variable message 
<b b> message ! 

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

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx 

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

ಈಗ ನಾವು ಪರಿಣಾಮವಾಗಿ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು.

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

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

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

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

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

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

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

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

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

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

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

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

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

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

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

ಲಾಂಚ್ ಮಾಡೋಣ.

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

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

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

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

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

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

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

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

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

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

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

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

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

ಪರಿಣಾಮವಾಗಿ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿ lottery-test-suite.fif, ಕೊನೆಯ ಸಾಲನ್ನು ಬದಲಾಯಿಸಲು ಮರೆಯುವುದಿಲ್ಲ.

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

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

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

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

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

#!/bin/bash

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

ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸೋಣ.

chmod +x ./build.sh

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

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

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

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

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

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

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

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

touch test.sh
chmod +x test.sh

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

./build.sh 

echo "nCompilation completedn"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

variable owner_private_key
variable owner_public_key 

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

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

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

variable owner_private_key
variable owner_public_key 
variable orders
variable owner_wc
variable owner_account_id

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

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

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

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

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

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

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

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

ಇಲ್ಲಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಹೊಂದಿರುವ ಫೈಲ್ ಈ ಹಂತದಲ್ಲಿ ಈ ರೀತಿ ಇರಬೇಕು.

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

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

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

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

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

ಸಂಬಂಧಿತ ಬದ್ಧತೆ ಇಲ್ಲಿಯೇ.

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

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

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

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

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

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

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

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

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

ಕಮಿಟ್ ಲಿಂಕ್ ಸೇರಿಸಿದ ಹಿಟ್ಟಿನೊಂದಿಗೆ.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

~/TON/build/crypto/fift -i 

ಮೊದಲು ನಾವು -1, 12345 ಮತ್ತು ಭವಿಷ್ಯದ ಫೈಲ್‌ನ "sender.addr" ಹೆಸರನ್ನು ಸ್ಟಾಕ್‌ಗೆ ತಳ್ಳುತ್ತೇವೆ:

-1 12345 "sender.addr" 

ಮುಂದಿನ ಹಂತವು ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು -rot, ಇದು ಸ್ಟಾಕ್‌ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ವಿಶಿಷ್ಟವಾದ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದ ಸಂಖ್ಯೆ ಇರುವ ರೀತಿಯಲ್ಲಿ ಸ್ಟಾಕ್ ಅನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ:

"sender.addr" -1 12345

256 u>B 256-ಬಿಟ್ ಋಣಾತ್ಮಕವಲ್ಲದ ಪೂರ್ಣಾಂಕವನ್ನು ಬೈಟ್‌ಗಳಿಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap ಸ್ಟಾಕ್‌ನ ಮೇಲಿನ ಎರಡು ಅಂಶಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B 32-ಬಿಟ್ ಪೂರ್ಣಾಂಕವನ್ನು ಬೈಟ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ ಬೈಟ್‌ಗಳ ಎರಡು ಅನುಕ್ರಮಗಳನ್ನು ಸಂಪರ್ಕಿಸುತ್ತದೆ.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

ಮತ್ತೆ swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

ಮತ್ತು ಅಂತಿಮವಾಗಿ ಬೈಟ್‌ಗಳನ್ನು ಫೈಲ್‌ಗೆ ಬರೆಯಲಾಗುತ್ತದೆ B>file. ಇದರ ನಂತರ ನಮ್ಮ ಸ್ಟಾಕ್ ಖಾಲಿಯಾಗಿದೆ. ನಾವು ನಿಲ್ಲಿಸುತ್ತೇವೆ Fift. ಪ್ರಸ್ತುತ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ sender.addr. ರಚಿಸಿದ ಫೋಲ್ಡರ್‌ಗೆ ಫೈಲ್ ಅನ್ನು ಸರಿಸೋಣ test/addresses/.

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

ಈಗ ಲಾಟರಿಯ ತರ್ಕವನ್ನು ನೋಡೋಣ.

ನಾವು ಮಾಡುವ ಮೊದಲ ಕೆಲಸವೆಂದರೆ ಸಂದೇಶವನ್ನು ಪರಿಶೀಲಿಸುವುದು bounced ಅಥವಾ ಇಲ್ಲದಿದ್ದರೆ bounced, ನಂತರ ನಾವು ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತೇವೆ. bounced ಕೆಲವು ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ ಒಪ್ಪಂದವು ಗ್ರಾಂಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂದರ್ಥ. ದೋಷವು ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಸಂಭವಿಸಿದಲ್ಲಿ ನಾವು ಗ್ರಾಂಗಳನ್ನು ಹಿಂತಿರುಗಿಸುವುದಿಲ್ಲ.

ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ಬ್ಯಾಲೆನ್ಸ್ ಅರ್ಧ ಗ್ರಾಂಗಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ, ನಾವು ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತೇವೆ.

ಮುಂದೆ, ಸಂದೇಶವು ಬಂದ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ವಿಳಾಸವನ್ನು ನಾವು ಪಾರ್ಸ್ ಮಾಡುತ್ತೇವೆ.

ನಾವು ಸಂಗ್ರಹಣೆಯಿಂದ ಡೇಟಾವನ್ನು ಓದುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಇಪ್ಪತ್ತಕ್ಕಿಂತ ಹೆಚ್ಚು ಇದ್ದರೆ ಇತಿಹಾಸದಿಂದ ಹಳೆಯ ಪಂತಗಳನ್ನು ಅಳಿಸುತ್ತೇವೆ. ಅನುಕೂಲಕ್ಕಾಗಿ, ನಾನು ಮೂರು ಹೆಚ್ಚುವರಿ ಕಾರ್ಯಗಳನ್ನು ಬರೆದಿದ್ದೇನೆ pack_order(), unpack_order(), remove_old_orders().

ಮುಂದೆ, ಪಾವತಿಗೆ ಸಮತೋಲನವು ಸಾಕಾಗದಿದ್ದರೆ ನಾವು ನೋಡುತ್ತೇವೆ, ನಂತರ ಇದು ಪಂತವಲ್ಲ, ಆದರೆ ಮರುಪೂರಣ ಎಂದು ನಾವು ಪರಿಗಣಿಸುತ್ತೇವೆ ಮತ್ತು ಮರುಪೂರಣವನ್ನು ಉಳಿಸುತ್ತೇವೆ orders.

ನಂತರ ಅಂತಿಮವಾಗಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಸಾರ.

ಮೊದಲನೆಯದಾಗಿ, ಆಟಗಾರನು ಕಳೆದುಕೊಂಡರೆ, ನಾವು ಅದನ್ನು ಬೆಟ್ಟಿಂಗ್ ಇತಿಹಾಸದಲ್ಲಿ ಉಳಿಸುತ್ತೇವೆ ಮತ್ತು ಮೊತ್ತವು 3 ಗ್ರಾಂಗಳಿಗಿಂತ ಹೆಚ್ಚು ಇದ್ದರೆ, ನಾವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಮಾಲೀಕರಿಗೆ 1/3 ಅನ್ನು ಕಳುಹಿಸುತ್ತೇವೆ.

ಆಟಗಾರನು ಗೆದ್ದರೆ, ನಾವು ಆಟಗಾರನ ವಿಳಾಸಕ್ಕೆ ಡಬಲ್ ಮೊತ್ತವನ್ನು ಕಳುಹಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಇತಿಹಾಸದಲ್ಲಿ ಪಂತದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಉಳಿಸುತ್ತೇವೆ.

() recv_internal(int order_amount, cell in_msg_cell, slice in_msg) impure {
    var cs = in_msg_cell.begin_parse();
    int flags = cs~load_uint(4);  ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
    if (flags & 1) { ;; ignore bounced
        return ();
    }
    if (order_amount < 500000000) { ;; just receive grams without changing state 
        return ();
    }
    slice src_addr_slice = cs~load_msg_addr();
    (int src_wc, int src_addr) = parse_std_addr(src_addr_slice);
    (int stored_seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) = unpack_state();
    orders = remove_old_orders(orders, order_seqno);
    if (balance() < 2 * order_amount + 500000000) { ;; not enough grams to pay the bet back, so this is re-fill
        builder order = pack_order(order_seqno, 1, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        return ();
    }
    if (rand(10) >= 4) {
        builder order = pack_order(order_seqno, 3, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        if (order_amount > 3000000000) {
            send_grams(owner_wc, owner_account_id, order_amount / 3);
        }
        return ();
    }
    send_grams(src_wc, src_addr, 2 * order_amount);
    builder order = pack_order(order_seqno, 2, now(), order_amount, src_wc, src_addr);
    orders~udict_set_builder(32, order_seqno, order);
    set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins + 1, incoming_amount, outgoing_amount + 2 * order_amount, owner_wc, owner_account_id, orders));
}

ಅದು ಅಷ್ಟೆ. ಅನುಗುಣವಾದ ಬದ್ಧತೆ.

ಈಗ ಉಳಿದಿರುವುದು ಸರಳವಾಗಿದೆ, ನಾವು ಪಡೆಯಲು-ವಿಧಾನಗಳನ್ನು ರಚಿಸೋಣ ಇದರಿಂದ ನಾವು ಹೊರಗಿನ ಪ್ರಪಂಚದಿಂದ ಒಪ್ಪಂದದ ಸ್ಥಿತಿಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಬಹುದು (ವಾಸ್ತವವಾಗಿ, ಅವರ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಸಂಗ್ರಹಣೆಯಿಂದ ಡೇಟಾವನ್ನು ಓದಿ).

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

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಪ್ರಕಟಿಸುವಾಗ ಸಂಭವಿಸುವ ಮೊದಲ ವಿನಂತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸಲು ನಾನು ಮರೆತಿದ್ದೇನೆ. ಅನುಗುಣವಾದ ಬದ್ಧತೆ. ಮತ್ತು ಮುಂದೆ ಸರಿಪಡಿಸಲಾಗಿದೆ 1/3 ಮೊತ್ತವನ್ನು ಮಾಲೀಕರ ಖಾತೆಗೆ ಕಳುಹಿಸುವ ದೋಷ.

ಮುಂದಿನ ಹಂತವು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಪ್ರಕಟಿಸುವುದು. ಫೋಲ್ಡರ್ ಅನ್ನು ರಚಿಸೋಣ requests.

ನಾನು ಪ್ರಕಟಣೆಯ ಕೋಡ್ ಅನ್ನು ಆಧಾರವಾಗಿ ತೆಗೆದುಕೊಂಡೆ simple-wallet-code.fc ಇದು ಹುಡುಕಬಹುದು ಅಧಿಕೃತ ಭಂಡಾರದಲ್ಲಿ.

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

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

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

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

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

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

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

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

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

account state is empty

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

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

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

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

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

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

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

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ಇತರ ವಿಷಯಗಳ ಜೊತೆಗೆ ನಾವು ಪಡೆಯುತ್ತೇವೆ.

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

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

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

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

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

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

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

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

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

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

ಆರಂಭ lite-client ಮತ್ತು ನಾವು ಬರೆದ ವಿಧಾನಗಳನ್ನು ರನ್ ಮಾಡಿ.

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

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

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

ನಿಮ್ಮ ಬೆಟ್ ಇತಿಹಾಸವನ್ನು ಕೇಳೋಣ.

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

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

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

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

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

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

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

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

ನಂತರದ

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

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

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

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

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

ಉಲ್ಲೇಖಗಳು

1. ಅಧಿಕೃತ TON ದಸ್ತಾವೇಜನ್ನು: https://test.ton.org
2. ಅಧಿಕೃತ ಟನ್ ರೆಪೊಸಿಟರಿ: https://github.com/ton-blockchain/ton
3. ವಿವಿಧ ವೇದಿಕೆಗಳಿಗಾಗಿ ಅಧಿಕೃತ ವಾಲೆಟ್: https://wallet.ton.org
4. ಈ ಲೇಖನದಿಂದ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ಭಂಡಾರ: https://github.com/raiym/astonished
5. ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದ ವೆಬ್‌ಸೈಟ್‌ಗೆ ಲಿಂಕ್ ಮಾಡಿ: https://ton-lottery.appspot.com
6. FunC ಗಾಗಿ ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋ ಕೋಡ್‌ಗಾಗಿ ವಿಸ್ತರಣೆಗಾಗಿ ರೆಪೊಸಿಟರಿ: https://github.com/raiym/func-visual-studio-plugin
7. ಟೆಲಿಗ್ರಾಮ್‌ನಲ್ಲಿ ಟನ್ ಕುರಿತು ಚಾಟ್ ಮಾಡಿ, ಇದು ಆರಂಭಿಕ ಹಂತದಲ್ಲಿ ಅದನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಿಜವಾಗಿಯೂ ಸಹಾಯ ಮಾಡಿದೆ. TON ಗಾಗಿ ಏನನ್ನಾದರೂ ಬರೆದವರೆಲ್ಲರೂ ಇದ್ದಾರೆ ಎಂದು ನಾನು ಹೇಳಿದರೆ ಅದು ತಪ್ಪಾಗುವುದಿಲ್ಲ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಅಲ್ಲಿ ನೀವು ಪರೀಕ್ಷಾ ಗ್ರಾಂಗಳನ್ನು ಸಹ ಕೇಳಬಹುದು. 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