ਸ਼ੁਰੂ ਤੋਂ ਇੱਕ ਰਸਮੀ ਤਸਦੀਕ ਸਿਸਟਮ ਬਣਾਉਣਾ। ਭਾਗ 1: PHP ਅਤੇ ਪਾਈਥਨ ਵਿੱਚ ਅੱਖਰ ਵਰਚੁਅਲ ਮਸ਼ੀਨ

ਰਸਮੀ ਤਸਦੀਕ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਜਾਂ ਦੂਜੇ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਐਲਗੋਰਿਦਮ ਦੀ ਤਸਦੀਕ ਹੈ।

ਇਹ ਸਭ ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਢੰਗਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਸਾਰੀਆਂ ਕਮਜ਼ੋਰੀਆਂ ਲੱਭਣ ਜਾਂ ਇਹ ਸਾਬਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਕਿ ਉਹ ਮੌਜੂਦ ਨਹੀਂ ਹਨ।

ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦੇ ਉਦਾਹਰਣ ਵਿੱਚ ਰਸਮੀ ਤਸਦੀਕ ਦਾ ਇੱਕ ਹੋਰ ਵਿਸਤ੍ਰਿਤ ਵਰਣਨ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਬਘਿਆੜ, ਬੱਕਰੀ, ਅਤੇ ਗੋਭੀ ਮੇਰੇ ਪਿਛਲੇ ਲੇਖ ਵਿੱਚ.

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

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਮੈਂ ਪ੍ਰਤੀਕਾਤਮਕ ਸਿਧਾਂਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦਾ ਆਪਣਾ ਐਨਾਲਾਗ ਲਿਖਿਆ.

ਇਹ ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਨੂੰ ਪਾਰਸ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਮੀਕਰਨਾਂ ਦੀ ਇੱਕ ਪ੍ਰਣਾਲੀ (SMT) ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਪ੍ਰੋਗਰਾਮਾਂ ਨਾਲ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਕਿਉਂਕਿ ਪ੍ਰਤੀਕਾਤਮਕ ਗਣਨਾਵਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਇੰਟਰਨੈਟ 'ਤੇ ਖੰਡਿਤ ਰੂਪ ਵਿੱਚ ਪੇਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ,
ਮੈਂ ਸੰਖੇਪ ਵਿੱਚ ਵਰਣਨ ਕਰਾਂਗਾ ਕਿ ਇਹ ਕੀ ਹੈ.

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

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

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

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

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਪ੍ਰੋਗਰਾਮ ਦੀਆਂ ਸਾਰੀਆਂ ਕਮਜ਼ੋਰੀਆਂ ਲੱਭਾਂਗੇ ਜਾਂ ਪ੍ਰਸ਼ਾਸਕ ਦਾ ਪਾਸਵਰਡ ਸੁਰੱਖਿਅਤ ਹੋਣ ਦਾ ਸਬੂਤ ਪ੍ਰਾਪਤ ਕਰਾਂਗੇ।

ਇਹ ਨੋਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਕਿ ਖਾਸ ਇਨਪੁਟ ਡੇਟਾ ਦੇ ਨਾਲ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਦਾ ਕਲਾਸੀਕਲ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਿੰਬਲਿਕ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦਾ ਇੱਕ ਖਾਸ ਕੇਸ ਹੈ।

ਇਸ ਲਈ, ਮੇਰਾ ਅੱਖਰ VM ਇੱਕ ਮਿਆਰੀ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੇ ਇਮੂਲੇਸ਼ਨ ਮੋਡ ਵਿੱਚ ਵੀ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ।

ਪਿਛਲੇ ਲੇਖ ਦੀਆਂ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਇਸ ਦੀਆਂ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਚਰਚਾ ਦੇ ਨਾਲ ਰਸਮੀ ਤਸਦੀਕ ਦੀ ਨਿਰਪੱਖ ਆਲੋਚਨਾ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਮੁੱਖ ਸਮੱਸਿਆਵਾਂ ਹਨ:

