TON ਵਿੱਚ ਇੱਕ ਸਮਾਰਟ ਇਕਰਾਰਨਾਮੇ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਅਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ

ਇਹ ਲੇਖ ਕਿਸ ਬਾਰੇ ਹੈ?

ਲੇਖ ਵਿੱਚ ਮੈਂ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗਾ ਕਿ ਮੈਂ ਪਹਿਲੇ (ਦੋ ਵਿੱਚੋਂ) ਟੈਲੀਗ੍ਰਾਮ ਬਲਾਕਚੈਨ ਮੁਕਾਬਲੇ ਵਿੱਚ ਕਿਵੇਂ ਹਿੱਸਾ ਲਿਆ, ਕੋਈ ਇਨਾਮ ਨਹੀਂ ਲਿਆ, ਅਤੇ ਇੱਕ ਲੇਖ ਵਿੱਚ ਆਪਣੇ ਤਜ਼ਰਬੇ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਤਾਂ ਜੋ ਇਹ ਭੁਲੇਖੇ ਵਿੱਚ ਨਾ ਡੁੱਬ ਜਾਵੇ ਅਤੇ, ਸ਼ਾਇਦ, ਮਦਦ ਕਰ ਸਕੇ। ਕੋਈ

ਕਿਉਂਕਿ ਮੈਂ ਐਬਸਟਰੈਕਟ ਕੋਡ ਨਹੀਂ ਲਿਖਣਾ ਚਾਹੁੰਦਾ ਸੀ, ਪਰ ਕੁਝ ਕੰਮ ਕਰਨ ਲਈ, ਲੇਖ ਲਈ ਮੈਂ ਇੱਕ ਤਤਕਾਲ ਲਾਟਰੀ ਲਈ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲਿਖਿਆ ਅਤੇ ਇੱਕ ਵੈਬਸਾਈਟ ਜੋ ਇੰਟਰਮੀਡੀਏਟ ਸਟੋਰੇਜ ਦੀ ਵਰਤੋਂ ਕੀਤੇ ਬਿਨਾਂ TON ਤੋਂ ਸਿੱਧਾ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਡੇਟਾ ਦਿਖਾਉਂਦੀ ਹੈ।

ਲੇਖ ਉਹਨਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ ਜੋ TON ਵਿੱਚ ਆਪਣਾ ਪਹਿਲਾ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹਨ, ਪਰ ਇਹ ਨਹੀਂ ਜਾਣਦੇ ਕਿ ਕਿੱਥੇ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ.

ਲਾਟਰੀ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਮੈਂ ਵਾਤਾਵਰਣ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਤੋਂ ਲੈ ਕੇ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ, ਇਸ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ, ਅਤੇ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਪ੍ਰਕਾਸ਼ਤ ਕਰਨ ਲਈ ਇੱਕ ਵੈਬਸਾਈਟ ਲਿਖਣ ਤੱਕ ਜਾਵਾਂਗਾ।

ਮੁਕਾਬਲੇ ਵਿੱਚ ਭਾਗ ਲੈਣ ਬਾਰੇ

ਪਿਛਲੇ ਅਕਤੂਬਰ, ਟੈਲੀਗ੍ਰਾਮ ਨੇ ਨਵੀਆਂ ਭਾਸ਼ਾਵਾਂ ਦੇ ਨਾਲ ਇੱਕ ਬਲਾਕਚੈਨ ਮੁਕਾਬਲੇ ਦੀ ਘੋਸ਼ਣਾ ਕੀਤੀ Fift и FunC. ਪੰਜ ਪ੍ਰਸਤਾਵਿਤ ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਵਿੱਚੋਂ ਕਿਸੇ ਨੂੰ ਵੀ ਲਿਖਣਾ ਚੁਣਨਾ ਜ਼ਰੂਰੀ ਸੀ। ਮੈਂ ਸੋਚਿਆ ਕਿ ਕੁਝ ਵੱਖਰਾ ਕਰਨਾ, ਭਾਸ਼ਾ ਸਿੱਖਣਾ ਅਤੇ ਕੁਝ ਬਣਾਉਣਾ ਚੰਗਾ ਲੱਗੇਗਾ, ਭਾਵੇਂ ਮੈਨੂੰ ਭਵਿੱਖ ਵਿੱਚ ਕੁਝ ਹੋਰ ਲਿਖਣਾ ਨਾ ਪਵੇ। ਨਾਲ ਹੀ, ਵਿਸ਼ਾ ਲਗਾਤਾਰ ਬੁੱਲ੍ਹਾਂ 'ਤੇ ਹੈ.

ਇਹ ਕਹਿਣਾ ਮਹੱਤਵਪੂਰਣ ਹੈ ਕਿ ਮੇਰੇ ਕੋਲ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿਕਸਿਤ ਕਰਨ ਦਾ ਕੋਈ ਅਨੁਭਵ ਨਹੀਂ ਸੀ।

ਮੈਂ ਅੰਤ ਤੱਕ ਹਿੱਸਾ ਲੈਣ ਦੀ ਯੋਜਨਾ ਬਣਾਈ ਜਦੋਂ ਤੱਕ ਮੈਂ ਨਹੀਂ ਕਰ ਸਕਦਾ ਅਤੇ ਫਿਰ ਇੱਕ ਸਮੀਖਿਆ ਲੇਖ ਲਿਖ ਸਕਦਾ ਹਾਂ, ਪਰ ਮੈਂ ਪਹਿਲੇ ਇੱਕ ਵਿੱਚ ਤੁਰੰਤ ਅਸਫਲ ਰਿਹਾ. ਆਈ ਇੱਕ ਬਟੂਆ ਲਿਖਿਆ ਬਹੁ-ਦਸਤਖਤ ਚਾਲੂ ਨਾਲ FunC ਅਤੇ ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ। ਮੈਂ ਇਸਨੂੰ ਇੱਕ ਅਧਾਰ ਵਜੋਂ ਲਿਆ ਇਕਸਾਰਤਾ 'ਤੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ.

ਉਸ ਸਮੇਂ, ਮੈਂ ਸੋਚਿਆ ਕਿ ਇਹ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਘੱਟੋ ਘੱਟ ਕੁਝ ਇਨਾਮੀ ਸਥਾਨ ਲੈਣ ਲਈ ਕਾਫ਼ੀ ਸੀ. ਨਤੀਜੇ ਵਜੋਂ, 40 ਵਿੱਚੋਂ ਲਗਭਗ 60 ਭਾਗੀਦਾਰ ਇਨਾਮ ਜੇਤੂ ਬਣ ਗਏ ਅਤੇ ਮੈਂ ਉਹਨਾਂ ਵਿੱਚੋਂ ਨਹੀਂ ਸੀ। ਆਮ ਤੌਰ 'ਤੇ, ਇਸ ਵਿੱਚ ਕੁਝ ਵੀ ਗਲਤ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ ਗੱਲ ਨੇ ਮੈਨੂੰ ਪਰੇਸ਼ਾਨ ਕੀਤਾ. ਨਤੀਜਿਆਂ ਦੀ ਘੋਸ਼ਣਾ ਦੇ ਸਮੇਂ, ਮੇਰੇ ਇਕਰਾਰਨਾਮੇ ਲਈ ਟੈਸਟ ਦੀ ਸਮੀਖਿਆ ਨਹੀਂ ਕੀਤੀ ਗਈ ਸੀ, ਮੈਂ ਚੈਟ ਵਿੱਚ ਭਾਗ ਲੈਣ ਵਾਲਿਆਂ ਨੂੰ ਪੁੱਛਿਆ ਕਿ ਕੀ ਕੋਈ ਹੋਰ ਸੀ ਜਿਸ ਕੋਲ ਇਹ ਨਹੀਂ ਸੀ, ਕੋਈ ਵੀ ਨਹੀਂ ਸੀ.

ਜ਼ਾਹਰ ਤੌਰ 'ਤੇ ਮੇਰੇ ਸੁਨੇਹਿਆਂ ਵੱਲ ਧਿਆਨ ਦਿੰਦੇ ਹੋਏ, ਦੋ ਦਿਨ ਬਾਅਦ ਜੱਜਾਂ ਨੇ ਇੱਕ ਟਿੱਪਣੀ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੀ ਅਤੇ ਮੈਨੂੰ ਅਜੇ ਵੀ ਇਹ ਸਮਝ ਨਹੀਂ ਆ ਰਿਹਾ ਹੈ ਕਿ ਕੀ ਉਨ੍ਹਾਂ ਨੇ ਨਿਰਣਾ ਦੇ ਦੌਰਾਨ ਗਲਤੀ ਨਾਲ ਮੇਰੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਖੁੰਝਾਇਆ ਜਾਂ ਬਸ ਇਹ ਸੋਚਿਆ ਕਿ ਇਹ ਇੰਨਾ ਬੁਰਾ ਸੀ ਕਿ ਇਸ ਨੂੰ ਟਿੱਪਣੀ ਦੀ ਲੋੜ ਨਹੀਂ ਸੀ। ਮੈਂ ਪੰਨੇ 'ਤੇ ਇੱਕ ਸਵਾਲ ਪੁੱਛਿਆ, ਪਰ ਜਵਾਬ ਨਹੀਂ ਮਿਲਿਆ। ਹਾਲਾਂਕਿ ਇਹ ਕੋਈ ਭੇਤ ਨਹੀਂ ਹੈ ਕਿ ਕਿਸ ਨੇ ਨਿਰਣਾ ਕੀਤਾ, ਮੈਂ ਨਿੱਜੀ ਸੰਦੇਸ਼ ਲਿਖਣਾ ਬੇਲੋੜਾ ਸਮਝਿਆ.

ਸਮਝਣ ਵਿੱਚ ਬਹੁਤ ਸਮਾਂ ਲੱਗ ਗਿਆ, ਇਸ ਲਈ ਇੱਕ ਲੇਖ ਲਿਖਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਗਿਆ। ਕਿਉਂਕਿ ਅਜੇ ਬਹੁਤ ਸਾਰੀ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੈ, ਇਹ ਲੇਖ ਦਿਲਚਸਪੀ ਰੱਖਣ ਵਾਲੇ ਹਰੇਕ ਲਈ ਸਮਾਂ ਬਚਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ।

TON ਵਿੱਚ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੀ ਧਾਰਨਾ

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਕੁਝ ਵੀ ਲਿਖੋ, ਤੁਹਾਨੂੰ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਇਸ ਚੀਜ਼ ਤੱਕ ਕਿਸ ਪਾਸੇ ਪਹੁੰਚਣਾ ਹੈ. ਇਸ ਲਈ, ਹੁਣ ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗਾ ਕਿ ਸਿਸਟਮ ਵਿੱਚ ਕਿਹੜੇ ਹਿੱਸੇ ਸ਼ਾਮਲ ਹਨ. ਵਧੇਰੇ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ, ਘੱਟੋ-ਘੱਟ ਕਿਸੇ ਕਿਸਮ ਦਾ ਕੰਮਕਾਜੀ ਇਕਰਾਰਨਾਮਾ ਲਿਖਣ ਲਈ ਤੁਹਾਨੂੰ ਕਿਹੜੇ ਹਿੱਸੇ ਜਾਣਨ ਦੀ ਲੋੜ ਹੈ।

ਅਸੀਂ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲਿਖਣ ਅਤੇ ਇਸ ਨਾਲ ਕੰਮ ਕਰਨ 'ਤੇ ਧਿਆਨ ਦੇਵਾਂਗੇ TON Virtual Machine (TVM), Fift и FunC, ਇਸ ਲਈ ਲੇਖ ਇੱਕ ਨਿਯਮਤ ਪ੍ਰੋਗਰਾਮ ਦੇ ਵਿਕਾਸ ਦੇ ਵਰਣਨ ਵਰਗਾ ਹੈ. ਅਸੀਂ ਇਸ ਗੱਲ 'ਤੇ ਧਿਆਨ ਨਹੀਂ ਦੇਵਾਂਗੇ ਕਿ ਪਲੇਟਫਾਰਮ ਖੁਦ ਇੱਥੇ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।

ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ TVM ਅਤੇ ਭਾਸ਼ਾ Fift ਵਧੀਆ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ ਹਨ। ਮੁਕਾਬਲੇ ਵਿਚ ਹਿੱਸਾ ਲੈਣ ਸਮੇਂ ਅਤੇ ਹੁਣ ਮੌਜੂਦਾ ਇਕਰਾਰਨਾਮੇ ਨੂੰ ਲਿਖਣ ਵੇਲੇ, ਮੈਂ ਅਕਸਰ ਉਸ ਵੱਲ ਮੁੜਿਆ.

ਮੁੱਖ ਭਾਸ਼ਾ ਜਿਸ ਵਿੱਚ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲਿਖੇ ਜਾਂਦੇ ਹਨ FunC. ਇਸ ਸਮੇਂ ਇਸ 'ਤੇ ਕੋਈ ਦਸਤਾਵੇਜ਼ ਨਹੀਂ ਹੈ, ਇਸਲਈ ਕੁਝ ਲਿਖਣ ਲਈ ਤੁਹਾਨੂੰ ਅਧਿਕਾਰਤ ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦਾ ਅਧਿਐਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਅਤੇ ਉੱਥੇ ਖੁਦ ਭਾਸ਼ਾ ਨੂੰ ਲਾਗੂ ਕਰਨਾ, ਨਾਲ ਹੀ ਤੁਸੀਂ ਪਿਛਲੇ ਦੋ ਤੋਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦੇਖ ਸਕਦੇ ਹੋ। ਮੁਕਾਬਲੇ ਲੇਖ ਦੇ ਅੰਤ ਵਿੱਚ ਲਿੰਕ.

