ਜੇਕਰ ਅਸੀਂ ਪਿਛਲੇ ਕੁਝ ਸਾਲਾਂ ਦੇ ਰੁਝਾਨਾਂ 'ਤੇ ਨਜ਼ਰ ਮਾਰੀਏ, ਤਾਂ ਅਸੀਂ ਹਰ ਸਮੇਂ ਬਲਾਕਚੈਨ ਬਾਰੇ ਸੁਣਿਆ ਹੈ, ਪਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ ਜ਼ਿਆਦਾ ਨਹੀਂ।
ਅਸੀਂ ਸਾਰੇ ਜਾਣਦੇ ਹਾਂ ਕਿ ਕ੍ਰਿਪਟੋਕਰੰਸੀ ਜਿਵੇਂ ਕਿ ਬਿਟਕੋਇਨ, ਈਥਰਿਅਮ, ਡੋਗੇਕੋਇਨ, ਮੈਟਿਕ, ਅਤੇ ਹੋਰ ਬਲੌਕਚੈਨ ਤਕਨਾਲੋਜੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। ਬਲਾਕਚੈਨ ਨੇ ਮਹੱਤਵਪੂਰਨ ਘਟਨਾਵਾਂ ਦੀ ਅਗਵਾਈ ਕੀਤੀ ਜਿਨ੍ਹਾਂ ਨੇ 2021 ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਉਦਯੋਗਾਂ ਵਿੱਚ ਕ੍ਰਾਂਤੀ ਲਿਆ ਦਿੱਤੀ ਅਤੇ ਨਵੀਆਂ ਪ੍ਰਾਪਤੀਆਂ ਲਈ ਰਾਹ ਪੱਧਰਾ ਕੀਤਾ।
ਬਲਾਕਚੈਨ ਡੇਟਾ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਸਟੋਰ ਕਰਨ ਦਾ ਇੱਕ ਸਾਧਨ ਹੈ ਜਿਸਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨਾ, ਹੈਕ ਕਰਨਾ ਜਾਂ ਧੋਖਾ ਦੇਣਾ ਔਖਾ ਜਾਂ ਅਸੰਭਵ ਹੈ। ਇਹ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਦਾ ਇੱਕ ਡਿਜੀਟਲ ਬਹੀ ਹੈ ਜੋ ਡੁਪਲੀਕੇਟ ਹੁੰਦੇ ਹਨ ਅਤੇ ਬਲਾਕਚੈਨ ਦੇ ਕੰਪਿਊਟਰ ਸਿਸਟਮਾਂ ਦੇ ਪੂਰੇ ਨੈੱਟਵਰਕ ਵਿੱਚ ਫੈਲਦੇ ਹਨ।
ਇਹ ਜ਼ਮੀਨ ਨੂੰ ਤੋੜਨ ਵਾਲੀ ਡੇਟਾਬੇਸ ਤਕਨਾਲੋਜੀ ਹੈ ਜੋ ਅਮਲੀ ਤੌਰ 'ਤੇ ਸਾਰੀਆਂ ਕ੍ਰਿਪਟੋਕਰੰਸੀਆਂ ਨੂੰ ਸ਼ਕਤੀ ਦਿੰਦੀ ਹੈ। ਬਲਾਕਚੈਨ ਪੂਰੇ ਨੈੱਟਵਰਕ ਵਿੱਚ ਇੱਕ ਡੇਟਾਬੇਸ ਦੀਆਂ ਇੱਕੋ ਜਿਹੀਆਂ ਕਾਪੀਆਂ ਨੂੰ ਫੈਲਾ ਕੇ ਸਿਸਟਮ ਨੂੰ ਹੈਕ ਕਰਨਾ ਜਾਂ ਧੋਖਾ ਦੇਣਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦਾ ਹੈ।
ਜਦੋਂ ਕਿ ਬਿਟਕੋਇਨ ਹੁਣ ਬਲਾਕਚੈਨ ਲਈ ਸਭ ਤੋਂ ਪ੍ਰਮੁੱਖ ਵਰਤੋਂ ਹੈ, ਤਕਨਾਲੋਜੀ ਬਹੁਤ ਵਿਆਪਕ ਕਿਸਮ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਸੇਵਾ ਕਰ ਸਕਦੀ ਹੈ।
ਹਾਲ ਹੀ ਦੇ ਸਾਲਾਂ ਵਿੱਚ ਕ੍ਰਿਪਟੋਕਰੰਸੀ ਅਤੇ ਬਲਾਕਚੈਨ ਵਧਦੀ ਪ੍ਰਸਿੱਧ ਹੋ ਗਈ ਹੈ, ਅਤੇ ਇਹ ਰੁਝਾਨ ਜਾਰੀ ਰਹਿਣ ਦੀ ਉਮੀਦ ਹੈ।
ਅਸੀਂ ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ JavaScript ਦੇ ਨਾਲ ਇੱਕ ਸਧਾਰਨ ਬਲਾਕਚੇਨ ਬਣਾਵਾਂਗੇ। ਇਹ ਤੁਹਾਨੂੰ ਇੱਕ ਬੁਨਿਆਦੀ ਸਮਝ ਪ੍ਰਦਾਨ ਕਰੇਗਾ ਕਿ ਇੱਕ ਬਲਾਕਚੈਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।
ਚਲੋ ਇਸਨੂੰ MelodyCoin ਕਹਿੰਦੇ ਹਾਂ ਅਤੇ ਕਾਰਵਾਈ 'ਤੇ ਸਹੀ ਪਾਈਏ!
ਇੱਕ ਬਲਾਕ ਬਣਾਉਣਾ
ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਨਵੀਂ JavaScript ਫਾਈਲ ਬਣਾਵਾਂਗੇ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਆਪਣਾ ਸਾਰਾ ਕੋਡ ਰੱਖਾਂਗੇ।
ਆਉ ਇਸਨੂੰ main.js ਕਹਿੰਦੇ ਹਾਂ ਅਤੇ ਇਸ ਦੇ ਵਰਣਨ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ ਕਿ ਇੱਕ ਬਲਾਕਚੈਨ ਅਤੇ ਬਲਾਕ ਕਿਵੇਂ ਦਿਖਾਈ ਦੇਣੇ ਚਾਹੀਦੇ ਹਨ।
ਇੱਕ ਬਲਾਕ ਕਲਾਸ ਬਣਾਓ ਅਤੇ ਇਸਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ Object() { [ਦੇਸੀ ਕੋਡ] } ਦਿਓ।
ਨਵਾਂ ਬਲਾਕ ਬਣਾਉਣ ਵੇਲੇ ਤੁਹਾਨੂੰ ਇੱਕ ਮਿਤੀ, ਅਤੇ ਪਿਛਲੇ ਬਲਾਕ ਦਾ ਹੈਸ਼ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ:
ਇੱਥੇ ਹਰੇਕ ਸੰਪਤੀ ਲਈ ਪਰਿਭਾਸ਼ਾਵਾਂ ਹਨ:
- ਟਾਈਮਸਟੈਂਪ ਦੱਸਦਾ ਹੈ ਕਿ ਬਲਾਕ ਕਦੋਂ ਬਣਾਇਆ ਗਿਆ ਸੀ। ਤੁਸੀਂ ਜੋ ਵੀ ਫਾਰਮੈਟ ਚੁਣਦੇ ਹੋ ਉਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ (ਇਸ ਕੇਸ ਵਿੱਚ, ਇੱਕ UNIX ਟਾਈਮਸਟੈਂਪ)।
- ਡੇਟਾ ਦਾ ਕੋਈ ਵੀ ਰੂਪ ਜੋ ਤੁਸੀਂ ਇਸ ਬਲਾਕ ਨਾਲ ਜੁੜਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਡੇਟਾ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਕ੍ਰਿਪਟੋਕੁਰੰਸੀ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਲੈਣ-ਦੇਣ ਦਾ ਡਾਟਾ ਰੱਖ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਕਿ ਭੇਜਣ ਵਾਲਾ/ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲਾ ਅਤੇ ਇੱਥੇ ਭੇਜੀ ਗਈ ਰਕਮ ਦੀ ਰਕਮ।
- ਪਿਛਲਾ ਹੈਸ਼ ਇੱਕ ਸਤਰ ਹੈ ਜੋ ਪੁਰਾਣੇ ਬਲਾਕ ਦੇ ਹੈਸ਼ ਨੂੰ ਰੱਖਦਾ ਹੈ। ਇਹ ਉਹ ਹੈ ਜੋ ਬਲਾਕਾਂ ਦੀ ਲੜੀ ਪੈਦਾ ਕਰੇਗਾ, ਜੋ ਬਾਅਦ ਵਿੱਚ ਸਾਡੇ ਬਲਾਕਚੈਨ ਦੀ ਇਕਸਾਰਤਾ ਪ੍ਰਦਾਨ ਕਰਨ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੋਵੇਗਾ।
ਹੈਸ਼ ਬਣਾਉਣਾ
ਹਰੇਕ ਬਲਾਕ ਪਿਛਲੇ ਬਲਾਕ ਨਾਲ ਲਿੰਕ ਕਰਦਾ ਹੈ (ਇਸ ਤਰ੍ਹਾਂ ਪਿਛਲੀ ਹੈਸ਼ ਵਿਸ਼ੇਸ਼ਤਾ)। ਭਾਵ, ਹਰੇਕ ਬਲਾਕ ਲਈ ਇੱਕ ਹੈਸ਼ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਕ ਹੈਸ਼ ਇੱਕ ਫਿੰਗਰਪ੍ਰਿੰਟ ਦੇ ਸਮਾਨ ਹੈ। ਇਹ ਹਰੇਕ ਬਲਾਕ ਲਈ ਵੱਖਰਾ ਹੈ।
ਇੱਕ ਬਲਾਕ ਦੀ ਹੈਸ਼ ਨੂੰ ਹੈਸ਼ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਇਸਦੀ ਸਾਰੀ ਸਮੱਗਰੀ ਨੂੰ ਪਾਸ ਕਰਕੇ ਗਿਣਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਇਸ ਲਈ, ਆਉ ਇੱਕ ਫੰਕਸ਼ਨ ਲਾਗੂ ਕਰਕੇ ਸ਼ੁਰੂਆਤ ਕਰੀਏ ਜੋ ਮੌਜੂਦਾ ਬਲਾਕ ਦੇ ਹੈਸ਼ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ।
ਇਸ ਲਈ, ਬਲਾਕ ਕਲਾਸ ਦੇ ਅਧੀਨ, ਅਸੀਂ ਕੈਲਕੂਲੇਟ ਹੈਸ਼ ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ:
ਹਾਲਾਂਕਿ, SHA256 ਹੈਸ਼ JavaScript ਦੁਆਰਾ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ ਅਤੇ ਇੱਕ ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
Crypto-js ਇੱਕ ਸ਼ਾਨਦਾਰ ਪੈਕੇਜ ਹੈ ਜਿਸ ਵਿੱਚ ਕਈ ਹੈਸ਼ ਐਲਗੋਰਿਦਮ ਦੇ ਸੁਰੱਖਿਅਤ ਲਾਗੂਕਰਨ ਸ਼ਾਮਲ ਹਨ।
ਫਿਰ ਅਸੀਂ ਇਸਨੂੰ ਸਾਡੇ main.js ਕੋਡ ਵਿੱਚ ਆਯਾਤ ਕਰ ਸਕਦੇ ਹਾਂ।
ਹੁਣ ਜਦੋਂ ਕਿ ਸਾਡੇ ਕੋਲ calculateHash() ਫੰਕਸ਼ਨ ਹੈ, ਆਓ ਇਸਨੂੰ ਆਪਣੇ ਬਲਾਕ ਦੇ ਫੰਕਸ਼ਨ ਵਿੱਚ ਵਰਤਣ ਲਈ ਰੱਖੀਏ:
ਇਹ ਵਰਣਨ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕਿ ਇੱਕ ਬਲਾਕ ਕਿਹੋ ਜਿਹਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਅਸੀਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਇੱਕ ਬਲਾਕਚੈਨ ਕਿਹੋ ਜਿਹਾ ਦਿਖਾਈ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਤਾਂ ਆਓ ਇੱਕ ਨਵੀਂ ਕਲਾਸ ਬਣਾਈਏ।
ਇਸ ਦ੍ਰਿਸ਼ ਵਿੱਚ, ਬਲਾਕਚੈਨ ਇੱਕ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਵਸਤੂ ਹੈ ਜਿਸਦੀ ਇੱਕ ਜਾਇਦਾਦ ਲੜੀ ਹੈ। ਇਹ ਲੜੀ ਦੇ ਸਾਰੇ ਬਲਾਕਾਂ ਨੂੰ ਰੱਖਣ ਵਾਲੀ ਇੱਕ ਐਰੇ ਹੈ।
ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਬਲਾਕ ਜੋੜ ਸਕੀਏ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਉਸ ਚੀਜ਼ ਨੂੰ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸਨੂੰ "ਉਤਪਤ ਬਲਾਕ" ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਚੇਨ ਵਿੱਚ ਪਹਿਲਾ ਬਲਾਕ ਹੈ, ਅਤੇ ਇਹ ਵਿਲੱਖਣ ਹੈ ਕਿ ਇਹ ਕਿਸੇ ਪੁਰਾਣੇ ਬਲਾਕ ਵੱਲ ਇਸ਼ਾਰਾ ਨਹੀਂ ਕਰ ਸਕਦਾ (ਇਹ ਪਹਿਲਾ ਹੈ!)
ਇਸ ਲਈ, ਜੈਨੇਸਿਸ ਬਲਾਕ ਬਣਾਉਣ ਲਈ, ਮੈਂ createGenesisBlock () ਨਾਮਕ ਸਾਡੀ ਕਲਾਸ ਵਿੱਚ ਇੱਕ ਫੰਕਸ਼ਨ ਜੋੜਾਂਗਾ। ਸਾਡੀ ਬਲਾਕਚੈਨ ਕਲਾਸ ਦੇ ਫੰਕਸ਼ਨ Object() { [ਨੇਟਿਵ ਕੋਡ] } ਵਿੱਚ ਵਾਪਸ।
ਜਦੋਂ ਵੀ ਅਸੀਂ ਇੱਕ ਨਵਾਂ ਬਲਾਕਚੈਨ ਉਦਾਹਰਨ ਬਣਾਉਂਦੇ ਹਾਂ ਤਾਂ ਅਸੀਂ ਹੁਣ ਜੈਨੇਸਿਸ ਬਲਾਕ ਨੂੰ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹਾਂ:
ਬਲਾਕਚੈਨ ਢੰਗ
ਹੁਣ, ਆਓ ਸਾਡੀ ਬਲਾਕਚੈਨ ਕਲਾਸ ਵਿੱਚ ਵਿਧੀਆਂ ਜੋੜੀਏ ਜੋ ਸਾਨੂੰ ਨਵੇਂ ਬਲਾਕ ਜੋੜਨ ਅਤੇ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਬਲਾਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਰਗੀਆਂ ਚੀਜ਼ਾਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗੀ।
getLatestBlock ਫੰਕਸ਼ਨ ਸਭ ਤੋਂ ਬੁਨਿਆਦੀ ਹੈ। ਇਹ ਬਸ ਚੇਨ ਐਰੇ ਦੇ ਅੰਤਮ ਮੈਂਬਰ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ:
ਐਡਬਲਾਕ ਤਕਨੀਕ ਥੋੜੀ ਹੋਰ ਸ਼ਾਮਲ ਹੈ।
ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਅਸੀਂ ਆਪਣੀ ਚੇਨ ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਬਲਾਕ ਜੋੜ ਸਕੀਏ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਉਸ ਬਲਾਕ ਦੇ ਪਿਛਲੇ ਹੈਸ਼ ਫੀਲਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੈੱਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਇਹ ਸਾਡੀ ਚੇਨ ਵਿੱਚ ਸਭ ਤੋਂ ਹਾਲ ਹੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਬਲਾਕ ਦੇ ਹੈਸ਼ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਸਾਨੂੰ ਨਵੇਂ ਬਲਾਕ ਦੇ ਹੈਸ਼ ਦੀ ਗਣਨਾ ਕਰਨ ਦੀ ਵੀ ਲੋੜ ਹੈ:
ਟੈਸਟਿੰਗ
ਆਓ ਦੇਖੀਏ ਕਿ ਸਾਡਾ MelodyCoin ਕਿਵੇਂ ਬਾਹਰ ਆਇਆ ਹੈ।
ਇਸ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਇੱਕ ਬਲਾਕਚੈਨ ਉਦਾਹਰਣ ਬਣਾਓ। ਆਓ ਕੁਝ ਹੋਰ ਬਲਾਕ ਜੋੜੀਏ:
ਅਸੀਂ ਉੱਥੇ ਦੋ ਨਵੇਂ ਬਲਾਕ ਬਣਾਏ ਹਨ। ਆਓ ਇੱਕ ਝਾਤ ਮਾਰੀਏ ਕਿ ਸਾਡਾ ਬਲਾਕਚੈਨ ਵਰਤਮਾਨ ਵਿੱਚ ਕਿਹੋ ਜਿਹਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।
MelodyCoin ਨੂੰ ਚਾਰ ਸਪੇਸਾਂ ਨਾਲ ਸਟ੍ਰਿੰਗਾਈਫਾਈਡ ਅਤੇ ਫਾਰਮੈਟ ਕੀਤਾ ਜਾਵੇਗਾ:
ਬਲਾਕਚੈਨ ਦੀ ਇਕਸਾਰਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ
ਬਲਾਕਚੈਨ ਸ਼ਾਨਦਾਰ ਹਨ ਕਿਉਂਕਿ ਇੱਕ ਵਾਰ ਇੱਕ ਬਲਾਕ ਜੋੜਿਆ ਗਿਆ ਹੈ, ਇਸ ਨੂੰ ਚੇਨ ਦੇ ਬਾਕੀ ਹਿੱਸੇ ਨੂੰ ਅਯੋਗ ਕੀਤੇ ਬਿਨਾਂ ਸੋਧਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਹੈ।
ਹਾਲਾਂਕਿ, ਇਸ ਲਾਗੂ ਕਰਨ ਦੇ ਨਾਲ ਸਾਡੇ ਬਲਾਕਚੈਨ ਦੀ ਇਕਸਾਰਤਾ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਮੇਰੇ ਲਈ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ.
ਆਉ ਸਾਡੇ ਬਲਾਕਚੈਨ ਲਈ ਇੱਕ isChainValid ਫੰਕਸ਼ਨ ਪੇਸ਼ ਕਰੀਏ। ਜੇ ਚੇਨ ਜਾਇਜ਼ ਹੈ, ਤਾਂ ਇਹ ਸੱਚੀ ਵਾਪਸ ਆ ਜਾਵੇਗੀ; ਨਹੀਂ ਤਾਂ, ਇਹ ਗਲਤ ਵਾਪਸ ਆ ਜਾਵੇਗਾ:
ਟੈਸਟਿੰਗ ਇਮਾਨਦਾਰੀ
ਅਸੀਂ ਹੁਣ ਆਪਣੀ ਬਲਾਕਚੈਨ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਟੈਸਟ ਲਈ ਪਾ ਸਕਦੇ ਹਾਂ। ਜੇਕਰ ਅਸੀਂ ਇਸਨੂੰ ਹੁਣੇ ਚਲਾਉਂਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਪੁਸ਼ਟੀ ਕਰੇਗਾ ਕਿ ਸਾਡੀ ਲੜੀ ਅਸਲੀ ਹੈ।
ਆਓ ਹੁਣ ਆਪਣੇ ਬਲਾਕਚੈਨ ਨਾਲ ਛੇੜਛਾੜ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ। ਆਓ ਬਲਾਕ 2 ਨੂੰ ਬਦਲੀਏ ਅਤੇ ਇਸਦੀ ਸਮੱਗਰੀ ਨੂੰ ਓਵਰਰਾਈਟ ਕਰੀਏ (ਆਓ ਮੰਨ ਲਓ ਅਸੀਂ ਚਾਰ ਦੀ ਬਜਾਏ 100 ਸਿੱਕੇ ਟ੍ਰਾਂਸਫਰ ਕੀਤੇ ਹਨ)।
ਜਦੋਂ ਅਸੀਂ ਇਸਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਾਂ, ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਸੌਫਟਵੇਅਰ ਚੇਨ ਨਾਲ ਛੇੜਛਾੜ ਕਰਨ ਦੀ ਸਾਡੀ ਕੋਸ਼ਿਸ਼ ਨੂੰ ਪਛਾਣਦਾ ਹੈ।
ਹਾਲਾਂਕਿ, ਤੁਸੀਂ ਵਿਸ਼ਵਾਸ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਮੇਰੇ ਕੋਲ ਇਸ ਨਾਲ ਦਖਲ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਹੈ. ਮੈਂ ਬਲਾਕ ਵਿੱਚ ਸਮੱਗਰੀ ਨੂੰ ਬਦਲਿਆ ਪਰ ਹੈਸ਼ ਦੀ ਮੁੜ ਗਣਨਾ ਨਹੀਂ ਕੀਤੀ। ਇਸ ਲਈ ਤੁਸੀਂ ਹੁਸ਼ਿਆਰ ਹੋਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਉਸੇ ਬਲਾਕ ਦੇ ਹੈਸ਼ ਦੀ ਮੁੜ ਗਣਨਾ ਕਰ ਸਕਦੇ ਹੋ.
ਸਾਡੇ ਛੋਟੇ ਬਲਾਕਚੈਨ ਸੈੱਟਅੱਪ ਲਈ ਇਹ ਸਭ ਕੁਝ ਸੀ! ਇਹ ਸਾਨੂੰ ਨਵੇਂ ਬਲਾਕ ਜੋੜਨ ਅਤੇ ਚੇਨ ਦੇ ਅੰਦਰ ਡੇਟਾ ਨਾਲ ਛੇੜਛਾੜ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।
ਸਾਡੇ ਛੋਟੇ ਬਲਾਕਚੈਨ ਨਾਲ ਦੋ ਮੁੱਦੇ ਹਨ ਜੋ ਸਾਨੂੰ ਹੱਲ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ:
- ਆਧੁਨਿਕ ਕੰਪਿਊਟਰ ਬਹੁਤ ਤੇਜ਼ ਹਨ ਅਤੇ ਸਕਿੰਟਾਂ ਵਿੱਚ ਸਾਡੀ ਲੜੀ ਵਿੱਚ ਹਜ਼ਾਰਾਂ ਬਲਾਕ ਜੋੜ ਸਕਦੇ ਹਨ। ਅਸੀਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਨਹੀਂ ਚਾਹੁੰਦੇ ਕਿ ਕੋਈ ਵੀ ਸਾਡੇ ਬਲਾਕਚੈਨ ਨੂੰ ਸਪੈਮਿੰਗ ਕਰੇ।
- ਸਾਡਾ ਬਲਾਕਚੈਨ ਅਜੇ ਵੀ ਛੇੜਛਾੜ ਲਈ ਕਮਜ਼ੋਰ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਬਲਾਕ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਅਪਡੇਟ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਫਿਰ ਹੇਠਾਂ ਦਿੱਤੇ ਸਾਰੇ ਬਲਾਕਾਂ ਲਈ ਹੈਸ਼ਾਂ (ਅਤੇ ਪੁਰਾਣੇ ਹੈਸ਼ਾਂ) ਦੀ ਮੁੜ ਗਣਨਾ ਕਰ ਸਕਦੇ ਹੋ। ਭਾਵੇਂ ਤੁਸੀਂ ਇਸ ਨਾਲ ਗੜਬੜ ਕਰਦੇ ਹੋ, ਤੁਸੀਂ ਇੱਕ ਜਾਇਜ਼ ਚੇਨ ਦੇ ਨਾਲ ਖਤਮ ਹੋਵੋਗੇ.
ਇਹਨਾਂ ਚਿੰਤਾਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਬਲਾਕਚੈਨ ਇੱਕ ਤਕਨੀਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਜਿਸਨੂੰ "ਕੰਮ ਦਾ ਸਬੂਤ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਇਹ ਦਿਖਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇਸ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਬਲਾਕ ਬਣਾਉਣ ਲਈ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਮਾਤਰਾ ਵਿੱਚ ਗਣਨਾਤਮਕ ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ। ਇਸ ਨੂੰ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਮਾਈਨਿੰਗ.
ਕੰਮ ਦੇ ਸਬੂਤ ਦੀ ਲੋੜ ਹੈ ਕਿ ਇੱਕ ਬਲਾਕ ਦੀ ਹੈਸ਼ ਇੱਕ ਖਾਸ ਮਾਤਰਾ ਵਿੱਚ ਜ਼ੀਰੋ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ। ਪਰ ਤੁਸੀਂ ਕਿਵੇਂ ਜਾਣ ਸਕਦੇ ਹੋ ਕਿ ਕੀ ਤੁਹਾਡਾ ਹੈਸ਼ ਇਸ ਨਿਯਮ ਨੂੰ ਫਿੱਟ ਕਰਦਾ ਹੈ?
ਇੱਕ ਬਲਾਕ ਦੀ ਸਮੱਗਰੀ ਇਸਦੇ ਹੈਸ਼ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਹਮੇਸ਼ਾ ਉਹੀ ਹੈਸ਼ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ, ਬਸ਼ਰਤੇ ਅਸੀਂ ਸਮੱਗਰੀ ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਨਾ ਕਰੀਏ।
ਹਰ ਇੱਕ ਬਲਾਕ ਨੂੰ ਇੱਕ ਹੱਲ ਵਜੋਂ ਇਸ ਵਿੱਚ ਇੱਕ ਗੈਰ-ਮੁੱਲ ਜੋੜਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਕੁਝ ਬੇਤਰਤੀਬ ਡੇਟਾ ਹੈ ਜੋ ਅਸੀਂ ਉਦੋਂ ਤੱਕ ਅੱਪਡੇਟ ਕਰ ਸਕਦੇ ਹਾਂ ਜਦੋਂ ਤੱਕ ਸਾਡੇ ਬਲਾਕ ਦਾ ਹੈਸ਼ ਕਾਫ਼ੀ ਜ਼ੀਰੋ ਨਾਲ ਸ਼ੁਰੂ ਨਹੀਂ ਹੁੰਦਾ ਹੈ। ਕਿਉਂਕਿ ਤੁਸੀਂ ਹੈਸ਼ ਫੰਕਸ਼ਨ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਬਦਲ ਨਹੀਂ ਸਕਦੇ, ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੇ ਵੱਖ-ਵੱਖ ਸੰਜੋਗਾਂ ਦੀ ਜਾਂਚ ਕਰਨੀ ਪਵੇਗੀ ਅਤੇ ਸਭ ਤੋਂ ਵਧੀਆ ਦੀ ਉਮੀਦ ਕਰਨੀ ਪਵੇਗੀ।
ਬਲਾਕਚੈਨ ਵਿੱਚ ਮਾਈਨਿੰਗ ਨੂੰ ਪੇਸ਼ ਕਰੋ
ਆਉ ਆਪਣੀ ਬਲਾਕ ਕਲਾਸ ਵਿੱਚ ਇੱਕ ਨਾਸ ਸ਼ਾਮਲ ਕਰਕੇ ਸ਼ੁਰੂਆਤ ਕਰੀਏ। nonce ਸਾਡੇ ਬਲਾਕ ਦੇ ਅੰਦਰ ਇੱਕ ਸਿੰਗਲ ਮੁੱਲ ਹੈ ਜਿਸਨੂੰ ਅਸੀਂ ਬਲਾਕ ਦੇ ਹੈਸ਼ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਨ ਲਈ ਸੋਧ ਸਕਦੇ ਹਾਂ।
ਅਸੀਂ ਟਾਈਮਸਟੈਂਪ ਜਾਂ ਡੇਟਾ ਨੂੰ ਬਦਲਣ ਵਿੱਚ ਅਸਮਰੱਥ ਹਾਂ।
ਅੱਗੇ, ਆਓ ਇੱਕ mineBlock() ਫੰਕਸ਼ਨ ਲਿਖੀਏ ਜੋ ਇੱਕ ਬਲਾਕ ਦੀ ਅਸਲ ਮਾਈਨਿੰਗ ਕਰੇਗਾ। ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ 'ਤੇ ਲੋੜੀਂਦੀ ਮੁਸ਼ਕਲ ਭੇਜੀ ਜਾਵੇਗੀ ਅਤੇ ਉਦੋਂ ਤੱਕ ਲਾਗੂ ਕਰਨਾ ਜਾਰੀ ਰਹੇਗਾ ਜਦੋਂ ਤੱਕ ਸਾਡੇ ਬਲਾਕ ਦਾ ਹੈਸ਼ ਕਾਫ਼ੀ ਜ਼ੀਰੋ ਨਾਲ ਸ਼ੁਰੂ ਨਹੀਂ ਹੁੰਦਾ।
ਮੈਂ ਹੁਣੇ ਇੱਕ ਬੇਸਿਕ ਜਦਕਿ ਲੂਪ ਬਣਾਇਆ ਹੈ ਜੋ ਉਦੋਂ ਤੱਕ ਚੱਲੇਗਾ ਜਦੋਂ ਤੱਕ ਸਾਡਾ ਹੈਸ਼ ਕਾਫ਼ੀ ਜ਼ੀਰੋ ਨਾਲ ਸ਼ੁਰੂ ਨਹੀਂ ਹੁੰਦਾ। ਅਸੀਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਮੁਸ਼ਕਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਕਿ ਕਿੰਨੇ ਜ਼ੀਰੋ ਦੀ ਲੋੜ ਹੈ। 5 ਦੀ ਮੁਸ਼ਕਲ ਨਾਲ, ਸਾਡੀ ਹੈਸ਼ 5 ਜ਼ੀਰੋ ਨਾਲ ਸ਼ੁਰੂ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।
ਜਦੋਂ ਸਾਡੀ ਹੈਸ਼ ਵਿੱਚ ਲੋੜੀਂਦੇ ਜ਼ੀਰੋ ਨਹੀਂ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਅਸੀਂ ਨੋਂਸ ਨੂੰ ਇੱਕ ਨਾਲ ਵਧਾਉਂਦੇ ਹਾਂ ਅਤੇ ਹੈਸ਼ ਦੀ ਮੁੜ ਗਣਨਾ ਕਰਦੇ ਹਾਂ। ਅਤੇ ਜੇਕਰ ਸਾਨੂੰ ਇੱਕ ਹੈਸ਼ ਮਿਲਦਾ ਹੈ ਜੋ ਮੁਸ਼ਕਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸਨੂੰ ਕੰਸੋਲ ਵਿੱਚ ਲੌਗ ਕਰਦੇ ਹਾਂ।
ਸਾਨੂੰ ਇੱਕ ਹੋਰ ਚੀਜ਼ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਸਾਡੇ ਕੈਲਕੂਲੇਟ ਹੈਸ਼ ਵਿਧੀ ਵਿੱਚ ਗੈਰ-ਵੇਰੀਏਬਲ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਨਹੀਂ ਰੱਖਦੇ, ਇਸ ਲਈ ਇਹ ਇੱਥੇ ਹੈ:
ਬਲਾਕਚੈਨ ਕਲਾਸ
ਆਉ ਸਾਡੀ ਬਲਾਕਚੈਨ ਕਲਾਸ ਵਿੱਚ ਟੈਸਟ ਲਈ ਇਸ ਨਵੀਂ ਪਹੁੰਚ ਨੂੰ ਪਾਉਂਦੇ ਹਾਂ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਇਹ ਕਿਵੇਂ ਚਲਦਾ ਹੈ।
ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਮੈਂ ਫੰਕਸ਼ਨ ਆਬਜੈਕਟ() ਵਿੱਚ ਸਾਡੇ ਬਲਾਕਚੈਨ ਦੀ ਮੁਸ਼ਕਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗਾ। ਅਸੀਂ ਇਸਨੂੰ ਇੱਥੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ ਕਿਉਂਕਿ ਅਸੀਂ ਇਸਨੂੰ ਬਾਅਦ ਵਿੱਚ ਕਿਤੇ ਵੀ ਵਰਤ ਸਕਦੇ ਹਾਂ।
ਐਡਬਲਾਕ ਫੰਕਸ਼ਨ ਨੂੰ ਫਿਰ ਇਸ ਤਰ੍ਹਾਂ ਸੋਧਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇਹ ਸਾਡੀ ਚੇਨ ਵਿੱਚ ਜੋੜਨ ਤੋਂ ਪਹਿਲਾਂ ਬਲਾਕ ਨੂੰ ਮਾਈਨ ਕਰਦਾ ਹੈ।
ਬਲਾਕਚੈਨ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਹੁਣ, ਆਓ ਆਪਣੇ ਨਵੇਂ ਬਲਾਕਚੈਨ ਨੂੰ ਕੰਮ ਦੇ ਸਬੂਤ ਦੇ ਐਲਗੋਰਿਦਮ ਨਾਲ ਵਰਤਣ ਲਈ ਰੱਖੀਏ। ਇੱਥੇ, ਕੁਝ console.log ਸਟੇਟਮੈਂਟਾਂ ਸ਼ਾਮਲ ਕਰੋ।
ਜਦੋਂ ਅਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਾਂ, ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਮਾਈਨਿੰਗ ਪ੍ਰਕਿਰਿਆ ਹੁਣ ਖਾਸ ਤੌਰ 'ਤੇ ਤੇਜ਼ ਨਹੀਂ ਹੈ।
ਐਲਗੋਰਿਦਮ ਨੂੰ ਹੈਸ਼ਾਂ ਦੇ ਨਾਲ ਬਲਾਕ ਬਣਾਉਣ ਵਿੱਚ ਕੁਝ ਸਮਾਂ ਲੱਗਦਾ ਹੈ ਜੋ ਤਿੰਨ ਜ਼ੀਰੋ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ (ਜਿਵੇਂ ਕਿ ਮੁਸ਼ਕਲ ਦੁਆਰਾ ਸੰਰਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ)।
ਇਸ ਲਈ ਇਹ ਸਾਡੇ ਮੂਲ ਬਲਾਕਚੈਨ ਸੈਟਅਪ ਦਾ ਅੰਤ ਸੀ.
ਅਸੀਂ ਨਿਯੰਤ੍ਰਿਤ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਸਾਡੇ ਬਲਾਕਚੈਨ ਵਿੱਚ ਨਵੇਂ ਬਲਾਕ ਕਿੰਨੀ ਤੇਜ਼ੀ ਨਾਲ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਪਰੂਫ-ਆਫ-ਵਰਕ ਵਿਧੀ ਦਾ ਧੰਨਵਾਦ।
ਬਲਾਕਚੈਨ 'ਤੇ ਇਹ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਸੁਰੱਖਿਆ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ। ਅਤੇ ਹੁਣ ਜਦੋਂ ਤੁਸੀਂ ਸਮਝ ਗਏ ਹੋ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਤਾਂ ਆਪਣੀ ਖੁਦ ਦੀ ਰਚਨਾ ਕਰੋ!
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