1. ਸੰਯੁਕਤ ਵਿਸਫੋਟ, ਕਿਉਂਕਿ ਰਸਮੀ ਤਸਦੀਕ ਆਖਰਕਾਰ P=NP ਤੱਕ ਹੇਠਾਂ ਆਉਂਦੀ ਹੈ
2. ਫਾਈਲ ਸਿਸਟਮ, ਨੈੱਟਵਰਕਾਂ ਅਤੇ ਹੋਰ ਬਾਹਰੀ ਸਟੋਰੇਜ ਲਈ ਕਾਲਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਤਸਦੀਕ ਕਰਨਾ ਵਧੇਰੇ ਮੁਸ਼ਕਲ ਹੈ
3. ਨਿਰਧਾਰਨ ਵਿੱਚ ਬੱਗ, ਜਦੋਂ ਗਾਹਕ ਜਾਂ ਪ੍ਰੋਗਰਾਮਰ ਇੱਕ ਚੀਜ਼ ਦਾ ਇਰਾਦਾ ਰੱਖਦਾ ਹੈ, ਪਰ ਤਕਨੀਕੀ ਨਿਰਧਾਰਨ ਵਿੱਚ ਇਸ ਦਾ ਕਾਫ਼ੀ ਸਹੀ ਵਰਣਨ ਨਹੀਂ ਕਰਦਾ ਹੈ।

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

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

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

ਪਰ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਤਕਨੀਕੀ ਪੱਖ ਤੋਂ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਵਿਚਾਰਾਂਗੇ।

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

ਮੇਰੀ ਸਿੰਬਲਿਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ PHP ਅਤੇ Python ਵਿੱਚ ਲਿਖੀ ਗਈ ਹੈ, ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ SMT ਫਾਰਮੂਲੇ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ Microsoft ਖੋਜ ਤੋਂ Z3Prover ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।

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

ਪਰ ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਈਥਰ ਕੰਟਰੈਕਟ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਅਤੇ ਟਿਊਰਿੰਗ ਸੰਪੂਰਨ ਹਨ।

PHP RIDE ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਸਰੋਤ ਕੋਡ ਨੂੰ ਇੱਕ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਉਹਨਾਂ ਦੇ ਪਰਿਵਰਤਨ ਲਈ ਕੰਟਰੈਕਟ ਸਟੇਟਸ ਅਤੇ ਸ਼ਰਤਾਂ ਦੀ Z3 SMT-ਅਨੁਕੂਲ ਪ੍ਰਣਾਲੀ ਵਜੋਂ ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

ਹੁਣ ਮੈਂ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਵਰਣਨ ਕਰਾਂਗਾ ਕਿ ਅੰਦਰ ਕੀ ਹੋ ਰਿਹਾ ਹੈ.

ਪਰ ਪਹਿਲਾਂ, ਰਾਈਡ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਭਾਸ਼ਾ ਬਾਰੇ ਕੁਝ ਸ਼ਬਦ।

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

ਤੁਸੀਂ ਹਰੇਕ ਵਾਲਿਟ ਨਾਲ ਇੱਕ ਰਾਈਡ ਇਕਰਾਰਨਾਮਾ ਨੱਥੀ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਲਾਗੂ ਕਰਨ ਦਾ ਨਤੀਜਾ ਸਿਰਫ ਸਹੀ ਜਾਂ ਗਲਤ ਹੋਵੇਗਾ।

TRUE ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲੈਣ-ਦੇਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਅਤੇ FALSE ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਇਸਦੀ ਮਨਾਹੀ ਕਰਦਾ ਹੈ।
ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਨ: ਜੇਕਰ ਵਾਲਿਟ ਬੈਲੇਂਸ 100 ਤੋਂ ਘੱਟ ਹੈ ਤਾਂ ਇੱਕ ਸਕ੍ਰਿਪਟ ਟ੍ਰਾਂਸਫਰ ਨੂੰ ਰੋਕ ਸਕਦੀ ਹੈ।

ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ ਤੇ, ਮੈਂ ਉਹੀ ਵੁਲਫ, ਬੱਕਰੀ ਅਤੇ ਗੋਭੀ ਲਵਾਂਗਾ, ਪਰ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਰੂਪ ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ.

ਉਪਭੋਗਤਾ ਉਸ ਵਾਲਿਟ ਤੋਂ ਪੈਸੇ ਕਢਵਾਉਣ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੇਗਾ ਜਿਸ 'ਤੇ ਇਕਰਾਰਨਾਮਾ ਤਾਇਨਾਤ ਹੈ ਜਦੋਂ ਤੱਕ ਉਹ ਹਰ ਕਿਸੇ ਨੂੰ ਦੂਜੇ ਪਾਸੇ ਨਹੀਂ ਭੇਜਦਾ।