ਮੰਨ ਲਓ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲਿਖ ਚੁੱਕੇ ਹਾਂ FunC, ਉਸ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਕੋਡ ਨੂੰ ਫਿਫਟ ਅਸੈਂਬਲਰ ਵਿੱਚ ਕੰਪਾਇਲ ਕਰਦੇ ਹਾਂ।

ਕੰਪਾਇਲ ਕੀਤਾ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤਾ ਜਾਣਾ ਬਾਕੀ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਵਿੱਚ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ Fift, ਜੋ ਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਕੋਡ ਅਤੇ ਕੁਝ ਹੋਰ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਲਵੇਗਾ, ਅਤੇ ਆਉਟਪੁੱਟ ਐਕਸਟੈਂਸ਼ਨ ਵਾਲੀ ਇੱਕ ਫਾਈਲ ਹੋਵੇਗੀ। .boc (ਜਿਸਦਾ ਮਤਲਬ ਹੈ "ਸੈੱਲਾਂ ਦਾ ਬੈਗ"), ਅਤੇ, ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਅਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਲਿਖਦੇ ਹਾਂ, ਇੱਕ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਅਤੇ ਪਤਾ, ਜੋ ਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਕੋਡ ਦੇ ਅਧਾਰ 'ਤੇ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਪਤੇ 'ਤੇ ਗ੍ਰਾਮ ਭੇਜ ਸਕਦੇ ਹੋ ਜੋ ਅਜੇ ਪ੍ਰਕਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ।

TON ਵਿੱਚ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਲਈ ਪ੍ਰਾਪਤ ਕੀਤਾ .boc ਫਾਈਲ ਨੂੰ ਇੱਕ ਹਲਕੇ ਕਲਾਇੰਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਲਾਕਚੈਨ ਨੂੰ ਭੇਜਣ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ (ਹੇਠਾਂ ਇਸ ਬਾਰੇ ਹੋਰ)। ਪਰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਗ੍ਰਾਮ ਨੂੰ ਤਿਆਰ ਕੀਤੇ ਪਤੇ 'ਤੇ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਨਹੀਂ ਤਾਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਪ੍ਰਕਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ। ਪ੍ਰਕਾਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਬਾਹਰੋਂ ਸੰਦੇਸ਼ ਭੇਜ ਕੇ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਹਲਕੇ ਕਲਾਇੰਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ) ਜਾਂ ਅੰਦਰੋਂ (ਉਦਾਹਰਣ ਵਜੋਂ, ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੂਜੇ ਨੂੰ TON ਦੇ ਅੰਦਰ ਸੁਨੇਹਾ ਭੇਜ ਕੇ) ਨਾਲ ਗੱਲਬਾਤ ਕਰ ਸਕਦੇ ਹੋ।

ਇੱਕ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਸਮਝ ਜਾਂਦੇ ਹਾਂ ਕਿ ਕੋਡ ਕਿਵੇਂ ਪ੍ਰਕਾਸ਼ਿਤ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ। ਅਸੀਂ ਮੋਟੇ ਤੌਰ 'ਤੇ ਜਾਣਦੇ ਹਾਂ ਕਿ ਅਸੀਂ ਕੀ ਲਿਖਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਅਤੇ ਸਾਡਾ ਪ੍ਰੋਗਰਾਮ ਕਿਵੇਂ ਕੰਮ ਕਰੇਗਾ। ਅਤੇ ਲਿਖਣ ਵੇਲੇ, ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਇਹ ਮੌਜੂਦਾ ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਕਿਵੇਂ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਜਾਂ ਅਸੀਂ ਲਾਗੂਕਰਨ ਕੋਡ ਨੂੰ ਦੇਖਦੇ ਹਾਂ Fift и FunC ਅਧਿਕਾਰਤ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ, ਜਾਂ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਦੇਖੋ।

ਬਹੁਤ ਵਾਰ ਮੈਂ ਟੈਲੀਗ੍ਰਾਮ ਚੈਟ ਵਿੱਚ ਕੀਵਰਡਸ ਦੀ ਖੋਜ ਕੀਤੀ ਜਿੱਥੇ ਸਾਰੇ ਮੁਕਾਬਲੇ ਦੇ ਭਾਗੀਦਾਰ ਅਤੇ ਟੈਲੀਗ੍ਰਾਮ ਕਰਮਚਾਰੀ ਇਕੱਠੇ ਹੋਏ, ਅਤੇ ਅਜਿਹਾ ਹੋਇਆ ਕਿ ਮੁਕਾਬਲੇ ਦੇ ਦੌਰਾਨ ਹਰ ਕੋਈ ਉੱਥੇ ਇਕੱਠੇ ਹੋ ਗਿਆ ਅਤੇ ਫਾਈਫਟ ਅਤੇ ਫਨਸੀ ਬਾਰੇ ਚਰਚਾ ਕਰਨੀ ਸ਼ੁਰੂ ਕਰ ਦਿੱਤੀ। ਲੇਖ ਦੇ ਅੰਤ ਵਿੱਚ ਲਿੰਕ.

ਇਹ ਥਿਊਰੀ ਤੋਂ ਅਭਿਆਸ ਵੱਲ ਜਾਣ ਦਾ ਸਮਾਂ ਹੈ.

TON ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਵਾਤਾਵਰਨ ਤਿਆਰ ਕਰਨਾ

ਮੈਂ ਉਹ ਸਭ ਕੁਝ ਕੀਤਾ ਜੋ MacOS 'ਤੇ ਲੇਖ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਜਾਵੇਗਾ ਅਤੇ ਇਸਨੂੰ ਡੌਕਰ 'ਤੇ ਸਾਫ਼ ਉਬੰਟੂ 18.04 LTS ਵਿੱਚ ਡਬਲ-ਚੈੱਕ ਕੀਤਾ ਹੈ।

ਪਹਿਲੀ ਗੱਲ ਇਹ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਡਾਊਨਲੋਡ ਅਤੇ ਇੰਸਟਾਲ ਹੈ lite-client ਜਿਸ ਨਾਲ ਤੁਸੀਂ TON ਨੂੰ ਬੇਨਤੀਆਂ ਭੇਜ ਸਕਦੇ ਹੋ।

ਅਧਿਕਾਰਤ ਵੈੱਬਸਾਈਟ 'ਤੇ ਹਦਾਇਤਾਂ ਇੰਸਟਾਲੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਾਫ਼ੀ ਵਿਸਥਾਰ ਵਿੱਚ ਅਤੇ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਬਿਆਨ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਕੁਝ ਵੇਰਵਿਆਂ ਨੂੰ ਛੱਡਦੀਆਂ ਹਨ। ਇੱਥੇ ਅਸੀਂ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹਾਂ, ਰਸਤੇ ਵਿੱਚ ਗੁੰਮ ਹੋਈਆਂ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਦੇ ਹੋਏ। ਮੈਂ ਹਰੇਕ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਆਪਣੇ ਆਪ ਕੰਪਾਇਲ ਨਹੀਂ ਕੀਤਾ ਅਤੇ ਅਧਿਕਾਰਤ ਉਬੰਟੂ ਰਿਪੋਜ਼ਟਰੀ (ਮੈਕਓਐਸ 'ਤੇ ਜੋ ਮੈਂ ਵਰਤਿਆ ਹੈ) ਤੋਂ ਸਥਾਪਿਤ ਕੀਤਾ brew).

apt -y install git 
apt -y install wget 
apt -y install cmake 
apt -y install g++ 
apt -y install zlib1g-dev 
apt -y install libssl-dev 

ਇੱਕ ਵਾਰ ਸਾਰੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਸਥਾਪਤ ਹੋਣ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਸਥਾਪਿਤ ਕਰ ਸਕਦੇ ਹੋ lite-client, Fift, FunC.

ਪਹਿਲਾਂ, ਅਸੀਂ TON ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਇਸਦੀ ਨਿਰਭਰਤਾ ਦੇ ਨਾਲ ਕਲੋਨ ਕਰਦੇ ਹਾਂ। ਸਹੂਲਤ ਲਈ, ਅਸੀਂ ਇੱਕ ਫੋਲਡਰ ਵਿੱਚ ਸਭ ਕੁਝ ਕਰਾਂਗੇ ~/TON.

cd ~/TON
git clone https://github.com/ton-blockchain/ton.git
cd ./ton
git submodule update --init --recursive

ਰਿਪੋਜ਼ਟਰੀ ਅਮਲ ਨੂੰ ਵੀ ਸਟੋਰ ਕਰਦੀ ਹੈ Fift и FunC.

ਹੁਣ ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅਸੈਂਬਲ ਕਰਨ ਲਈ ਤਿਆਰ ਹਾਂ। ਰਿਪੋਜ਼ਟਰੀ ਕੋਡ ਨੂੰ ਇੱਕ ਫੋਲਡਰ ਵਿੱਚ ਕਲੋਨ ਕੀਤਾ ਗਿਆ ਹੈ ~/TON/ton. The ~/TON ਇੱਕ ਫੋਲਡਰ ਬਣਾਓ build ਅਤੇ ਇਸ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਇਕੱਠਾ ਕਰੋ।

mkdir ~/TON/build 
cd ~/TON/build
cmake ../ton

ਕਿਉਂਕਿ ਅਸੀਂ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲਿਖਣ ਜਾ ਰਹੇ ਹਾਂ, ਸਾਨੂੰ ਨਾ ਸਿਰਫ਼ ਲੋੜ ਹੈ lite-clientਪਰ Fift с FunC, ਤਾਂ ਆਓ ਸਭ ਕੁਝ ਕੰਪਾਇਲ ਕਰੀਏ। ਇਹ ਕੋਈ ਤੇਜ਼ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਉਡੀਕ ਕਰ ਰਹੇ ਹਾਂ।

cmake --build . --target lite-client
cmake --build . --target fift
cmake --build . --target func

ਅੱਗੇ, ਕੌਂਫਿਗਰੇਸ਼ਨ ਫਾਈਲ ਨੂੰ ਡਾਉਨਲੋਡ ਕਰੋ ਜਿਸ ਵਿੱਚ ਨੋਡ ਬਾਰੇ ਡੇਟਾ ਸ਼ਾਮਲ ਹੈ lite-client ਜੁੜ ਜਾਵੇਗਾ।

wget https://test.ton.org/ton-lite-client-test1.config.json

TON ਨੂੰ ਪਹਿਲੀਆਂ ਬੇਨਤੀਆਂ ਕਰਨਾ

ਹੁਣ ਲਾਂਚ ਕਰੀਏ lite-client.

cd ~/TON/build
./lite-client/lite-client -C ton-lite-client-test1.config.json

ਜੇਕਰ ਬਿਲਡ ਸਫਲ ਸੀ, ਤਾਂ ਲਾਂਚ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਨੋਡ ਨਾਲ ਲਾਈਟ ਕਲਾਇੰਟ ਦੇ ਕੁਨੈਕਸ਼ਨ ਦਾ ਇੱਕ ਲੌਗ ਵੇਖੋਗੇ।

[ 1][t 2][1582054822.963129282][lite-client.h:201][!testnode]   conn ready
[ 2][t 2][1582054823.085654020][lite-client.cpp:277][!testnode] server version is 1.1, capabilities 7
[ 3][t 2][1582054823.085725069][lite-client.cpp:286][!testnode] server time is 1582054823 (delta 0)
...

ਤੁਸੀਂ ਕਮਾਂਡ ਚਲਾ ਸਕਦੇ ਹੋ help ਅਤੇ ਵੇਖੋ ਕਿ ਕਿਹੜੀਆਂ ਕਮਾਂਡਾਂ ਉਪਲਬਧ ਹਨ।

help

ਆਉ ਉਹਨਾਂ ਕਮਾਂਡਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰੀਏ ਜੋ ਅਸੀਂ ਇਸ ਲੇਖ ਵਿੱਚ ਵਰਤਾਂਗੇ।

list of available commands:
last    Get last block and state info from server
sendfile <filename> Load a serialized message from <filename> and send it to server
getaccount <addr> [<block-id-ext>]  Loads the most recent state of specified account; <addr> is in [<workchain>:]<hex-or-base64-addr> format
runmethod <addr> [<block-id-ext>] <method-id> <params>...   Runs GET method <method-id> of account <addr> with specified parameters

last получает последний созданный блок с сервера. 

sendfile <filename> отправляет в TON файл с сообщением, именно с помощью этой команды публикуется смарт-контракт и запрсосы к нему. 

getaccount <addr> загружает текущее состояние смарт-контракта с указанным адресом. 

runmethod <addr> [<block-id-ext>] <method-id> <params>  запускает get-методы смартконтракта. 

ਹੁਣ ਅਸੀਂ ਖੁਦ ਇਕਰਾਰਨਾਮਾ ਲਿਖਣ ਲਈ ਤਿਆਰ ਹਾਂ।

Реализация

ਆਈਡੀਆ

ਜਿਵੇਂ ਕਿ ਮੈਂ ਉੱਪਰ ਲਿਖਿਆ ਹੈ, ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਜੋ ਅਸੀਂ ਲਿਖ ਰਹੇ ਹਾਂ ਇੱਕ ਲਾਟਰੀ ਹੈ.

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਕੋਈ ਲਾਟਰੀ ਨਹੀਂ ਹੈ ਜਿਸ ਵਿਚ ਤੁਹਾਨੂੰ ਟਿਕਟ ਖਰੀਦਣ ਅਤੇ ਇਕ ਘੰਟਾ, ਦਿਨ ਜਾਂ ਮਹੀਨਾ ਇੰਤਜ਼ਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਪਰ ਇਕ ਤਤਕਾਲ ਜਿਸ ਵਿਚ ਉਪਭੋਗਤਾ ਇਕਰਾਰਨਾਮੇ ਦੇ ਪਤੇ 'ਤੇ ਟ੍ਰਾਂਸਫਰ ਕਰਦਾ ਹੈ। N ਗ੍ਰਾਮ, ਅਤੇ ਤੁਰੰਤ ਇਸਨੂੰ ਵਾਪਸ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ 2 * N ਗ੍ਰਾਮ ਜਾਂ ਘਾਟਾ. ਅਸੀਂ ਲਗਭਗ 40% ਜਿੱਤਣ ਦੀ ਸੰਭਾਵਨਾ ਬਣਾਵਾਂਗੇ। ਜੇਕਰ ਭੁਗਤਾਨ ਲਈ ਲੋੜੀਂਦੇ ਗ੍ਰਾਮ ਨਹੀਂ ਹਨ, ਤਾਂ ਅਸੀਂ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਨੂੰ ਟੌਪ-ਅੱਪ ਸਮਝਾਂਗੇ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਸੱਟੇਬਾਜ਼ੀ ਨੂੰ ਰੀਅਲ ਟਾਈਮ ਵਿੱਚ ਅਤੇ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਰੂਪ ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਤਾਂ ਜੋ ਉਪਭੋਗਤਾ ਤੁਰੰਤ ਸਮਝ ਸਕੇ ਕਿ ਉਹ ਜਿੱਤ ਗਿਆ ਜਾਂ ਹਾਰ ਗਿਆ। ਇਸ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਵੈਬਸਾਈਟ ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ TON ਤੋਂ ਸਿੱਧੇ ਸੱਟੇ ਅਤੇ ਨਤੀਜੇ ਦਿਖਾਏਗੀ।

ਇੱਕ ਸਮਾਰਟ ਇਕਰਾਰਨਾਮਾ ਲਿਖਣਾ

ਸਹੂਲਤ ਲਈ, ਮੈਂ FunC ਲਈ ਕੋਡ ਨੂੰ ਉਜਾਗਰ ਕੀਤਾ ਹੈ; ਪਲੱਗਇਨ ਨੂੰ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਕੋਡ ਖੋਜ ਵਿੱਚ ਲੱਭਿਆ ਅਤੇ ਸਥਾਪਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ; ਜੇਕਰ ਤੁਸੀਂ ਅਚਾਨਕ ਕੁਝ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਮੈਂ ਪਲੱਗਇਨ ਨੂੰ ਜਨਤਕ ਤੌਰ 'ਤੇ ਉਪਲਬਧ ਕਰ ਦਿੱਤਾ ਹੈ। ਨਾਲ ਹੀ, ਕਿਸੇ ਨੇ ਪਹਿਲਾਂ ਫਿਫਟ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਪਲੱਗਇਨ ਬਣਾਇਆ ਸੀ, ਤੁਸੀਂ ਇਸਨੂੰ ਵੀ ਸਥਾਪਿਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ VSC ਵਿੱਚ ਲੱਭ ਸਕਦੇ ਹੋ।

ਚਲੋ ਤੁਰੰਤ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਬਣਾਈਏ ਜਿੱਥੇ ਅਸੀਂ ਵਿਚਕਾਰਲੇ ਨਤੀਜੇ ਦੇਵਾਂਗੇ।

ਆਪਣੀ ਜ਼ਿੰਦਗੀ ਨੂੰ ਆਸਾਨ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਇੱਕ ਸਮਾਰਟ ਇਕਰਾਰਨਾਮੇ ਨੂੰ ਲਿਖਾਂਗੇ ਅਤੇ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਇਸਦੀ ਜਾਂਚ ਕਰਾਂਗੇ ਜਦੋਂ ਤੱਕ ਇਹ ਤਿਆਰ ਨਹੀਂ ਹੁੰਦਾ। ਉਸ ਤੋਂ ਬਾਅਦ ਹੀ ਅਸੀਂ ਇਸਨੂੰ TON ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਾਂਗੇ।

ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਦੋ ਬਾਹਰੀ ਤਰੀਕੇ ਹਨ ਜਿਨ੍ਹਾਂ ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਪਹਿਲਾਂ, recv_external() ਇਹ ਫੰਕਸ਼ਨ ਉਦੋਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਇਕਰਾਰਨਾਮੇ ਲਈ ਬੇਨਤੀ ਬਾਹਰੀ ਦੁਨੀਆ ਤੋਂ ਆਉਂਦੀ ਹੈ, ਯਾਨੀ TON ਤੋਂ ਨਹੀਂ, ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ ਅਸੀਂ ਖੁਦ ਇੱਕ ਸੁਨੇਹਾ ਤਿਆਰ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਲਾਈਟ-ਕਲਾਇੰਟ ਦੁਆਰਾ ਭੇਜਦੇ ਹਾਂ। ਦੂਜਾ, recv_internal() ਇਹ ਉਦੋਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ, TON ਦੇ ਅੰਦਰ ਹੀ, ਕੋਈ ਵੀ ਇਕਰਾਰਨਾਮਾ ਸਾਡਾ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ। ਦੋਵਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਵਿੱਚ ਪੈਰਾਮੀਟਰ ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ।

ਆਉ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ ਜੋ ਪ੍ਰਕਾਸ਼ਿਤ ਹੋਣ 'ਤੇ ਕੰਮ ਕਰੇਗੀ, ਪਰ ਇਸ ਵਿੱਚ ਕੋਈ ਕਾਰਜਸ਼ੀਲ ਲੋਡ ਨਹੀਂ ਹੈ।

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

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

ਇੱਥੇ ਸਾਨੂੰ ਇਹ ਦੱਸਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਇਹ ਕੀ ਹੈ slice. TON ਬਲਾਕਚੈਨ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਸਾਰਾ ਡਾਟਾ ਇੱਕ ਸੰਗ੍ਰਹਿ ਹੈ TVM cell ਜ ਬਸ cell, ਅਜਿਹੇ ਸੈੱਲ ਵਿੱਚ ਤੁਸੀਂ 1023 ਬਿੱਟ ਡੇਟਾ ਅਤੇ ਹੋਰ ਸੈੱਲਾਂ ਦੇ 4 ਲਿੰਕ ਤੱਕ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹੋ।

TVM cell slice ਜ slice ਇਹ ਮੌਜੂਦਾ ਦਾ ਹਿੱਸਾ ਹੈ cell ਨੂੰ ਪਾਰਸ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਇਹ ਬਾਅਦ ਵਿੱਚ ਸਪੱਸ਼ਟ ਹੋ ਜਾਵੇਗਾ। ਸਾਡੇ ਲਈ ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ ਕਿ ਅਸੀਂ ਟ੍ਰਾਂਸਫਰ ਕਰ ਸਕਦੇ ਹਾਂ slice ਅਤੇ ਸੁਨੇਹੇ ਦੀ ਕਿਸਮ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਵਿੱਚ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰੋ recv_external() ਜ recv_internal().

impure — ਇੱਕ ਕੀਵਰਡ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਡੇਟਾ ਨੂੰ ਸੋਧਦਾ ਹੈ।

ਆਓ ਇਕਰਾਰਨਾਮੇ ਦੇ ਕੋਡ ਨੂੰ ਇਸ ਵਿਚ ਸੁਰੱਖਿਅਤ ਕਰੀਏ lottery-code.fc ਅਤੇ ਕੰਪਾਇਲ.

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

ਫਲੈਗ ਦੇ ਅਰਥ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੇਖੇ ਜਾ ਸਕਦੇ ਹਨ

~/TON/build/crypto/func -help

ਅਸੀਂ ਵਿੱਚ ਫਿਫਟ ਅਸੈਂਬਲਰ ਕੋਡ ਕੰਪਾਇਲ ਕੀਤਾ ਹੈ lottery-compiled.fif:

// lottery-compiled.fif

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

ਇਸ ਨੂੰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਲਾਂਚ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਇਸਦੇ ਲਈ ਅਸੀਂ ਵਾਤਾਵਰਣ ਨੂੰ ਤਿਆਰ ਕਰਾਂਗੇ।

ਨੋਟ ਕਰੋ ਕਿ ਪਹਿਲੀ ਲਾਈਨ ਜੁੜਦੀ ਹੈ Asm.fif, ਇਹ ਫਿਫਟ ਅਸੈਂਬਲਰ ਲਈ ਫਿਫਟ ਵਿੱਚ ਲਿਖਿਆ ਕੋਡ ਹੈ।

ਕਿਉਂਕਿ ਅਸੀਂ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਚਲਾਉਣਾ ਅਤੇ ਟੈਸਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਅਸੀਂ ਇੱਕ ਫਾਈਲ ਬਣਾਵਾਂਗੇ lottery-test-suite.fif ਅਤੇ ਉਥੇ ਕੰਪਾਇਲ ਕੀਤੇ ਕੋਡ ਦੀ ਨਕਲ ਕਰੋ, ਇਸ ਵਿੱਚ ਆਖਰੀ ਲਾਈਨ ਨੂੰ ਬਦਲੋ, ਜੋ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਕੋਡ ਨੂੰ ਇੱਕ ਸਥਿਰ ਵਿੱਚ ਲਿਖਦਾ ਹੈ codeਫਿਰ ਇਸਨੂੰ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ:

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

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

ਹੁਣ ਤੱਕ ਇਹ ਸਪੱਸ਼ਟ ਜਾਪਦਾ ਹੈ, ਆਓ ਹੁਣ ਉਸੇ ਫਾਈਲ ਵਿੱਚ ਕੋਡ ਜੋੜੀਏ ਜਿਸਦੀ ਵਰਤੋਂ ਅਸੀਂ TVM ਨੂੰ ਲਾਂਚ ਕਰਨ ਲਈ ਕਰਾਂਗੇ।

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

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

В c7 ਅਸੀਂ ਸੰਦਰਭ ਨੂੰ ਰਿਕਾਰਡ ਕਰਦੇ ਹਾਂ, ਯਾਨੀ ਉਹ ਡੇਟਾ ਜਿਸ ਨਾਲ TVM (ਜਾਂ ਨੈੱਟਵਰਕ ਸਥਿਤੀ) ਨੂੰ ਲਾਂਚ ਕੀਤਾ ਜਾਵੇਗਾ। ਮੁਕਾਬਲੇ ਦੇ ਦੌਰਾਨ ਵੀ, ਡਿਵੈਲਪਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੇ ਦਿਖਾਇਆ ਕਿ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ c7 ਅਤੇ ਮੈਂ ਕਾਪੀ ਕੀਤਾ। ਇਸ ਲੇਖ ਵਿਚ ਸਾਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ rand_seed ਕਿਉਂਕਿ ਇੱਕ ਬੇਤਰਤੀਬ ਸੰਖਿਆ ਦੀ ਉਤਪੱਤੀ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਅਤੇ ਜੇਕਰ ਬਦਲਿਆ ਨਹੀਂ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਹਰ ਵਾਰ ਉਹੀ ਨੰਬਰ ਵਾਪਸ ਕੀਤਾ ਜਾਵੇਗਾ।

recv_internal и recv_external 0 ਅਤੇ -1 ਮੁੱਲਾਂ ਵਾਲੇ ਸਥਿਰਾਂਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਸੰਬੰਧਿਤ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੋਣਗੇ।

ਹੁਣ ਅਸੀਂ ਆਪਣੇ ਖਾਲੀ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲਈ ਪਹਿਲਾ ਟੈਸਟ ਬਣਾਉਣ ਲਈ ਤਿਆਰ ਹਾਂ। ਸਪਸ਼ਟਤਾ ਲਈ, ਹੁਣ ਲਈ ਅਸੀਂ ਸਾਰੇ ਟੈਸਟਾਂ ਨੂੰ ਉਸੇ ਫਾਈਲ ਵਿੱਚ ਜੋੜਾਂਗੇ lottery-test-suite.fif.

ਚਲੋ ਇੱਕ ਵੇਰੀਏਬਲ ਬਣਾਉ storage ਅਤੇ ਇਸ ਵਿੱਚ ਇੱਕ ਖਾਲੀ ਲਿਖੋ cell, ਇਹ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਹੋਵੇਗੀ।

message ਇਹ ਉਹ ਸੰਦੇਸ਼ ਹੈ ਜੋ ਅਸੀਂ ਬਾਹਰੋਂ ਸਮਾਰਟ ਸੰਪਰਕ ਨੂੰ ਸੰਚਾਰਿਤ ਕਰਾਂਗੇ। ਅਸੀਂ ਇਸਨੂੰ ਹੁਣ ਲਈ ਖਾਲੀ ਵੀ ਕਰ ਦੇਵਾਂਗੇ।

variable storage 
<b b> storage ! 

variable message 
<b b> message ! 

ਅਸਥਿਰਾਂ ਅਤੇ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਤਿਆਰ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ TVM ਨੂੰ ਲਾਂਚ ਕਰਦੇ ਹਾਂ runvmctx ਅਤੇ ਬਣਾਏ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਇਨਪੁਟ ਵਿੱਚ ਪਾਸ ਕਰੋ।

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx 

ਅੰਤ ਵਿੱਚ ਅਸੀਂ ਕਾਮਯਾਬ ਹੋਵਾਂਗੇ ਇਸ ਤਰ੍ਹਾਂ ਲਈ ਵਿਚਕਾਰਲਾ ਕੋਡ Fift.

ਹੁਣ ਅਸੀਂ ਨਤੀਜਾ ਕੋਡ ਚਲਾ ਸਕਦੇ ਹਾਂ।

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

ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਗਲਤੀ ਦੇ ਚੱਲਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਆਉਟਪੁੱਟ ਵਿੱਚ ਅਸੀਂ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲੌਗ ਵੇਖਾਂਗੇ:

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

ਬਹੁਤ ਵਧੀਆ, ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦਾ ਪਹਿਲਾ ਕਾਰਜਸ਼ੀਲ ਸੰਸਕਰਣ ਲਿਖਿਆ ਹੈ।