#Извлекаем положение всех объектов из блокчейна
let contract = tx.sender
let human= extract(getInteger(contract,"human"))
let wolf= extract(getInteger(contract,"wolf"))
let goat= extract(getInteger(contract,"goat"))
let cabbage= extract(getInteger(contract,"cabbage"))

#Это так называемая дата-транзакция, в которой пользователь присылает новые 4 переменные.
#Контракт разрешит её только в случае если все объекты останутся в сохранности.
match tx {
case t:DataTransaction =>
   #Извлекаем будущее положение всех объектов из транзакции
   let newHuman= extract(getInteger(t.data,"human")) 
   let newWolf= extract(getInteger(t.data,"wolf"))
   let newGoat= extract(getInteger(t.data,"goat"))
   let newCabbage= extract(getInteger(t.data,"cabbage"))
   
   #0 обозначает, что объект на левом берегу, а 1 что на правом
   let humanSide= human == 0 || human == 1
   let wolfSide= wolf == 0 || wolf == 1
   let goatSide= goat == 0 || goat == 1
   let cabbageSide= cabbage == 0 || cabbage == 1
   let side= humanSide && wolfSide && goatSide && cabbageSide

   #Будут разрешены только те транзакции, где с козой никого нет в отсутствии фермера.
   let safeAlone= newGoat != newWolf && newGoat != newCabbage
   let safe= safeAlone || newGoat == newHuman
   let humanTravel= human != newHuman 

   #Способы путешествия фермера туда и обратно, с кем-то либо в одиночку.
   let t1= humanTravel && newWolf == wolf + 1 && newGoat == goat && newCabbage == cabbage 
   let t2= humanTravel && newWolf == wolf && newGoat == goat + 1 && newCabbage == cabbage
   let t3= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage + 1
   let t4= humanTravel && newWolf == wolf - 1 && newGoat == goat && newCabbage == cabbage
   let t5= humanTravel && newWolf == wolf && newGoat == goat - 1 && newCabbage == cabbage
   let t6= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage - 1
   let t7= humanTravel && newWolf == wolf && newGoat == goat && newCabbage == cabbage
   let objectTravel = t1 || t2 || t3 || t4 || t5 || t6 || t7
   
   #Последняя строка в разделе транзакции описывает разрешающее транзакцию условие.
   #Переменные транзакции должны иметь значения 1 или 0, все объекты должны
   #быть в безопасности, а фермер должен переплывать реку в одиночку 
   #или с кем-то на каждом шагу
   side && safe && humanTravel && objectTravel
case s:TransferTransaction =>
   #Транзакция вывода средств разрешена только в случае если все переплыли на другой берег
   human == 1 && wolf == 1 && goat == 1 && cabbage == 1

#Все прочие типы транзакций запрещены
case _ => false

}

PHP ਪਹਿਲਾਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਤੋਂ ਸਾਰੇ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਉਹਨਾਂ ਦੀਆਂ ਕੁੰਜੀਆਂ ਅਤੇ ਸੰਬੰਧਿਤ ਬੂਲੀਅਨ ਸਮੀਕਰਨ ਵੇਰੀਏਬਲ ਦੇ ਰੂਪ ਵਿੱਚ ਕੱਢਦਾ ਹੈ।

cabbage: extract ( getInteger ( contract , "cabbage" ) )
goat: extract ( getInteger ( contract , "goat" ) )
human: extract ( getInteger ( contract , "human" ) )
wolf: extract ( getInteger ( contract , "wolf" ) )
fState: human== 1 && wolf== 1 && goat== 1 && cabbage== 1
fState: 
wolf: 
goat: 
cabbage: 
cabbageSide: cabbage== 0 || cabbage== 1
human: extract ( getInteger ( contract , "human" ) )
newGoat: extract ( getInteger ( t.data , "goat" ) )
newHuman: extract ( getInteger ( t.data , "human" ) )
goatSide: goat== 0 || goat== 1
humanSide: human== 0 || human== 1
t7: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage
t3: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage + 1
t6: humanTravel && newWolf== wolf && newGoat== goat && newCabbage== cabbage - 1
t2: humanTravel && newWolf== wolf && newGoat== goat + 1 && newCabbage== cabbage
t5: humanTravel && newWolf== wolf && newGoat== goat - 1 && newCabbage== cabbage
t1: humanTravel && newWolf== wolf + 1 && newGoat== goat && newCabbage== cabbage
t4: humanTravel && newWolf== wolf - 1 && newGoat== goat && newCabbage== cabbage
safeAlone: newGoat != newWolf && newGoat != newCabbage
wolfSide: wolf== 0 || wolf== 1
humanTravel: human != newHuman
side: humanSide && wolfSide && goatSide && cabbageSide
safe: safeAlone || newGoat== newHuman
objectTravel: t1 || t2 || t3 || t4 || t5 || t6 || t7

PHP ਫਿਰ ਉਹਨਾਂ ਨੂੰ Python ਵਿੱਚ Z3Prover SMT- ਅਨੁਕੂਲ ਸਿਸਟਮ ਵਰਣਨ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
ਡੇਟਾ ਨੂੰ ਇੱਕ ਲੂਪ ਵਿੱਚ ਲਪੇਟਿਆ ਜਾਂਦਾ ਹੈ, ਜਿੱਥੇ ਸਟੋਰੇਜ ਵੇਰੀਏਬਲ ਇੰਡੈਕਸ i ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ, ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵੇਰੀਏਬਲ ਇੰਡੈਕਸ i + 1, ਅਤੇ ਸਮੀਕਰਨਾਂ ਵਾਲੇ ਵੇਰੀਏਬਲ ਪਿਛਲੀ ਸਥਿਤੀ ਤੋਂ ਅਗਲੀ ਸਥਿਤੀ ਵਿੱਚ ਤਬਦੀਲੀ ਲਈ ਨਿਯਮ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ।

ਇਹ ਸਾਡੀ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦਾ ਬਹੁਤ ਹੀ ਦਿਲ ਹੈ, ਜੋ ਇੱਕ ਮਲਟੀ-ਟ੍ਰਾਂਜੈਕਸ਼ਨਲ ਖੋਜ ਇੰਜਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

fState:  And( And( And( human[Steps]  ==  1 , wolf[Steps]  ==  1 )  , goat[Steps]  ==  1 )  , cabbage[Steps]  ==  1 )  
final:  fState[Steps] 
fState:   
wolf:   
goat:   
cabbage:   
cabbageSide:  Or( cabbage[i]  ==  0 , cabbage[i]  ==  1 )  
goatSide:  Or( goat[i]  ==  0 , goat[i]  ==  1 )  
humanSide:  Or( human[i]  ==  0 , human[i]  ==  1 )  
t7:  And( And( And( humanTravel[i] , wolf  ==  wolf[i] )  , goat[i+1]  ==  goat[i] )  , cabbage  ==  cabbage[i] )  
t3:  And( And( And( humanTravel[i] , wolf  ==  wolf[i] )  , goat[i+1]  ==  goat[i] )  , cabbage  ==  cabbage[i] + 1 )  
t6:  And( And( And( humanTravel[i] , wolf  ==  wolf[i] )  , goat[i+1]  ==  goat[i] )  , cabbage  ==  cabbage[i] - 1 )  
t2:  And( And( And( humanTravel[i] , wolf  ==  wolf[i] )  , goat[i+1]  ==  goat[i] + 1 )  , cabbage  ==  cabbage[i] )  
t5:  And( And( And( humanTravel[i] , wolf  ==  wolf[i] )  , goat[i+1]  ==  goat[i] - 1 )  , cabbage  ==  cabbage[i] )  
t1:  And( And( And( humanTravel[i] , wolf  ==  wolf[i] + 1 )  , goat[i+1]  ==  goat[i] )  , cabbage  ==  cabbage[i] )  
t4:  And( And( And( humanTravel[i] , wolf  ==  wolf[i] - 1 )  , goat[i+1]  ==  goat[i] )  , cabbage  ==  cabbage[i] )  
safeAlone:  And( goat[i+1] != wolf , goat[i+1] != cabbage )  
wolfSide:  Or( wolf[i]  ==  0 , wolf[i]  ==  1 )  
humanTravel:  human[i] != human[i+1] 
side:  And( And( And( humanSide[i] , wolfSide[i] )  , goatSide[i] )  , cabbageSide[i] )  
safe:  Or( safeAlone[i] , goat[i+1]  ==  human[i+1] )  
objectTravel:  Or( Or( Or( Or( Or( Or( t1[i] , t2[i] )  , t3[i] )  , t4[i] )  , t5[i] )  , t6[i] )  , t7[i] )  
data:  And( And( And( side[i] , safe[i] )  , humanTravel[i] )  , objectTravel[i] )  

ਸ਼ਰਤਾਂ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਪਾਈਥਨ ਵਿੱਚ SMT ਸਿਸਟਮ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਇੱਕ ਸਕ੍ਰਿਪਟ ਟੈਂਪਲੇਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ।