ਹੁਣ ਸਾਨੂੰ ਕਾਰਜਸ਼ੀਲਤਾ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਪਹਿਲਾਂ ਆਓ ਉਨ੍ਹਾਂ ਸੰਦੇਸ਼ਾਂ ਨਾਲ ਨਜਿੱਠੀਏ ਜੋ ਬਾਹਰੀ ਦੁਨੀਆ ਤੋਂ ਆਉਂਦੇ ਹਨ recv_external()

ਡਿਵੈਲਪਰ ਖੁਦ ਸੁਨੇਹਾ ਫਾਰਮੈਟ ਚੁਣਦਾ ਹੈ ਜਿਸਨੂੰ ਇਕਰਾਰਨਾਮਾ ਸਵੀਕਾਰ ਕਰ ਸਕਦਾ ਹੈ।

ਪਰ ਆਮ ਤੌਰ 'ਤੇ

• ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਅਸੀਂ ਆਪਣੇ ਇਕਰਾਰਨਾਮੇ ਨੂੰ ਬਾਹਰੀ ਦੁਨੀਆਂ ਤੋਂ ਬਚਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਅਤੇ ਇਸ ਨੂੰ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਤਾਂ ਜੋ ਸਿਰਫ਼ ਇਕਰਾਰਨਾਮੇ ਦਾ ਮਾਲਕ ਹੀ ਇਸ ਨੂੰ ਬਾਹਰੀ ਸੰਦੇਸ਼ ਭੇਜ ਸਕੇ।
• ਦੂਜਾ, ਜਦੋਂ ਅਸੀਂ TON ਨੂੰ ਇੱਕ ਵੈਧ ਸੁਨੇਹਾ ਭੇਜਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਇਹ ਇੱਕ ਵਾਰ ਹੀ ਹੋਵੇ ਅਤੇ ਜਦੋਂ ਅਸੀਂ ਉਹੀ ਸੁਨੇਹਾ ਦੁਬਾਰਾ ਭੇਜਦੇ ਹਾਂ, ਤਾਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਇਸਨੂੰ ਰੱਦ ਕਰਦਾ ਹੈ।

ਇਸ ਲਈ ਲਗਭਗ ਹਰ ਇਕਰਾਰਨਾਮਾ ਇਹਨਾਂ ਦੋ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ ਸਾਡਾ ਇਕਰਾਰਨਾਮਾ ਬਾਹਰੀ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ਸਾਨੂੰ ਇਸਦਾ ਵੀ ਧਿਆਨ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।

ਅਸੀਂ ਇਸਨੂੰ ਉਲਟ ਕ੍ਰਮ ਵਿੱਚ ਕਰਾਂਗੇ। ਪਹਿਲਾਂ, ਆਉ ਦੁਹਰਾਓ ਨਾਲ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰੀਏ; ਜੇ ਇਕਰਾਰਨਾਮੇ ਨੇ ਪਹਿਲਾਂ ਹੀ ਅਜਿਹਾ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਹੈ ਅਤੇ ਇਸਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਹੈ, ਤਾਂ ਇਹ ਇਸਨੂੰ ਦੂਜੀ ਵਾਰ ਲਾਗੂ ਨਹੀਂ ਕਰੇਗਾ. ਅਤੇ ਫਿਰ ਅਸੀਂ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਾਂਗੇ ਤਾਂ ਜੋ ਸਿਰਫ ਲੋਕਾਂ ਦਾ ਇੱਕ ਖਾਸ ਸਰਕਲ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਸੰਦੇਸ਼ ਭੇਜ ਸਕੇ.

ਡੁਪਲੀਕੇਟ ਸੁਨੇਹਿਆਂ ਨਾਲ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦੇ ਵੱਖ-ਵੱਖ ਤਰੀਕੇ ਹਨ। ਇੱਥੇ ਅਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਕਰਾਂਗੇ। ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ, ਅਸੀਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਸੁਨੇਹਿਆਂ ਦੇ ਕਾਊਂਟਰ ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ 0 ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ। ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲਈ ਹਰੇਕ ਸੰਦੇਸ਼ ਵਿੱਚ, ਅਸੀਂ ਮੌਜੂਦਾ ਕਾਊਂਟਰ ਮੁੱਲ ਨੂੰ ਜੋੜਾਂਗੇ। ਜੇਕਰ ਸੁਨੇਹੇ ਵਿੱਚ ਕਾਊਂਟਰ ਮੁੱਲ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਮੁੱਲ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਤਾਂ ਅਸੀਂ ਇਸ 'ਤੇ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ ਕਰਦੇ; ਜੇਕਰ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸ 'ਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਦੇ ਹਾਂ ਅਤੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਕਾਊਂਟਰ ਨੂੰ 1 ਤੱਕ ਵਧਾ ਦਿੰਦੇ ਹਾਂ।

ਚਲੋ ਵਾਪਸ ਆਓ lottery-test-suite.fif ਅਤੇ ਇਸ ਵਿੱਚ ਇੱਕ ਦੂਜਾ ਟੈਸਟ ਸ਼ਾਮਲ ਕਰੋ। ਜੇਕਰ ਅਸੀਂ ਇੱਕ ਗਲਤ ਨੰਬਰ ਭੇਜਦੇ ਹਾਂ, ਤਾਂ ਕੋਡ ਨੂੰ ਇੱਕ ਅਪਵਾਦ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਕੰਟਰੈਕਟ ਡੇਟਾ ਨੂੰ 166 ਸਟੋਰ ਕਰਨ ਦਿਓ, ਅਤੇ ਅਸੀਂ 165 ਭੇਜਾਂਗੇ।

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

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

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

ਚਲੋ ਲਾਂਚ ਕਰੀਏ।

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

ਅਤੇ ਅਸੀਂ ਵੇਖਾਂਗੇ ਕਿ ਟੈਸਟ ਇੱਕ ਗਲਤੀ ਨਾਲ ਚਲਾਇਆ ਗਿਆ ਹੈ।

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

ਇਸ ਪੜਾਅ 'ਤੇ lottery-test-suite.fif ਵਰਗਾ ਦਿਖਾਈ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ ਲਿੰਕ.

ਆਉ ਹੁਣ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਕਾਊਂਟਰ ਤਰਕ ਨੂੰ ਜੋੜੀਏ lottery-code.fc.

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

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

В slice in_msg ਸਾਡੇ ਦੁਆਰਾ ਭੇਜੇ ਗਏ ਸੰਦੇਸ਼ ਨੂੰ ਝੂਠ ਬੋਲਦਾ ਹੈ।

ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਅਸੀਂ ਇਹ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਕੀ ਸੁਨੇਹੇ ਵਿੱਚ ਡੇਟਾ ਹੈ, ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਅਸੀਂ ਬਸ ਬਾਹਰ ਆ ਜਾਂਦੇ ਹਾਂ।

ਅੱਗੇ ਅਸੀਂ ਸੰਦੇਸ਼ ਨੂੰ ਪਾਰਸ ਕਰਦੇ ਹਾਂ। in_msg~load_uint(32) ਨੰਬਰ 165, 32-ਬਿੱਟ ਲੋਡ ਕਰਦਾ ਹੈ unsigned int ਪ੍ਰਸਾਰਿਤ ਸੰਦੇਸ਼ ਤੋਂ.

ਅੱਗੇ ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਤੋਂ 32 ਬਿੱਟ ਲੋਡ ਕਰਦੇ ਹਾਂ। ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਲੋਡ ਕੀਤਾ ਨੰਬਰ ਪਾਸ ਕੀਤੇ ਨੰਬਰ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ; ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਅਸੀਂ ਇੱਕ ਅਪਵਾਦ ਦਿੰਦੇ ਹਾਂ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਕਿਉਂਕਿ ਅਸੀਂ ਇੱਕ ਗੈਰ-ਮੈਚ ਪਾਸ ਕਰ ਰਹੇ ਹਾਂ, ਇੱਕ ਅਪਵਾਦ ਦਿੱਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਹੁਣ ਕੰਪਾਇਲ ਕਰੀਏ।

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

ਨਤੀਜੇ ਕੋਡ ਨੂੰ ਕਾਪੀ ਕਰੋ lottery-test-suite.fif, ਆਖਰੀ ਲਾਈਨ ਨੂੰ ਬਦਲਣਾ ਨਾ ਭੁੱਲੋ।

ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਟੈਸਟ ਪਾਸ ਹੋਇਆ ਹੈ:

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

ਇਥੇ ਹੀ ਤੁਸੀਂ ਮੌਜੂਦਾ ਨਤੀਜਿਆਂ ਦੇ ਨਾਲ ਸੰਬੰਧਿਤ ਪ੍ਰਤੀਬੱਧਤਾ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹੋ।

ਨੋਟ ਕਰੋ ਕਿ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਕੰਪਾਇਲ ਕੀਤੇ ਕੋਡ ਨੂੰ ਟੈਸਟਾਂ ਵਾਲੀ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਲਗਾਤਾਰ ਕਾਪੀ ਕਰਨਾ ਅਸੁਵਿਧਾਜਨਕ ਹੈ, ਇਸ ਲਈ ਆਓ ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖੀਏ ਜੋ ਕੋਡ ਨੂੰ ਸਾਡੇ ਲਈ ਇੱਕ ਸਥਿਰ ਵਿੱਚ ਲਿਖ ਦੇਵੇਗੀ, ਅਤੇ ਅਸੀਂ ਕੰਪਾਇਲ ਕੀਤੇ ਕੋਡ ਨੂੰ ਸਾਡੇ ਟੈਸਟਾਂ ਨਾਲ ਜੋੜਾਂਗੇ "include".

ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ ਫਾਈਲ ਬਣਾਓ build.sh ਹੇਠ ਦਿੱਤੀ ਸਮੱਗਰੀ ਦੇ ਨਾਲ.

#!/bin/bash

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

ਚਲੋ ਇਸਨੂੰ ਚੱਲਣਯੋਗ ਬਣਾਈਏ।

chmod +x ./build.sh

ਹੁਣ, ਸਿਰਫ਼ ਇਕਰਾਰਨਾਮੇ ਨੂੰ ਕੰਪਾਇਲ ਕਰਨ ਲਈ ਸਾਡੀ ਸਕ੍ਰਿਪਟ ਚਲਾਓ। ਪਰ ਇਸਦੇ ਇਲਾਵਾ, ਸਾਨੂੰ ਇਸਨੂੰ ਇੱਕ ਸਥਿਰ ਵਿੱਚ ਲਿਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ code. ਇਸ ਲਈ ਅਸੀਂ ਇੱਕ ਨਵੀਂ ਫਾਈਲ ਬਣਾਵਾਂਗੇ lotter-compiled-for-test.fif, ਜਿਸ ਨੂੰ ਅਸੀਂ ਫਾਈਲ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਾਂਗੇ lottery-test-suite.fif.

ਚਲੋ ਸਕਰਿਪਟ ਕੋਡ ਨੂੰ sh ਵਿੱਚ ਜੋੜਦੇ ਹਾਂ, ਜੋ ਕਿ ਕੰਪਾਇਲ ਕੀਤੀ ਫਾਈਲ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਡੁਪਲੀਕੇਟ ਕਰੇਗਾ lotter-compiled-for-test.fif ਅਤੇ ਇਸ ਵਿੱਚ ਆਖਰੀ ਲਾਈਨ ਬਦਲੋ।

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

ਹੁਣ, ਜਾਂਚ ਕਰਨ ਲਈ, ਆਓ ਨਤੀਜੇ ਵਾਲੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇੱਕ ਫਾਈਲ ਤਿਆਰ ਕੀਤੀ ਜਾਵੇਗੀ lottery-compiled-for-test.fif, ਜਿਸ ਨੂੰ ਅਸੀਂ ਆਪਣੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਾਂਗੇ lottery-test-suite.fif

В lottery-test-suite.fif ਕੰਟਰੈਕਟ ਕੋਡ ਨੂੰ ਮਿਟਾਓ ਅਤੇ ਲਾਈਨ ਜੋੜੋ "lottery-compiled-for-test.fif" include.

ਅਸੀਂ ਇਹ ਜਾਂਚਣ ਲਈ ਟੈਸਟ ਚਲਾਉਂਦੇ ਹਾਂ ਕਿ ਉਹ ਪਾਸ ਹਨ ਜਾਂ ਨਹੀਂ।

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

ਬਹੁਤ ਵਧੀਆ, ਹੁਣ ਟੈਸਟਾਂ ਦੀ ਸ਼ੁਰੂਆਤ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰਨ ਲਈ, ਆਓ ਇੱਕ ਫਾਈਲ ਬਣਾਈਏ test.sh, ਜੋ ਪਹਿਲਾਂ ਚਲਾਇਆ ਜਾਵੇਗਾ build.sh, ਅਤੇ ਫਿਰ ਟੈਸਟ ਚਲਾਓ।

touch test.sh
chmod +x test.sh

ਅਸੀਂ ਅੰਦਰ ਲਿਖਦੇ ਹਾਂ

./build.sh 

echo "nCompilation completedn"

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

ਚਲੋ ਕਰੀਏ test.sh ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸਨੂੰ ਚਲਾਓ ਕਿ ਟੈਸਟ ਕੰਮ ਕਰਦੇ ਹਨ।

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

ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ ਕਿ ਇਕਰਾਰਨਾਮੇ ਨੂੰ ਕੰਪਾਇਲ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਟੈਸਟ ਕੀਤੇ ਗਏ ਹਨ।