ਖਾਲੀ ਟੈਮਪਲੇਟ

import json

from z3 import *

s = Solver()

  
  
    
Steps=7
Num= Steps+1

$code$



#template, only start rest
s.add(data + start)

#template
s.add(final)




ind = 0

f = open("/var/www/html/all/bin/python/log.txt", "a")



while s.check() == sat:
  ind = ind +1
  

  print ind
  m = s.model()
  print m

  print "traversing model..." 
  #for d in m.decls():
	#print "%s = %s" % (d.name(), m[d])

  
 
  f.write(str(m))
  f.write("nn")
  exit()
  #s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model



print "Total solution number: "
print ind  

f.close()
 

ਪੂਰੀ ਲੜੀ ਵਿੱਚ ਆਖਰੀ ਸਥਿਤੀ ਲਈ, ਟ੍ਰਾਂਸਫਰ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਸੈਕਸ਼ਨ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਨਿਯਮ ਲਾਗੂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

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

ਨਤੀਜੇ ਵਜੋਂ, ਅਸੀਂ ਆਪਣੇ ਆਪ ਹੀ ਸਾਡੇ ਇਕਰਾਰਨਾਮੇ ਦਾ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਾਰਜਸ਼ੀਲ SMT ਮਾਡਲ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ।
ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਮੇਰੇ ਪਿਛਲੇ ਲੇਖ ਦੇ ਮਾਡਲ ਦੇ ਸਮਾਨ ਹੈ, ਜਿਸਨੂੰ ਮੈਂ ਹੱਥੀਂ ਕੰਪਾਇਲ ਕੀਤਾ ਹੈ.

ਪੂਰਾ ਕੀਤਾ ਟੈਮਪਲੇਟ

import json

from z3 import *

s = Solver()

  
  
    
Steps=7
Num= Steps+1

human = [ Int('human_%i' % (i + 1)) for i in range(Num) ]
wolf = [ Int('wolf_%i' % (i + 1)) for i in range(Num) ]
goat = [ Int('goat_%i' % (i + 1)) for i in range(Num) ]
cabbage = [ Int('cabbage_%i' % (i + 1)) for i in range(Num) ]
nothing= [  And( human[i] == human[i+1], wolf[i] == wolf[i+1], goat[i] == goat[i+1], cabbage[i] == cabbage[i+1] )   for i in range(Num-1) ]


start= [ human[0] == 1, wolf[0] == 0, goat[0] == 1, cabbage[0] == 0 ]

safeAlone= [  And( goat[i+1] != wolf[i+1] , goat[i+1] != cabbage[i+1] )   for i in range(Num-1) ]
safe= [  Or( safeAlone[i] , goat[i+1]  ==  human[i+1] )   for i in range(Num-1) ]
humanTravel= [  human[i] != human[i+1]  for i in range(Num-1) ]
cabbageSide= [  Or( cabbage[i]  ==  0 , cabbage[i]  ==  1 )   for i in range(Num-1) ]
goatSide= [  Or( goat[i]  ==  0 , goat[i]  ==  1 )   for i in range(Num-1) ]
humanSide= [  Or( human[i]  ==  0 , human[i]  ==  1 )   for i in range(Num-1) ]
t7= [  And( And( And( humanTravel[i] , wolf[i+1]  ==  wolf[i] )  , goat[i+1]  ==  goat[i] )  , cabbage[i+1]  ==  cabbage[i] )   for i in range(Num-1) ]
t3= [  And( And( And( humanTravel[i] , wolf[i+1]  ==  wolf[i] )  , goat[i+1]  ==  goat[i] )  , cabbage[i+1]  ==  cabbage[i] + 1 )   for i in range(Num-1) ]
t6= [  And( And( And( humanTravel[i] , wolf[i+1]  ==  wolf[i] )  , goat[i+1]  ==  goat[i] )  , cabbage[i+1]  ==  cabbage[i] - 1 )   for i in range(Num-1) ]
t2= [  And( And( And( humanTravel[i] , wolf[i+1]  ==  wolf[i] )  , goat[i+1]  ==  goat[i] + 1 )  , cabbage[i+1]  ==  cabbage[i] )   for i in range(Num-1) ]
t5= [  And( And( And( humanTravel[i] , wolf[i+1]  ==  wolf[i] )  , goat[i+1]  ==  goat[i] - 1 )  , cabbage[i+1]  ==  cabbage[i] )   for i in range(Num-1) ]
t1= [  And( And( And( humanTravel[i] , wolf[i+1]  ==  wolf[i] + 1 )  , goat[i+1]  ==  goat[i] )  , cabbage[i+1]  ==  cabbage[i] )   for i in range(Num-1) ]
t4= [  And( And( And( humanTravel[i] , wolf[i+1]  ==  wolf[i] - 1 )  , goat[i+1]  ==  goat[i] )  , cabbage[i+1]  ==  cabbage[i] )   for i in range(Num-1) ]
wolfSide= [  Or( wolf[i]  ==  0 , wolf[i]  ==  1 )   for i in range(Num-1) ]
side= [  And( And( And( humanSide[i] , wolfSide[i] )  , goatSide[i] )  , cabbageSide[i] )   for i in range(Num-1) ]
objectTravel= [  Or( Or( Or( Or( Or( Or( t1[i] , t2[i] )  , t3[i] )  , t4[i] )  , t5[i] )  , t6[i] )  , t7[i] )   for i in range(Num-1) ]
data= [ Or(  And( And( And( side[i] , safe[i] )  , humanTravel[i] )  , objectTravel[i] )   , nothing[i]) for i in range(Num-1) ]