ਵਧੀਆ, ਹੁਣ ਸ਼ੁਰੂਆਤ 'ਤੇ test.sh ਟੈਸਟ ਕੰਪਾਇਲ ਕੀਤੇ ਜਾਣਗੇ ਅਤੇ ਤੁਰੰਤ ਚਲਾਏ ਜਾਣਗੇ। ਇੱਥੇ ਲਈ ਲਿੰਕ ਹੈ ਵਚਨਬੱਧ.

ਠੀਕ ਹੈ, ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਜਾਰੀ ਰੱਖੀਏ, ਆਓ ਸਹੂਲਤ ਲਈ ਇੱਕ ਹੋਰ ਗੱਲ ਕਰੀਏ।

ਚਲੋ ਇੱਕ ਫੋਲਡਰ ਬਣਾਉਂਦੇ ਹਾਂ build ਜਿੱਥੇ ਅਸੀਂ ਕਾਪੀ ਕੀਤੇ ਇਕਰਾਰਨਾਮੇ ਅਤੇ ਇਸਦੇ ਕਲੋਨ ਨੂੰ ਇੱਕ ਸਥਿਰ ਵਿੱਚ ਲਿਖਿਆ ਹੋਇਆ ਸਟੋਰ ਕਰਾਂਗੇ lottery-compiled.fif, lottery-compiled-for-test.fif. ਚਲੋ ਇੱਕ ਫੋਲਡਰ ਵੀ ਬਣਾਈਏ test ਟੈਸਟ ਫਾਈਲ ਕਿੱਥੇ ਸਟੋਰ ਕੀਤੀ ਜਾਵੇਗੀ? lottery-test-suite.fif ਅਤੇ ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਹੋਰ ਸਹਾਇਕ ਫਾਈਲਾਂ। ਸੰਬੰਧਿਤ ਤਬਦੀਲੀਆਂ ਲਈ ਲਿੰਕ.

ਆਓ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਨਾ ਜਾਰੀ ਰੱਖੀਏ।

ਅੱਗੇ ਇੱਕ ਟੈਸਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਇਹ ਜਾਂਚਦਾ ਹੈ ਕਿ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਹੋਇਆ ਹੈ ਅਤੇ ਜਦੋਂ ਅਸੀਂ ਸਹੀ ਨੰਬਰ ਭੇਜਦੇ ਹਾਂ ਤਾਂ ਸਟੋਰ ਵਿੱਚ ਕਾਊਂਟਰ ਅੱਪਡੇਟ ਹੁੰਦਾ ਹੈ। ਪਰ ਅਸੀਂ ਇਹ ਬਾਅਦ ਵਿੱਚ ਕਰਾਂਗੇ।

ਹੁਣ ਆਓ ਇਸ ਬਾਰੇ ਸੋਚੀਏ ਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਕਿਹੜਾ ਡੇਟਾ ਬਣਤਰ ਅਤੇ ਕਿਹੜੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਮੈਂ ਹਰ ਚੀਜ਼ ਦਾ ਵਰਣਨ ਕਰਾਂਗਾ ਜੋ ਅਸੀਂ ਸਟੋਰ ਕਰਦੇ ਹਾਂ।

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

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

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

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

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

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

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

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

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

ਅੱਗੇ ਤੁਹਾਨੂੰ ਦੋ ਫੰਕਸ਼ਨ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ. ਆਓ ਪਹਿਲੇ ਨੂੰ ਕਾਲ ਕਰੀਏ pack_state(), ਜੋ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਵਿੱਚ ਬਾਅਦ ਵਿੱਚ ਬੱਚਤ ਕਰਨ ਲਈ ਡੇਟਾ ਨੂੰ ਪੈਕ ਕਰੇਗਾ। ਚਲੋ ਦੂਜੇ ਨੂੰ ਕਾਲ ਕਰੀਏ unpack_state() ਸਟੋਰੇਜ ਤੋਂ ਡਾਟਾ ਪੜ੍ਹੇਗਾ ਅਤੇ ਵਾਪਸ ਕਰੇਗਾ।

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

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

ਅਸੀਂ ਇਹਨਾਂ ਦੋ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਜੋੜਦੇ ਹਾਂ। ਇਹ ਕੰਮ ਕਰੇਗਾ ਇਸ ਤਰ੍ਹਾਂ ਵਿਚਕਾਰਲਾ ਨਤੀਜਾ.

ਡਾਟਾ ਬਚਾਉਣ ਲਈ ਤੁਹਾਨੂੰ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ set_data() ਅਤੇ ਇਸ ਤੋਂ ਡਾਟਾ ਲਿਖਿਆ ਜਾਵੇਗਾ pack_state() ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਵਿੱਚ.

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

ਹੁਣ ਜਦੋਂ ਸਾਡੇ ਕੋਲ ਡਾਟਾ ਲਿਖਣ ਅਤੇ ਪੜ੍ਹਨ ਲਈ ਸੁਵਿਧਾਜਨਕ ਫੰਕਸ਼ਨ ਹਨ, ਅਸੀਂ ਅੱਗੇ ਵਧ ਸਕਦੇ ਹਾਂ।

ਸਾਨੂੰ ਇਹ ਜਾਂਚ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਕਿ ਬਾਹਰੋਂ ਆਉਣ ਵਾਲੇ ਸੰਦੇਸ਼ 'ਤੇ ਇਕਰਾਰਨਾਮੇ ਦੇ ਮਾਲਕ (ਜਾਂ ਕਿਸੇ ਹੋਰ ਉਪਭੋਗਤਾ ਜਿਸ ਕੋਲ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਤੱਕ ਪਹੁੰਚ ਹੈ) ਦੁਆਰਾ ਹਸਤਾਖਰ ਕੀਤੇ ਗਏ ਹਨ।

ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਇਸਨੂੰ ਸਟੋਰੇਜ ਵਿੱਚ ਲੋੜੀਂਦੇ ਡੇਟਾ ਨਾਲ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ, ਜੋ ਭਵਿੱਖ ਵਿੱਚ ਵਰਤੋਂ ਲਈ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਵੇਗਾ। ਅਸੀਂ ਉੱਥੇ ਜਨਤਕ ਕੁੰਜੀ ਨੂੰ ਰਿਕਾਰਡ ਕਰਾਂਗੇ ਤਾਂ ਜੋ ਅਸੀਂ ਪੁਸ਼ਟੀ ਕਰ ਸਕੀਏ ਕਿ ਆਉਣ ਵਾਲੇ ਸੁਨੇਹੇ ਨੂੰ ਸੰਬੰਧਿਤ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਨਾਲ ਸਾਈਨ ਕੀਤਾ ਗਿਆ ਸੀ।

ਜਾਰੀ ਰੱਖਣ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਇੱਕ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਬਣਾਈਏ ਅਤੇ ਇਸਨੂੰ ਲਿਖੀਏ test/keys/owner.pk. ਅਜਿਹਾ ਕਰਨ ਲਈ, ਆਓ ਇੰਟਰਐਕਟਿਵ ਮੋਡ ਵਿੱਚ ਫਿਫਟ ਨੂੰ ਲਾਂਚ ਕਰੀਏ ਅਤੇ ਚਾਰ ਕਮਾਂਡਾਂ ਨੂੰ ਲਾਗੂ ਕਰੀਏ।

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

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

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

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

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

ਚਲੋ ਇੱਕ ਫੋਲਡਰ ਬਣਾਉਂਦੇ ਹਾਂ keys ਫੋਲਡਰ ਦੇ ਅੰਦਰ test ਅਤੇ ਉੱਥੇ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਲਿਖੋ।

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

ਅਸੀਂ ਮੌਜੂਦਾ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ ਫਾਈਲ ਵੇਖਦੇ ਹਾਂ owner.pk.

ਅਸੀਂ ਸਟੈਕ ਤੋਂ ਜਨਤਕ ਕੁੰਜੀ ਨੂੰ ਹਟਾਉਂਦੇ ਹਾਂ ਅਤੇ ਲੋੜ ਪੈਣ 'ਤੇ ਅਸੀਂ ਇਸਨੂੰ ਪ੍ਰਾਈਵੇਟ ਤੋਂ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ।

ਹੁਣ ਸਾਨੂੰ ਦਸਤਖਤ ਤਸਦੀਕ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ। ਆਉ ਟੈਸਟ ਦੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ. ਪਹਿਲਾਂ ਅਸੀਂ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਾਈਲ ਤੋਂ ਪ੍ਰਾਈਵੇਟ ਕੀ ਪੜ੍ਹਦੇ ਹਾਂ file>B ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਲਿਖੋ owner_private_key, ਫਿਰ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ priv>pub ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਨੂੰ ਜਨਤਕ ਕੁੰਜੀ ਵਿੱਚ ਬਦਲੋ ਅਤੇ ਨਤੀਜਾ ਲਿਖੋ owner_public_key.

variable owner_private_key
variable owner_public_key 

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

ਸਾਨੂੰ ਦੋਨਾਂ ਕੁੰਜੀਆਂ ਦੀ ਲੋੜ ਪਵੇਗੀ।

ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਨੂੰ ਆਰਬਿਟਰਰੀ ਡੇਟਾ ਦੇ ਨਾਲ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨ ਵਿੱਚ ਹੈ pack_state()ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਲਿਖੋ storage.

variable owner_private_key
variable owner_public_key 
variable orders
variable owner_wc
variable owner_account_id

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

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

ਅੱਗੇ, ਅਸੀਂ ਇੱਕ ਦਸਤਖਤ ਕੀਤੇ ਸੰਦੇਸ਼ ਨੂੰ ਲਿਖਾਂਗੇ, ਇਸ ਵਿੱਚ ਸਿਰਫ਼ ਦਸਤਖਤ ਅਤੇ ਕਾਊਂਟਰ ਮੁੱਲ ਸ਼ਾਮਲ ਹੋਵੇਗਾ।

ਪਹਿਲਾਂ, ਅਸੀਂ ਉਹ ਡੇਟਾ ਬਣਾਉਂਦੇ ਹਾਂ ਜੋ ਅਸੀਂ ਪ੍ਰਸਾਰਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ, ਫਿਰ ਅਸੀਂ ਇਸਨੂੰ ਇੱਕ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਨਾਲ ਦਸਤਖਤ ਕਰਦੇ ਹਾਂ ਅਤੇ ਅੰਤ ਵਿੱਚ ਅਸੀਂ ਇੱਕ ਦਸਤਖਤ ਸੁਨੇਹਾ ਤਿਆਰ ਕਰਦੇ ਹਾਂ।

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

ਨਤੀਜੇ ਵਜੋਂ, ਸੁਨੇਹਾ ਜੋ ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਭੇਜਾਂਗੇ, ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਰਿਕਾਰਡ ਕੀਤਾ ਗਿਆ ਹੈ message_to_send, ਫੰਕਸ਼ਨਾਂ ਬਾਰੇ hashu, ed25519_sign_uint ਤੁਸੀਂ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਫਿਫਟ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ.

ਅਤੇ ਟੈਸਟ ਨੂੰ ਚਲਾਉਣ ਲਈ ਅਸੀਂ ਦੁਬਾਰਾ ਕਾਲ ਕਰਦੇ ਹਾਂ.

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

ਇੱਥੇ ਏ ਟੈਸਟਾਂ ਵਾਲੀ ਫਾਈਲ ਇਸ ਪੜਾਅ 'ਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ।

ਚਲੋ ਟੈਸਟ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਹ ਅਸਫਲ ਹੋ ਜਾਵੇਗਾ, ਇਸਲਈ ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਬਦਲਾਂਗੇ ਤਾਂ ਜੋ ਇਹ ਇਸ ਫਾਰਮੈਟ ਦੇ ਸੁਨੇਹੇ ਪ੍ਰਾਪਤ ਕਰ ਸਕੇ ਅਤੇ ਦਸਤਖਤ ਦੀ ਪੁਸ਼ਟੀ ਕਰ ਸਕੇ।

ਪਹਿਲਾਂ, ਅਸੀਂ ਮੈਸੇਜ ਤੋਂ ਹਸਤਾਖਰ ਦੇ 512 ਬਿੱਟ ਗਿਣਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਲਿਖਦੇ ਹਾਂ, ਫਿਰ ਅਸੀਂ ਕਾਊਂਟਰ ਵੇਰੀਏਬਲ ਦੇ 32 ਬਿੱਟ ਗਿਣਦੇ ਹਾਂ।

ਕਿਉਂਕਿ ਸਾਡੇ ਕੋਲ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਤੋਂ ਡਾਟਾ ਪੜ੍ਹਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ, ਅਸੀਂ ਇਸਨੂੰ ਵਰਤਾਂਗੇ।

ਅੱਗੇ ਸਟੋਰੇਜ ਦੇ ਨਾਲ ਟ੍ਰਾਂਸਫਰ ਕੀਤੇ ਕਾਊਂਟਰ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ ਅਤੇ ਦਸਤਖਤ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ। ਜੇਕਰ ਕੁਝ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਤਾਂ ਅਸੀਂ ਉਚਿਤ ਕੋਡ ਨਾਲ ਇੱਕ ਅਪਵਾਦ ਸੁੱਟ ਦਿੰਦੇ ਹਾਂ।

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

ਸੰਬੰਧਿਤ ਵਚਨਬੱਧਤਾ ਇੱਥੇ ਹੀ.

ਆਉ ਟੈਸਟਾਂ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਦੂਜਾ ਟੈਸਟ ਫੇਲ ਹੁੰਦਾ ਹੈ। ਦੋ ਕਾਰਨਾਂ ਕਰਕੇ, ਸੁਨੇਹੇ ਵਿੱਚ ਲੋੜੀਂਦੇ ਬਿੱਟ ਨਹੀਂ ਹਨ ਅਤੇ ਸਟੋਰੇਜ ਵਿੱਚ ਲੋੜੀਂਦੇ ਬਿੱਟ ਨਹੀਂ ਹਨ, ਇਸਲਈ ਕੋਡ ਪਾਰਸ ਕਰਨ ਵੇਲੇ ਕ੍ਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ। ਸਾਨੂੰ ਉਸ ਸੁਨੇਹੇ ਵਿੱਚ ਇੱਕ ਦਸਤਖਤ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ ਜੋ ਅਸੀਂ ਭੇਜ ਰਹੇ ਹਾਂ ਅਤੇ ਆਖਰੀ ਟੈਸਟ ਤੋਂ ਸਟੋਰੇਜ ਨੂੰ ਕਾਪੀ ਕਰਨਾ ਹੈ।

ਦੂਜੇ ਟੈਸਟ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸੁਨੇਹਾ ਦਸਤਖਤ ਜੋੜਾਂਗੇ ਅਤੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਨੂੰ ਬਦਲਾਂਗੇ। ਇੱਥੇ ਏ ਟੈਸਟਾਂ ਵਾਲੀ ਫਾਈਲ ਇਸ ਸਮੇਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ।

ਆਉ ਇੱਕ ਚੌਥਾ ਟੈਸਟ ਲਿਖਦੇ ਹਾਂ, ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਕਿਸੇ ਹੋਰ ਦੀ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਨਾਲ ਦਸਤਖਤ ਕੀਤੇ ਇੱਕ ਸੰਦੇਸ਼ ਭੇਜਾਂਗੇ। ਚਲੋ ਇੱਕ ਹੋਰ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਬਣਾਉ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਸੇਵ ਕਰੀਏ not-owner.pk. ਅਸੀਂ ਇਸ ਨਿੱਜੀ ਕੁੰਜੀ ਨਾਲ ਸੰਦੇਸ਼ 'ਤੇ ਦਸਤਖਤ ਕਰਾਂਗੇ। ਆਉ ਟੈਸਟਾਂ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਾਂ ਕਿ ਸਾਰੇ ਟੈਸਟ ਪਾਸ ਹੁੰਦੇ ਹਨ। ਵਚਨਬੱਧਤਾ ਇਸ ਮੌਕੇ ਤੇ.

ਹੁਣ ਅਸੀਂ ਅੰਤ ਵਿੱਚ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਅੱਗੇ ਵਧ ਸਕਦੇ ਹਾਂ।
В recv_external() ਅਸੀਂ ਦੋ ਤਰ੍ਹਾਂ ਦੇ ਸੁਨੇਹੇ ਸਵੀਕਾਰ ਕਰਾਂਗੇ।

ਕਿਉਂਕਿ ਸਾਡਾ ਇਕਰਾਰਨਾਮਾ ਖਿਡਾਰੀਆਂ ਦੇ ਨੁਕਸਾਨ ਨੂੰ ਇਕੱਠਾ ਕਰੇਗਾ, ਇਸ ਲਈ ਇਹ ਪੈਸਾ ਲਾਟਰੀ ਦੇ ਨਿਰਮਾਤਾ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜਦੋਂ ਇਕਰਾਰਨਾਮਾ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਲਾਟਰੀ ਬਣਾਉਣ ਵਾਲੇ ਦਾ ਵਾਲਿਟ ਪਤਾ ਸਟੋਰੇਜ ਵਿੱਚ ਦਰਜ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਬੱਸ, ਸਾਨੂੰ ਉਸ ਪਤੇ ਨੂੰ ਬਦਲਣ ਦੀ ਯੋਗਤਾ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਿਸ 'ਤੇ ਅਸੀਂ ਹਾਰਨ ਵਾਲਿਆਂ ਦੇ ਗ੍ਰਾਮ ਭੇਜਦੇ ਹਾਂ। ਸਾਨੂੰ ਲਾਟਰੀ ਤੋਂ ਮਾਲਕ ਦੇ ਪਤੇ 'ਤੇ ਗ੍ਰਾਮ ਭੇਜਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਆਉ ਪਹਿਲੇ ਇੱਕ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ. ਆਓ ਪਹਿਲਾਂ ਇੱਕ ਟੈਸਟ ਲਿਖਦੇ ਹਾਂ ਜੋ ਇਹ ਜਾਂਚ ਕਰੇਗਾ ਕਿ ਸੁਨੇਹਾ ਭੇਜਣ ਤੋਂ ਬਾਅਦ, ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੇ ਸਟੋਰੇਜ ਵਿੱਚ ਨਵਾਂ ਪਤਾ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਹੈ. ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਸੰਦੇਸ਼ ਵਿੱਚ, ਕਾਊਂਟਰ ਅਤੇ ਨਵੇਂ ਪਤੇ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਪ੍ਰਸਾਰਿਤ ਵੀ ਕਰਦੇ ਹਾਂ action ਇੱਕ 7-ਬਿੱਟ ਪੂਰਨ ਅੰਕ ਗੈਰ-ਨੈਗੇਟਿਵ ਨੰਬਰ, ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਚੁਣਾਂਗੇ ਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਸੰਦੇਸ਼ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਹੈ।

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

ਟੈਸਟ ਵਿੱਚ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਨੂੰ ਕਿਵੇਂ ਡੀਸੀਰੀਅਲਾਈਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ storage ਪੰਜ ਵਿੱਚ. ਵੇਰੀਏਬਲਾਂ ਦੇ ਡੀਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਦਾ ਵਰਣਨ ਫਿਫਟ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਹੈ।

ਕਮਿਟ ਲਿੰਕ ਸ਼ਾਮਿਲ ਆਟੇ ਦੇ ਨਾਲ.

ਚਲੋ ਟੈਸਟ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਾਂ ਕਿ ਇਹ ਅਸਫਲ ਰਿਹਾ ਹੈ। ਹੁਣ ਲਾਟਰੀ ਮਾਲਕ ਦਾ ਪਤਾ ਬਦਲਣ ਲਈ ਤਰਕ ਜੋੜਦੇ ਹਾਂ।

ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਅਸੀਂ ਪਾਰਸ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦੇ ਹਾਂ message, ਵਿੱਚ ਪੜ੍ਹੋ action. ਆਓ ਤੁਹਾਨੂੰ ਯਾਦ ਦਿਵਾ ਦੇਈਏ ਕਿ ਸਾਡੇ ਕੋਲ ਦੋ ਹੋਣਗੇ action: ਪਤਾ ਬਦਲੋ ਅਤੇ ਗ੍ਰਾਮ ਭੇਜੋ।

ਫਿਰ ਅਸੀਂ ਇਕਰਾਰਨਾਮੇ ਦੇ ਮਾਲਕ ਦਾ ਨਵਾਂ ਪਤਾ ਪੜ੍ਹਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਸਟੋਰੇਜ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਦੇ ਹਾਂ।
ਅਸੀਂ ਟੈਸਟ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਤੀਜਾ ਟੈਸਟ ਫੇਲ ਹੁੰਦਾ ਹੈ। ਇਹ ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਕਰੈਸ਼ ਹੋ ਗਿਆ ਹੈ ਕਿ ਇਕਰਾਰਨਾਮਾ ਹੁਣ ਸੁਨੇਹੇ ਤੋਂ 7 ਬਿੱਟਾਂ ਨੂੰ ਪਾਰਸ ਕਰਦਾ ਹੈ, ਜੋ ਟੈਸਟ ਵਿੱਚ ਗਾਇਬ ਹਨ। ਸੁਨੇਹੇ ਵਿੱਚ ਇੱਕ ਗੈਰ-ਮੌਜੂਦ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ action. ਆਉ ਟੈਸਟ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਸਭ ਕੁਝ ਪਾਸ ਹੁੰਦਾ ਹੈ. ਇੱਥੇ ਤਬਦੀਲੀਆਂ ਲਈ ਵਚਨਬੱਧ. ਮਹਾਨ।

ਹੁਣ ਪਹਿਲਾਂ ਸੇਵ ਕੀਤੇ ਪਤੇ 'ਤੇ ਗ੍ਰਾਮ ਦੀ ਨਿਰਧਾਰਤ ਸੰਖਿਆ ਭੇਜਣ ਲਈ ਤਰਕ ਲਿਖਦੇ ਹਾਂ।

ਪਹਿਲਾਂ, ਆਓ ਇੱਕ ਟੈਸਟ ਲਿਖੀਏ। ਅਸੀਂ ਦੋ ਟੈਸਟ ਲਿਖਾਂਗੇ, ਇੱਕ ਜਦੋਂ ਕਾਫ਼ੀ ਸੰਤੁਲਨ ਨਾ ਹੋਵੇ, ਦੂਜਾ ਜਦੋਂ ਸਭ ਕੁਝ ਸਫਲਤਾਪੂਰਵਕ ਪਾਸ ਹੋ ਜਾਵੇ। ਟੈਸਟ ਦੇਖੇ ਜਾ ਸਕਦੇ ਹਨ ਇਸ ਵਚਨਬੱਧਤਾ ਵਿੱਚ.

ਹੁਣ ਕੋਡ ਜੋੜਦੇ ਹਾਂ। ਪਹਿਲਾਂ, ਆਓ ਦੋ ਸਹਾਇਕ ਢੰਗਾਂ ਨੂੰ ਲਿਖੀਏ। ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਮੌਜੂਦਾ ਬਕਾਏ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਪਹਿਲਾ ਪ੍ਰਾਪਤ ਤਰੀਕਾ ਹੈ।

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

ਅਤੇ ਦੂਜਾ ਇੱਕ ਹੋਰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਗ੍ਰਾਮ ਭੇਜਣ ਲਈ ਹੈ। ਮੈਂ ਇੱਕ ਹੋਰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਤੋਂ ਇਸ ਵਿਧੀ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਾਪੀ ਕੀਤਾ.

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

ਆਉ ਇਹਨਾਂ ਦੋ ਤਰੀਕਿਆਂ ਨੂੰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਜੋੜੀਏ ਅਤੇ ਤਰਕ ਲਿਖੀਏ। ਪਹਿਲਾਂ, ਅਸੀਂ ਸੰਦੇਸ਼ ਤੋਂ ਗ੍ਰਾਮ ਦੀ ਸੰਖਿਆ ਨੂੰ ਪਾਰਸ ਕਰਦੇ ਹਾਂ। ਅੱਗੇ ਅਸੀਂ ਸੰਤੁਲਨ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ, ਜੇ ਇਹ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ ਤਾਂ ਅਸੀਂ ਇੱਕ ਅਪਵਾਦ ਸੁੱਟਦੇ ਹਾਂ. ਜੇ ਸਭ ਕੁਝ ਠੀਕ ਹੈ, ਤਾਂ ਅਸੀਂ ਗ੍ਰਾਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਪਤੇ 'ਤੇ ਭੇਜਦੇ ਹਾਂ ਅਤੇ ਕਾਊਂਟਰ ਨੂੰ ਅਪਡੇਟ ਕਰਦੇ ਹਾਂ.

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

ਇੱਥੇ ਏ ਇਸ ਸਮੇਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੀ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਆਉ ਟੈਸਟਾਂ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਾਂ ਕਿ ਉਹ ਪਾਸ ਹੋਏ ਹਨ।

ਤਰੀਕੇ ਨਾਲ, ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਕੀਤੇ ਸੰਦੇਸ਼ ਲਈ ਹਰ ਵਾਰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਤੋਂ ਇੱਕ ਕਮਿਸ਼ਨ ਕੱਟਿਆ ਜਾਂਦਾ ਹੈ. ਬੇਨਤੀ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸੁਨੇਹਿਆਂ ਲਈ, ਬੁਨਿਆਦੀ ਜਾਂਚਾਂ ਤੋਂ ਬਾਅਦ ਤੁਹਾਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ accept_message().

ਆਓ ਹੁਣ ਅੰਦਰੂਨੀ ਸੰਦੇਸ਼ਾਂ ਵੱਲ ਵਧੀਏ। ਅਸਲ ਵਿੱਚ, ਅਸੀਂ ਸਿਰਫ਼ ਗ੍ਰਾਮ ਹੀ ਸਵੀਕਾਰ ਕਰਾਂਗੇ ਅਤੇ ਖਿਡਾਰੀ ਨੂੰ ਦੁੱਗਣੀ ਰਕਮ ਵਾਪਸ ਭੇਜਾਂਗੇ ਜੇਕਰ ਉਹ ਜਿੱਤਦਾ ਹੈ ਅਤੇ ਇੱਕ ਤਿਹਾਈ ਮਾਲਕ ਨੂੰ ਜੇਕਰ ਉਹ ਹਾਰਦਾ ਹੈ।

ਪਹਿਲਾਂ, ਆਓ ਇੱਕ ਸਧਾਰਨ ਟੈਸਟ ਲਿਖੀਏ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਇੱਕ ਟੈਸਟ ਪਤੇ ਦੀ ਲੋੜ ਹੈ ਜਿਸ ਤੋਂ ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਗ੍ਰਾਮ ਭੇਜਦੇ ਹਾਂ।

ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਐਡਰੈੱਸ ਵਿੱਚ ਦੋ ਨੰਬਰ ਹੁੰਦੇ ਹਨ, ਇੱਕ 32-ਬਿੱਟ ਪੂਰਨ ਅੰਕ ਜੋ ਵਰਕਚੇਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸ ਵਰਕਚੇਨ ਵਿੱਚ ਇੱਕ 256-ਬਿੱਟ ਗੈਰ-ਨੈਗੇਟਿਵ ਪੂਰਨ ਅੰਕ ਵਿਲੱਖਣ ਖਾਤਾ ਨੰਬਰ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, -1 ਅਤੇ 12345, ਇਹ ਉਹ ਪਤਾ ਹੈ ਜੋ ਅਸੀਂ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਸੇਵ ਕਰਾਂਗੇ।

ਮੈਂ ਐਡਰੈੱਸ ਨੂੰ ਸੇਵ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਪੀ ਕੀਤਾ ਹੈ TonUtil.fif.

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