fState=  And( And( And( human[Steps]  ==  1 , wolf[Steps]  ==  1 )  , goat[Steps]  ==  1 )  , cabbage[Steps]  ==  1 )  
final=  fState 




#template, only start rest
s.add(data + start)

#template
s.add(final)




ind = 0

f = open("/var/www/html/all/bin/python/log.txt", "a")



while s.check() == sat:
  ind = ind +1
  

  print ind
  m = s.model()
  print m

  print "traversing model..." 
  #for d in m.decls():
	#print "%s = %s" % (d.name(), m[d])

  
 
  f.write(str(m))
  f.write("nn")
  exit()
  #s.add(Or(goat[0] != s.model()[data[0]] )) # prevent next model from using the same assignment as a previous model



print "Total solution number: "
print ind  

f.close()
 

ਲਾਂਚ ਤੋਂ ਬਾਅਦ, Z3Prover ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ ਅਤੇ ਸਾਨੂੰ ਲੈਣ-ਦੇਣ ਦੀ ਇੱਕ ਲੜੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਸਾਨੂੰ ਫੰਡ ਕਢਵਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ:

Winning transaction chain found:
Data transaction: human= 0, wolf= 0, goat= 1, cabbage= 0
Data transaction: human= 1, wolf= 0, goat= 1, cabbage= 1
Data transaction: human= 0, wolf= 0, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 0, wolf= 1, goat= 0, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Data transaction: human= 1, wolf= 1, goat= 1, cabbage= 1
Transfer transaction

ਫੈਰੀ ਇਕਰਾਰਨਾਮੇ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਆਪਣੇ ਖੁਦ ਦੇ ਇਕਰਾਰਨਾਮੇ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਇਸ ਸਧਾਰਨ ਉਦਾਹਰਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ 2 ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਵਿੱਚ ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.

let contract = tx.sender
let a= extract(getInteger(contract,"a"))
let b= extract(getInteger(contract,"b"))
let c= extract(getInteger(contract,"c"))
let d= extract(getInteger(contract,"d"))

match tx {
case t:DataTransaction =>
let na= extract(getInteger(t.data,"a")) 
let nb= extract(getInteger(t.data,"b"))
let nc= extract(getInteger(t.data,"c"))
let nd= extract(getInteger(t.data,"d"))
   
   nd == 0 || a == 100 - 5
case s:TransferTransaction =>
   ( a + b - c ) * d == 12

case _ => true

}

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

ਅੱਖਰ ਵਰਚੁਅਲ ਮਸ਼ੀਨ 'ਤੇ ਉਪਲਬਧ ਹੈ http://2.59.42.98/hyperbox/
ਪ੍ਰਤੀਕ VM ਦੇ ਸਰੋਤ ਕੋਡ ਨੂੰ ਕ੍ਰਮ ਵਿੱਚ ਰੱਖਣ ਅਤੇ ਉੱਥੇ ਟਿੱਪਣੀਆਂ ਜੋੜਨ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਇਸਨੂੰ ਮੁਫਤ ਪਹੁੰਚ ਲਈ GitHub 'ਤੇ ਰੱਖਣ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਿਹਾ ਹਾਂ.

ਸਰੋਤ: www.habr.com