ਆਓ ਦੇਖੀਏ ਕਿ ਫੰਕਸ਼ਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਹ ਸਮਝ ਦੇਵੇਗਾ ਕਿ ਫਿਫਟ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਇੰਟਰਐਕਟਿਵ ਮੋਡ ਵਿੱਚ ਫਿਫਟ ਲਾਂਚ ਕਰੋ।

~/TON/build/crypto/fift -i 

ਪਹਿਲਾਂ ਅਸੀਂ ਸਟੈਕ ਉੱਤੇ -1, 12345 ਅਤੇ ਭਵਿੱਖੀ ਫਾਈਲ "sender.addr" ਦਾ ਨਾਮ ਦਬਾਉਂਦੇ ਹਾਂ:

-1 12345 "sender.addr" 

ਅਗਲਾ ਕਦਮ ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਣਾ ਹੈ -rot, ਜੋ ਸਟੈਕ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਬਦਲਦਾ ਹੈ ਕਿ ਸਟੈਕ ਦੇ ਸਿਖਰ 'ਤੇ ਇੱਕ ਵਿਲੱਖਣ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੰਬਰ ਹੁੰਦਾ ਹੈ:

"sender.addr" -1 12345

256 u>B ਇੱਕ 256-ਬਿੱਟ ਗੈਰ-ਨੈਗੇਟਿਵ ਪੂਰਨ ਅੰਕ ਨੂੰ ਬਾਈਟਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap ਸਟੈਕ ਦੇ ਸਿਖਰਲੇ ਦੋ ਤੱਤਾਂ ਨੂੰ ਸਵੈਪ ਕਰਦਾ ਹੈ।

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B ਇੱਕ 32-ਬਿੱਟ ਪੂਰਨ ਅੰਕ ਨੂੰ ਬਾਈਟਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ ਬਾਈਟਸ ਦੇ ਦੋ ਕ੍ਰਮ ਜੋੜਦਾ ਹੈ।

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

ਦੁਬਾਰਾ swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

ਅਤੇ ਅੰਤ ਵਿੱਚ ਬਾਈਟ ਫਾਈਲ ਵਿੱਚ ਲਿਖੇ ਜਾਂਦੇ ਹਨ B>file. ਇਸ ਤੋਂ ਬਾਅਦ ਸਾਡਾ ਸਟੈਕ ਖਾਲੀ ਹੈ। ਅਸੀਂ ਰੋਕਦੇ ਹਾਂ Fift. ਮੌਜੂਦਾ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ ਫਾਈਲ ਬਣਾਈ ਗਈ ਹੈ sender.addr. ਚਲੋ ਫਾਈਲ ਨੂੰ ਬਣਾਏ ਗਏ ਫੋਲਡਰ ਵਿੱਚ ਮੂਵ ਕਰੀਏ test/addresses/.

ਆਓ ਇੱਕ ਸਧਾਰਨ ਟੈਸਟ ਲਿਖੀਏ ਜੋ ਗ੍ਰਾਮ ਨੂੰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਭੇਜੇਗਾ। ਇੱਥੇ ਵਚਨਬੱਧਤਾ ਹੈ.

ਆਓ ਹੁਣ ਲਾਟਰੀ ਦੇ ਤਰਕ ਨੂੰ ਵੇਖੀਏ.

ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਅਸੀਂ ਸੰਦੇਸ਼ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ bounced ਜਾਂ ਨਹੀਂ ਜੇ bounced, ਫਿਰ ਅਸੀਂ ਇਸਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਦੇ ਹਾਂ। bounced ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਜੇ ਕੋਈ ਗਲਤੀ ਹੁੰਦੀ ਹੈ ਤਾਂ ਇਕਰਾਰਨਾਮਾ ਗ੍ਰਾਮ ਵਾਪਸ ਕਰੇਗਾ। ਜੇਕਰ ਅਚਾਨਕ ਕੋਈ ਗਲਤੀ ਹੋ ਜਾਂਦੀ ਹੈ ਤਾਂ ਅਸੀਂ ਗ੍ਰਾਮ ਵਾਪਸ ਨਹੀਂ ਕਰਾਂਗੇ।

ਅਸੀਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ, ਜੇਕਰ ਬਕਾਇਆ ਅੱਧੇ ਗ੍ਰਾਮ ਤੋਂ ਘੱਟ ਹੈ, ਤਾਂ ਅਸੀਂ ਸਿਰਫ਼ ਸੰਦੇਸ਼ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਅਣਡਿੱਠ ਕਰਦੇ ਹਾਂ।

ਅੱਗੇ, ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਪਤੇ ਨੂੰ ਪਾਰਸ ਕਰਦੇ ਹਾਂ ਜਿਸ ਤੋਂ ਸੁਨੇਹਾ ਆਇਆ ਸੀ।

ਅਸੀਂ ਸਟੋਰੇਜ ਤੋਂ ਡੇਟਾ ਪੜ੍ਹਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਇਤਿਹਾਸ ਤੋਂ ਪੁਰਾਣੇ ਸੱਟੇ ਨੂੰ ਮਿਟਾ ਦਿੰਦੇ ਹਾਂ ਜੇਕਰ ਉਹਨਾਂ ਵਿੱਚੋਂ ਵੀਹ ਤੋਂ ਵੱਧ ਹਨ। ਸਹੂਲਤ ਲਈ, ਮੈਂ ਤਿੰਨ ਵਾਧੂ ਫੰਕਸ਼ਨ ਲਿਖੇ ਹਨ pack_order(), unpack_order(), remove_old_orders().

ਅੱਗੇ, ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਜੇਕਰ ਬਕਾਇਆ ਭੁਗਤਾਨ ਲਈ ਕਾਫ਼ੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਅਸੀਂ ਸਮਝਦੇ ਹਾਂ ਕਿ ਇਹ ਇੱਕ ਬਾਜ਼ੀ ਨਹੀਂ ਹੈ, ਪਰ ਇੱਕ ਪੂਰਤੀ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਮੁੜ ਭਰਨ ਨੂੰ ਬਚਾਓ. orders.

ਫਿਰ ਅੰਤ ਵਿੱਚ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦਾ ਸਾਰ.

ਪਹਿਲਾਂ, ਜੇਕਰ ਖਿਡਾਰੀ ਹਾਰਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸਨੂੰ ਸੱਟੇਬਾਜ਼ੀ ਦੇ ਇਤਿਹਾਸ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਦੇ ਹਾਂ ਅਤੇ ਜੇਕਰ ਰਕਮ 3 ਗ੍ਰਾਮ ਤੋਂ ਵੱਧ ਹੈ, ਤਾਂ ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਮਾਲਕ ਨੂੰ 1/3 ਭੇਜਦੇ ਹਾਂ।

ਜੇਕਰ ਖਿਡਾਰੀ ਜਿੱਤਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਖਿਡਾਰੀ ਦੇ ਪਤੇ 'ਤੇ ਦੁੱਗਣੀ ਰਕਮ ਭੇਜਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਸੱਟੇਬਾਜ਼ੀ ਬਾਰੇ ਜਾਣਕਾਰੀ ਨੂੰ ਇਤਿਹਾਸ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਦੇ ਹਾਂ।

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

ਇਹ ਸਭ ਕੁਝ ਹੈ ਅਨੁਸਾਰੀ ਵਚਨਬੱਧਤਾ.

ਹੁਣ ਜੋ ਬਾਕੀ ਬਚਿਆ ਹੈ ਉਹ ਸਧਾਰਨ ਹੈ, ਆਓ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਤਰੀਕੇ ਬਣਾਈਏ ਤਾਂ ਜੋ ਅਸੀਂ ਬਾਹਰੀ ਦੁਨੀਆ ਤੋਂ ਇਕਰਾਰਨਾਮੇ ਦੀ ਸਥਿਤੀ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕੀਏ (ਅਸਲ ਵਿੱਚ, ਉਹਨਾਂ ਦੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਤੋਂ ਡੇਟਾ ਪੜ੍ਹੋ)।

ਆਉ get methods ਸ਼ਾਮਲ ਕਰੀਏ. ਅਸੀਂ ਹੇਠਾਂ ਲਿਖਾਂਗੇ ਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਬਾਰੇ ਜਾਣਕਾਰੀ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨੀ ਹੈ।

ਮੈਂ ਉਹ ਕੋਡ ਜੋੜਨਾ ਵੀ ਭੁੱਲ ਗਿਆ ਜੋ ਸਮਾਰਟ ਇਕਰਾਰਨਾਮੇ ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਵੇਲੇ ਸਭ ਤੋਂ ਪਹਿਲੀ ਬੇਨਤੀ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰੇਗਾ। ਅਨੁਸਾਰੀ ਵਚਨਬੱਧਤਾ. ਅਤੇ ਅੱਗੇ ਠੀਕ ਕੀਤਾ ਮਾਲਕ ਦੇ ਖਾਤੇ ਵਿੱਚ ਰਕਮ ਦਾ 1/3 ਭੇਜਣ ਨਾਲ ਬੱਗ।

ਅਗਲਾ ਕਦਮ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨਾ ਹੈ। ਚਲੋ ਇੱਕ ਫੋਲਡਰ ਬਣਾਉਂਦੇ ਹਾਂ requests.

ਮੈਂ ਪ੍ਰਕਾਸ਼ਨ ਕੋਡ ਨੂੰ ਆਧਾਰ ਵਜੋਂ ਲਿਆ simple-wallet-code.fc ਜੋ ਕਿ ਲੱਭ ਸਕਦੇ ਹੋ ਅਧਿਕਾਰਤ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ.

ਧਿਆਨ ਦੇਣ ਯੋਗ ਚੀਜ਼. ਅਸੀਂ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਟੋਰੇਜ ਅਤੇ ਇੱਕ ਇਨਪੁਟ ਸੁਨੇਹਾ ਤਿਆਰ ਕਰਦੇ ਹਾਂ। ਇਸ ਤੋਂ ਬਾਅਦ, ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦਾ ਪਤਾ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਯਾਨੀ, ਪਤਾ TON ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਫਿਰ ਤੁਹਾਨੂੰ ਇਸ ਪਤੇ 'ਤੇ ਕਈ ਗ੍ਰਾਮ ਭੇਜਣ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਉਸ ਤੋਂ ਬਾਅਦ ਹੀ ਤੁਹਾਨੂੰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਨਾਲ ਇੱਕ ਫਾਈਲ ਭੇਜਣ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ, ਕਿਉਂਕਿ ਨੈਟਵਰਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਸਟੋਰ ਕਰਨ ਅਤੇ ਇਸ ਵਿੱਚ ਓਪਰੇਸ਼ਨ ਕਰਨ ਲਈ ਇੱਕ ਕਮਿਸ਼ਨ ਲੈਂਦਾ ਹੈ (ਪ੍ਰਮਾਣਿਕ ​​ਜੋ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਸਟੋਰ ਅਤੇ ਲਾਗੂ ਕਰਦੇ ਹਨ। ). ਕੋਡ ਨੂੰ ਇੱਥੇ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ.

ਅੱਗੇ ਅਸੀਂ ਪਬਲਿਸ਼ਿੰਗ ਕੋਡ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ lottery-query.boc ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਫਾਈਲ ਅਤੇ ਪਤਾ।

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

ਤਿਆਰ ਕੀਤੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਨਾ ਭੁੱਲੋ: lottery-query.boc, lottery.addr, lottery.pk.

ਹੋਰ ਚੀਜ਼ਾਂ ਦੇ ਨਾਲ, ਅਸੀਂ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲੌਗਸ ਵਿੱਚ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦਾ ਪਤਾ ਦੇਖਾਂਗੇ।

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

ਸਿਰਫ਼ ਮਨੋਰੰਜਨ ਲਈ, ਆਓ TON ਨੂੰ ਬੇਨਤੀ ਕਰੀਏ

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

ਅਤੇ ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਇਸ ਪਤੇ ਵਾਲਾ ਖਾਤਾ ਖਾਲੀ ਹੈ।

account state is empty

ਅਸੀਂ ਪਤੇ 'ਤੇ ਭੇਜਦੇ ਹਾਂ 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 ਗ੍ਰਾਮ ਅਤੇ ਕੁਝ ਸਕਿੰਟਾਂ ਬਾਅਦ ਅਸੀਂ ਉਹੀ ਕਮਾਂਡ ਚਲਾਉਂਦੇ ਹਾਂ। ਗ੍ਰਾਮ ਭੇਜਣ ਲਈ ਮੈਂ ਵਰਤਦਾ ਹਾਂ ਸਰਕਾਰੀ ਬਟੂਆ, ਅਤੇ ਤੁਸੀਂ ਚੈਟ ਤੋਂ ਕਿਸੇ ਨੂੰ ਟੈਸਟ ਗ੍ਰਾਮ ਲਈ ਪੁੱਛ ਸਕਦੇ ਹੋ, ਜਿਸ ਬਾਰੇ ਮੈਂ ਲੇਖ ਦੇ ਅੰਤ ਵਿੱਚ ਗੱਲ ਕਰਾਂਗਾ।

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ਇੱਕ ਅਣ-ਸ਼ੁਰੂਆਤੀ ਵਰਗਾ ਲੱਗਦਾ ਹੈ (state:account_uninit) ਇੱਕੋ ਪਤੇ ਦੇ ਨਾਲ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਅਤੇ 1 ਨੈਨੋਗ੍ਰਾਮ ਦਾ ਸੰਤੁਲਨ।

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

ਹੁਣ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੀਏ. ਆਓ ਲਾਈਟ-ਕਲਾਇੰਟ ਲਾਂਚ ਕਰੀਏ ਅਤੇ ਐਗਜ਼ੀਕਿਊਟ ਕਰੀਏ।

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

ਆਓ ਜਾਂਚ ਕਰੀਏ ਕਿ ਇਕਰਾਰਨਾਮਾ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ.

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ਹੋਰ ਚੀਜ਼ਾਂ ਦੇ ਨਾਲ ਅਸੀਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ.

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

ਅਸੀਂ ਇਹ ਦੇਖਦੇ ਹਾਂ account_active.

ਤਬਦੀਲੀਆਂ ਦੇ ਨਾਲ ਸੰਬੰਧਿਤ ਵਚਨਬੱਧਤਾ ਇੱਥੇ ਹੀ.

ਆਉ ਹੁਣ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ ਬੇਨਤੀਆਂ ਕਰੀਏ।

ਵਧੇਰੇ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਇੱਕ ਸੁਤੰਤਰ ਕੰਮ ਵਜੋਂ ਪਤੇ ਨੂੰ ਬਦਲਣ ਲਈ ਪਹਿਲੇ ਨੂੰ ਛੱਡ ਦੇਵਾਂਗੇ, ਅਤੇ ਅਸੀਂ ਮਾਲਕ ਦੇ ਪਤੇ 'ਤੇ ਗ੍ਰਾਮ ਭੇਜਣ ਲਈ ਦੂਜਾ ਕੰਮ ਕਰਾਂਗੇ। ਵਾਸਤਵ ਵਿੱਚ, ਸਾਨੂੰ ਗ੍ਰਾਮ ਭੇਜਣ ਲਈ ਟੈਸਟ ਵਿੱਚ ਉਹੀ ਕੰਮ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।

ਇਹ ਉਹ ਸੁਨੇਹਾ ਹੈ ਜੋ ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਭੇਜਾਂਗੇ, ਜਿੱਥੇ msg_seqno 165, action ਭੇਜਣ ਲਈ 2 ਅਤੇ 9.5 ਗ੍ਰਾਮ।

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

ਆਪਣੀ ਨਿੱਜੀ ਕੁੰਜੀ ਨਾਲ ਸੁਨੇਹੇ 'ਤੇ ਦਸਤਖਤ ਕਰਨਾ ਨਾ ਭੁੱਲੋ lottery.pk, ਜੋ ਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਬਣਾਉਣ ਵੇਲੇ ਪਹਿਲਾਂ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ। ਇੱਥੇ ਸੰਬੰਧਿਤ ਵਚਨਬੱਧਤਾ ਹੈ.

ਪ੍ਰਾਪਤ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਤੋਂ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨਾ

ਹੁਣ ਆਓ ਦੇਖੀਏ ਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਤਰੀਕਿਆਂ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ.

ਲਾਂਚ ਕਰੋ lite-client ਅਤੇ ਪ੍ਰਾਪਤ ਢੰਗਾਂ ਨੂੰ ਚਲਾਓ ਜੋ ਅਸੀਂ ਲਿਖੇ ਹਨ।

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

В result ਉਹ ਮੁੱਲ ਰੱਖਦਾ ਹੈ ਜੋ ਫੰਕਸ਼ਨ ਵਾਪਸ ਕਰਦਾ ਹੈ balance() ਸਾਡੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਤੋਂ।
ਅਸੀਂ ਕਈ ਹੋਰ ਤਰੀਕਿਆਂ ਲਈ ਵੀ ਅਜਿਹਾ ਹੀ ਕਰਾਂਗੇ।

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

ਚਲੋ ਤੁਹਾਡੇ ਬਾਜ਼ੀ ਇਤਿਹਾਸ ਲਈ ਪੁੱਛੀਏ।

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

ਅਸੀਂ ਲਾਈਟ-ਕਲਾਇੰਟ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਅਤੇ ਸਾਈਟ 'ਤੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਤਰੀਕੇ ਪ੍ਰਾਪਤ ਕਰਾਂਗੇ।

ਵੈੱਬਸਾਈਟ 'ਤੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਡੇਟਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ

ਮੈਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਤੋਂ ਡੇਟਾ ਨੂੰ ਸੁਵਿਧਾਜਨਕ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਵੈਬਸਾਈਟ ਲਿਖੀ ਹੈ। ਇੱਥੇ ਮੈਂ ਇਸ 'ਤੇ ਵਿਸਥਾਰ ਨਾਲ ਨਹੀਂ ਬੋਲਾਂਗਾ ਅਤੇ ਸਾਈਟ ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਾਂਗਾ ਇੱਕ ਵਚਨਬੱਧਤਾ ਵਿੱਚ.

ਤੋਂ TON ਨੂੰ ਬੇਨਤੀਆਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ Python ਦੀ ਸਹਾਇਤਾ ਨਾਲ lite-client. ਸਹੂਲਤ ਲਈ, ਸਾਈਟ ਨੂੰ ਡੌਕਰ ਵਿੱਚ ਪੈਕ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਗੂਗਲ ਕਲਾਉਡ 'ਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਲਿੰਕ.

ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ

ਹੁਣ ਆਉ ਉੱਥੇ ਤੋਂ ਪੂਰਤੀ ਲਈ ਗ੍ਰਾਮ ਭੇਜਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ ਬਟੂਆ. ਅਸੀਂ 40 ਗ੍ਰਾਮ ਭੇਜਾਂਗੇ। ਅਤੇ ਆਓ ਸਪੱਸ਼ਟਤਾ ਲਈ ਕੁਝ ਸੱਟੇਬਾਜ਼ੀ ਕਰੀਏ। ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਸਾਈਟ ਸੱਟੇਬਾਜ਼ੀ ਦਾ ਇਤਿਹਾਸ, ਮੌਜੂਦਾ ਜਿੱਤਣ ਦੀ ਪ੍ਰਤੀਸ਼ਤਤਾ ਅਤੇ ਹੋਰ ਉਪਯੋਗੀ ਜਾਣਕਾਰੀ ਦਿਖਾਉਂਦੀ ਹੈ।

ਅਸੀਂ ਦੇਖਦੇ ਹਾਂਕਿ ਅਸੀਂ ਪਹਿਲਾ ਜਿੱਤਿਆ, ਦੂਜਾ ਹਾਰਿਆ।

ਬਾਅਦ

ਲੇਖ ਮੇਰੀ ਉਮੀਦ ਨਾਲੋਂ ਬਹੁਤ ਲੰਬਾ ਨਿਕਲਿਆ, ਸ਼ਾਇਦ ਇਹ ਛੋਟਾ ਹੋ ਸਕਦਾ ਸੀ, ਜਾਂ ਹੋ ਸਕਦਾ ਹੈ ਸਿਰਫ਼ ਉਸ ਵਿਅਕਤੀ ਲਈ ਜੋ TON ਬਾਰੇ ਕੁਝ ਨਹੀਂ ਜਾਣਦਾ ਹੈ ਅਤੇ ਇਸ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਦੀ ਯੋਗਤਾ ਵਾਲਾ ਇੱਕ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲਿਖਣਾ ਅਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ। ਇਹ. ਸ਼ਾਇਦ ਕੁਝ ਗੱਲਾਂ ਨੂੰ ਹੋਰ ਸਰਲ ਤਰੀਕੇ ਨਾਲ ਸਮਝਾਇਆ ਜਾ ਸਕਦਾ ਸੀ।

ਸ਼ਾਇਦ ਲਾਗੂ ਕਰਨ ਦੇ ਕੁਝ ਪਹਿਲੂਆਂ ਨੂੰ ਹੋਰ ਕੁਸ਼ਲਤਾ ਅਤੇ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਸੀ, ਪਰ ਫਿਰ ਲੇਖ ਨੂੰ ਤਿਆਰ ਕਰਨ ਲਈ ਹੋਰ ਵੀ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਸੀ. ਇਹ ਵੀ ਸੰਭਵ ਹੈ ਕਿ ਮੈਂ ਕਿਤੇ ਗਲਤੀ ਕੀਤੀ ਹੈ ਜਾਂ ਕੁਝ ਸਮਝ ਨਹੀਂ ਆਇਆ, ਇਸ ਲਈ ਜੇਕਰ ਤੁਸੀਂ ਕੁਝ ਗੰਭੀਰ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ TON ਕੋਡ ਦੇ ਨਾਲ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ਾਂ ਜਾਂ ਅਧਿਕਾਰਤ ਰਿਪੋਜ਼ਟਰੀ 'ਤੇ ਭਰੋਸਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

ਇਹ ਨੋਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕਿਉਂਕਿ TON ਖੁਦ ਅਜੇ ਵੀ ਵਿਕਾਸ ਦੇ ਸਰਗਰਮ ਪੜਾਅ ਵਿੱਚ ਹੈ, ਤਬਦੀਲੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜੋ ਇਸ ਲੇਖ ਦੇ ਕਿਸੇ ਵੀ ਕਦਮ ਨੂੰ ਤੋੜ ਦੇਣਗੀਆਂ (ਜੋ ਮੈਂ ਲਿਖ ਰਿਹਾ ਸੀ, ਇਸ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਠੀਕ ਕੀਤਾ ਗਿਆ ਹੈ), ਪਰ ਆਮ ਪਹੁੰਚ ਹੈ. ਬਦਲਣ ਦੀ ਸੰਭਾਵਨਾ ਨਹੀਂ ਹੈ।

ਮੈਂ TON ਦੇ ਭਵਿੱਖ ਬਾਰੇ ਗੱਲ ਨਹੀਂ ਕਰਾਂਗਾ। ਸ਼ਾਇਦ ਪਲੇਟਫਾਰਮ ਕੁਝ ਵੱਡਾ ਬਣ ਜਾਵੇਗਾ ਅਤੇ ਸਾਨੂੰ ਇਸਦਾ ਅਧਿਐਨ ਕਰਨ ਵਿੱਚ ਸਮਾਂ ਬਿਤਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਹੁਣ ਸਾਡੇ ਉਤਪਾਦਾਂ ਨਾਲ ਇੱਕ ਸਥਾਨ ਭਰਨਾ ਚਾਹੀਦਾ ਹੈ।

ਫੇਸਬੁੱਕ ਤੋਂ ਲਿਬਰਾ ਵੀ ਹੈ, ਜਿਸ ਵਿੱਚ TON ਤੋਂ ਵੱਡੇ ਉਪਭੋਗਤਾਵਾਂ ਦੇ ਸੰਭਾਵੀ ਦਰਸ਼ਕ ਹਨ। ਮੈਂ ਲਿਬਰਾ ਬਾਰੇ ਲਗਭਗ ਕੁਝ ਨਹੀਂ ਜਾਣਦਾ, ਫੋਰਮ ਦੁਆਰਾ ਨਿਰਣਾ ਕਰਦੇ ਹੋਏ ਇੱਥੇ TON ਕਮਿਊਨਿਟੀ ਨਾਲੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਗਤੀਵਿਧੀ ਹੈ. ਹਾਲਾਂਕਿ TON ਦੇ ਡਿਵੈਲਪਰ ਅਤੇ ਕਮਿਊਨਿਟੀ ਭੂਮੀਗਤ ਵਰਗੇ ਹਨ, ਜੋ ਕਿ ਠੰਡਾ ਵੀ ਹੈ.

ਹਵਾਲੇ

1. ਅਧਿਕਾਰਤ TON ਦਸਤਾਵੇਜ਼: https://test.ton.org
2. ਅਧਿਕਾਰਤ TON ਭੰਡਾਰ: https://github.com/ton-blockchain/ton
3. ਵੱਖ-ਵੱਖ ਪਲੇਟਫਾਰਮਾਂ ਲਈ ਅਧਿਕਾਰਤ ਵਾਲਿਟ: https://wallet.ton.org
4. ਇਸ ਲੇਖ ਤੋਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਰਿਪੋਜ਼ਟਰੀ: https://github.com/raiym/astonished
5. ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵੈੱਬਸਾਈਟ ਨਾਲ ਲਿੰਕ ਕਰੋ: https://ton-lottery.appspot.com
6. FunC ਲਈ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਕੋਡ ਲਈ ਐਕਸਟੈਂਸ਼ਨ ਲਈ ਰਿਪੋਜ਼ਟਰੀ: https://github.com/raiym/func-visual-studio-plugin
7. ਟੈਲੀਗ੍ਰਾਮ ਵਿੱਚ TON ਬਾਰੇ ਗੱਲਬਾਤ ਕਰੋ, ਜਿਸ ਨੇ ਅਸਲ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਪੜਾਅ 'ਤੇ ਇਸਦਾ ਪਤਾ ਲਗਾਉਣ ਵਿੱਚ ਮਦਦ ਕੀਤੀ। ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੋਵੇਗੀ ਜੇਕਰ ਮੈਂ ਕਹਾਂ ਕਿ ਹਰ ਕੋਈ ਜਿਸਨੇ TON ਲਈ ਕੁਝ ਲਿਖਿਆ ਹੈ ਉੱਥੇ ਹੈ. ਤੁਸੀਂ ਉੱਥੇ ਟੈਸਟ ਗ੍ਰਾਮ ਵੀ ਮੰਗ ਸਕਦੇ ਹੋ। https://t.me/tondev_ru
8. TON ਬਾਰੇ ਇੱਕ ਹੋਰ ਗੱਲਬਾਤ ਜਿਸ ਵਿੱਚ ਮੈਨੂੰ ਉਪਯੋਗੀ ਜਾਣਕਾਰੀ ਮਿਲੀ: https://t.me/TONgramDev
9. ਮੁਕਾਬਲੇ ਦਾ ਪਹਿਲਾ ਪੜਾਅ: https://contest.com/blockchain
10. ਮੁਕਾਬਲੇ ਦਾ ਦੂਜਾ ਪੜਾਅ: https://contest.com/blockchain-2

ਸਰੋਤ: www.habr.com