ਬਲਾਕਚੈਨ: ਸਾਨੂੰ ਕਿਹੜਾ ਪੀਓਸੀ ਬਣਾਉਣਾ ਚਾਹੀਦਾ ਹੈ?

ਤੁਹਾਡੀਆਂ ਅੱਖਾਂ ਡਰ ਰਹੀਆਂ ਹਨ ਅਤੇ ਤੁਹਾਡੇ ਹੱਥ ਖੁਜ ਰਹੇ ਹਨ!

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

ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ - ਇੱਕ ਯੂਨੀਵਰਸਲ ਬਲਾਕਚੇਨ

ਆਮ ਤੌਰ 'ਤੇ, ਇੱਕ ਵਿਆਪਕ ਜਾਣਕਾਰੀ ਪ੍ਰਣਾਲੀ ਹੈ:

• ਸਰਵਰਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਅਤੇ ਇੱਕ ਸੌਫਟਵੇਅਰ ਕੋਰ ਜੋ ਵਪਾਰਕ ਤਰਕ ਕਰਦਾ ਹੈ;
• ਸਿਸਟਮ ਨਾਲ ਇੰਟਰਫੇਸ ਲਈ ਇੰਟਰਫੇਸ;
• ਡਿਵਾਈਸਾਂ/ਲੋਕਾਂ ਦੀ ਰਜਿਸਟ੍ਰੇਸ਼ਨ, ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਟੂਲ;
• ਡਾਟਾਬੇਸ ਸੰਚਾਲਨ ਅਤੇ ਪੁਰਾਲੇਖ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨਾ:

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

ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ ਆਰਕੀਟੈਕਚਰ

ਚਿੱਤਰ ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ:

ਸੰਗਠਨ — ਸੰਗਠਨਾਂ ਵਿੱਚ ਸਾਥੀ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਬਲਾਕਚੈਨ ਸੰਸਥਾਵਾਂ ਦੇ ਸਮਰਥਨ ਕਾਰਨ ਮੌਜੂਦ ਹੈ। ਵੱਖ-ਵੱਖ ਸੰਸਥਾਵਾਂ ਇੱਕੋ ਚੈਨਲ ਦਾ ਹਿੱਸਾ ਹੋ ਸਕਦੀਆਂ ਹਨ।

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

ਮੈਂਬਰਸ਼ਿਪ ਸਰਵਿਸ ਪ੍ਰੋਵਾਈਡਰ (MSP) ਪਛਾਣ ਜਾਰੀ ਕਰਨ ਅਤੇ ਭੂਮਿਕਾਵਾਂ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਇੱਕ CA (ਸਰਟੀਫਿਕੇਟ ਅਥਾਰਟੀ) ਹੈ। ਇੱਕ ਨੋਡ ਬਣਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ MSP ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

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

• ਪੀਅਰ ਸ਼ਾਇਦ ਸਾਥੀ ਦਾ ਸਮਰਥਨ (EP) ਅਤੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਨੂੰ ਲਾਗੂ ਕਰੋ।
• ਵਚਨਬੱਧ ਸਾਥੀ (CP) - ਸਿਰਫ ਬਲਾਕਚੈਨ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ ਅਤੇ "ਵਰਲਡ ਸਟੇਟ" ਨੂੰ ਅਪਡੇਟ ਕਰੋ।
• ਐਂਕਰ ਪੀਰ (ਏਪੀ) - ਜੇ ਕਈ ਸੰਸਥਾਵਾਂ ਬਲਾਕਚੈਨ ਵਿੱਚ ਹਿੱਸਾ ਲੈਂਦੀਆਂ ਹਨ, ਤਾਂ ਉਹਨਾਂ ਵਿਚਕਾਰ ਸੰਚਾਰ ਲਈ ਐਂਕਰ ਸਾਥੀਆਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਹਰੇਕ ਸੰਸਥਾ ਦੇ ਇੱਕ ਜਾਂ ਵੱਧ ਐਂਕਰ ਸਾਥੀ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। AP ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਕਿਸੇ ਸੰਸਥਾ ਵਿੱਚ ਕੋਈ ਵੀ ਪੀਅਰ ਦੂਜੀਆਂ ਸੰਸਥਾਵਾਂ ਵਿੱਚ ਸਾਰੇ ਸਾਥੀਆਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ। APs ਵਿਚਕਾਰ ਜਾਣਕਾਰੀ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਗੱਪਸ਼ਪ ਪ੍ਰੋਟੋਕੋਲ.
• ਆਗੂ ਪੀਰ - ਜੇਕਰ ਕਿਸੇ ਸੰਗਠਨ ਦੇ ਕਈ ਸਾਥੀ ਹਨ, ਤਾਂ ਸਿਰਫ ਪੀਅਰ ਦੇ ਨੇਤਾ ਨੂੰ ਆਰਡਰਿੰਗ ਸੇਵਾ ਤੋਂ ਬਲਾਕ ਪ੍ਰਾਪਤ ਹੋਣਗੇ ਅਤੇ ਬਾਕੀ ਸਾਥੀਆਂ ਨੂੰ ਦੇਣਗੇ। ਲੀਡਰ ਨੂੰ ਜਾਂ ਤਾਂ ਸਥਿਰ ਤੌਰ 'ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ ਸੰਗਠਨ ਦੇ ਸਾਥੀਆਂ ਦੁਆਰਾ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਚੁਣਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਗੌਸਿਪ ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਵਰਤੋਂ ਨੇਤਾਵਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਵੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

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

ਲੇਜ਼ਰ - ਬਲਾਕਚੈਨ ਅਤੇ ਵਰਡ ਸਟੇਟ ਡੇਟਾਬੇਸ ਦੇ ਸ਼ਾਮਲ ਹਨ, ਜੋ ਮੌਜੂਦਾ ਸੰਪਤੀਆਂ ਦੀ ਸਥਿਤੀ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਵਿਸ਼ਵ ਰਾਜ LevelDB ਜਾਂ CouchDB ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

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

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

• ਲੈਣ-ਦੇਣ ਨੂੰ ਸੰਸਥਾ ਦੇ ਕਿਸੇ ਵੀ ਪ੍ਰਬੰਧਕ ਦੁਆਰਾ ਮਨਜ਼ੂਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ;
• ਸੰਸਥਾ ਦੇ ਕਿਸੇ ਵੀ ਮੈਂਬਰ ਜਾਂ ਕਲਾਇੰਟ ਦੁਆਰਾ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ;
• ਕਿਸੇ ਵੀ ਪੀਅਰ ਸੰਸਥਾ ਦੁਆਰਾ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ.

ਆਰਡਰਿੰਗ ਸੇਵਾ - ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਨੂੰ ਬਲਾਕਾਂ ਵਿੱਚ ਪੈਕ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਚੈਨਲ ਵਿੱਚ ਸਾਥੀਆਂ ਨੂੰ ਭੇਜਦਾ ਹੈ। ਨੈੱਟਵਰਕ 'ਤੇ ਸਾਰੇ ਸਾਥੀਆਂ ਨੂੰ ਸੰਦੇਸ਼ਾਂ ਦੀ ਡਿਲੀਵਰੀ ਦੀ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ। ਉਦਯੋਗਿਕ ਪ੍ਰਣਾਲੀਆਂ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਾਫਕਾ ਸੁਨੇਹਾ ਦਲਾਲ, ਵਿਕਾਸ ਅਤੇ ਜਾਂਚ ਲਈ Solo.

ਕਾਲਫਲੋ

• ਐਪਲੀਕੇਸ਼ਨ Go, Node.js ਜਾਂ Java SDK ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ ਨਾਲ ਸੰਚਾਰ ਕਰਦੀ ਹੈ;
• ਕਲਾਇੰਟ ਇੱਕ tx ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਮਰਥਨ ਕਰਨ ਵਾਲੇ ਸਾਥੀਆਂ ਨੂੰ ਭੇਜਦਾ ਹੈ;
• ਪੀਅਰ ਗਾਹਕ ਦੇ ਦਸਤਖਤ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ, ਲੈਣ-ਦੇਣ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ, ਅਤੇ ਗਾਹਕ ਨੂੰ ਸਮਰਥਨ ਦਸਤਖਤ ਵਾਪਸ ਭੇਜਦਾ ਹੈ। ਚੇਨਕੋਡ ਨੂੰ ਸਿਰਫ਼ ਸਮਰਥਨ ਕਰਨ ਵਾਲੇ ਪੀਅਰ 'ਤੇ ਹੀ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਦੇ ਲਾਗੂ ਹੋਣ ਦਾ ਨਤੀਜਾ ਸਾਰੇ ਸਾਥੀਆਂ ਨੂੰ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ। ਕੰਮ ਦੇ ਇਸ ਐਲਗੋਰਿਦਮ ਨੂੰ PBFT (ਪ੍ਰੈਕਟੀਕਲ ਬਿਜ਼ੈਂਟਾਈਨ ਫਾਲਟ ਟੋਲਰੈਂਟ) ਸਹਿਮਤੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਤੋਂ ਵੱਖਰਾ ਹੈ ਕਲਾਸਿਕ BFT ਇਹ ਤੱਥ ਕਿ ਸੁਨੇਹਾ ਭੇਜਿਆ ਗਿਆ ਹੈ ਅਤੇ ਪੁਸ਼ਟੀ ਸਾਰੇ ਭਾਗੀਦਾਰਾਂ ਤੋਂ ਨਹੀਂ, ਪਰ ਸਿਰਫ ਇੱਕ ਖਾਸ ਸਮੂਹ ਤੋਂ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ;
• ਗਾਹਕ ਨੂੰ ਸਮਰਥਨ ਨੀਤੀ ਦੇ ਅਨੁਸਾਰੀ ਜਵਾਬਾਂ ਦੀ ਸੰਖਿਆ ਪ੍ਰਾਪਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਉਹ ਆਰਡਰਿੰਗ ਸੇਵਾ ਨੂੰ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਭੇਜਦਾ ਹੈ;
• ਆਰਡਰਿੰਗ ਸੇਵਾ ਇੱਕ ਬਲਾਕ ਤਿਆਰ ਕਰਦੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਾਰੇ ਪ੍ਰਤੀਬੱਧ ਸਾਥੀਆਂ ਨੂੰ ਭੇਜਦੀ ਹੈ। ਆਰਡਰਿੰਗ ਸੇਵਾ ਬਲਾਕਾਂ ਦੀ ਕ੍ਰਮਵਾਰ ਰਿਕਾਰਡਿੰਗ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ, ਜੋ ਅਖੌਤੀ ਲੇਜ਼ਰ ਫੋਰਕ (ਭਾਗ "ਫੋਰਕਸ" ਵੇਖੋ);
• ਸਾਥੀਆਂ ਨੂੰ ਇੱਕ ਬਲਾਕ ਮਿਲਦਾ ਹੈ, ਸਮਰਥਨ ਨੀਤੀ ਦੀ ਦੁਬਾਰਾ ਜਾਂਚ ਕਰੋ, ਬਲਾਕਚੈਨ ਨੂੰ ਬਲਾਕ ਲਿਖੋ ਅਤੇ "ਵਿਸ਼ਵ ਰਾਜ" DB ਵਿੱਚ ਰਾਜ ਬਦਲੋ।

ਉਹ. ਇਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਨੋਡਾਂ ਵਿਚਕਾਰ ਭੂਮਿਕਾਵਾਂ ਦੀ ਵੰਡ ਹੁੰਦੀ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਬਲਾਕਚੈਨ ਸਕੇਲੇਬਲ ਅਤੇ ਸੁਰੱਖਿਅਤ ਹੈ:

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

ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ ਦੇ ਆਰਕੀਟੈਕਚਰਲ ਹੱਲਾਂ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ ਅਤੇ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਕਿਉਂ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਨਹੀਂ ਤਾਂ ਇੱਥੇ ਲੱਭਿਆ ਜਾ ਸਕਦਾ ਹੈ: ਆਰਕੀਟੈਕਚਰ ਮੂਲ ਜਾਂ ਇੱਥੇ: ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ: ਆਗਿਆ ਪ੍ਰਾਪਤ ਬਲਾਕਚੈਨ ਲਈ ਇੱਕ ਵੰਡਿਆ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ.

ਇਸ ਲਈ, ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ ਸੱਚਮੁੱਚ ਇੱਕ ਵਿਆਪਕ ਪ੍ਰਣਾਲੀ ਹੈ ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਇਹ ਕਰ ਸਕਦੇ ਹੋ:

• ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਪਹੁਦਰੇ ਵਪਾਰਕ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰੋ;
• JSON ਫਾਰਮੈਟ ਵਿੱਚ ਬਲਾਕਚੈਨ ਡੇਟਾਬੇਸ ਤੋਂ ਡਾਟਾ ਰਿਕਾਰਡ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰੋ;
• ਸਰਟੀਫਿਕੇਟ ਅਥਾਰਟੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ API ਪਹੁੰਚ ਦਿਓ ਅਤੇ ਪੁਸ਼ਟੀ ਕਰੋ।

ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ ਥੋੜਾ ਜਿਹਾ ਸਮਝ ਗਏ ਹਾਂ, ਆਓ ਅੰਤ ਵਿੱਚ ਕੁਝ ਲਾਭਦਾਇਕ ਕਰੀਏ!

ਬਲਾਕਚੈਨ ਨੂੰ ਤੈਨਾਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਸਮੱਸਿਆ ਦਾ ਗਠਨ

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

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

IBM ਕਲਾਊਡ

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

• ਬਲਾਕਚੈਨ ਪਲੇਟਫਾਰਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਬੁਨਿਆਦੀ ਬਲਾਕਚੈਨ ਨੈੱਟਵਰਕ ਬਣਾਓ
• ਇੱਕ ਬਲਾਕਚੈਨ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਬਣਾਓ ਅਤੇ ਲਾਗੂ ਕਰੋ
• ਬਲਾਕਚੈਨ ਪਲੇਟਫਾਰਮ ਤੋਂ ਇਵੈਂਟਸ ਕੱਢੋ

ਹੇਠਾਂ IBM ਬਲਾਕਚੈਨ ਪਲੇਟਫਾਰਮ ਦੇ ਸਕ੍ਰੀਨਸ਼ੌਟਸ ਹਨ। ਇਹ ਬਲਾਕਚੈਨ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ ਇਸ ਬਾਰੇ ਕੋਈ ਹਦਾਇਤ ਨਹੀਂ ਹੈ, ਪਰ ਕੰਮ ਦੇ ਦਾਇਰੇ ਦਾ ਸਿਰਫ਼ ਇੱਕ ਪ੍ਰਦਰਸ਼ਨ ਹੈ। ਇਸ ਲਈ, ਸਾਡੇ ਉਦੇਸ਼ਾਂ ਲਈ, ਅਸੀਂ ਇੱਕ ਸੰਗਠਨ ਬਣਾਉਂਦੇ ਹਾਂ:

ਅਸੀਂ ਇਸ ਵਿੱਚ ਨੋਡ ਬਣਾਉਂਦੇ ਹਾਂ: ਆਰਡਰਰ CA, Org1 CA, Orderer Peer:

ਅਸੀਂ ਉਪਭੋਗਤਾ ਬਣਾਉਂਦੇ ਹਾਂ:

ਇੱਕ ਚੈਨਲ ਬਣਾਓ ਅਤੇ ਇਸਨੂੰ ਸਿਟਕੋਇਨ ਕਹੋ:

ਅਸਲ ਵਿੱਚ ਚੈਨਲ ਇੱਕ ਬਲਾਕਚੈਨ ਹੈ, ਇਸਲਈ ਇਹ ਬਲਾਕ ਜ਼ੀਰੋ (ਉਤਪਤ ਬਲਾਕ) ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ:

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

/*
 * Citcoin smart-contract v1.5 for Hyperledger Fabric
 * (c) Alexey Sushkov, 2019
 */
 
'use strict';
 
const { Contract } = require('fabric-contract-api');
const maxAccounts = 5;
 
class CitcoinEvents extends Contract {
 
    async instantiate(ctx) {
        console.info('instantiate');
        let emptyList = [];
        await ctx.stub.putState('accounts', Buffer.from(JSON.stringify(emptyList)));
    }
    // Get all accounts
    async GetAccounts(ctx) {
        // Get account list:
        let accounts = '{}'
        let accountsData = await ctx.stub.getState('accounts');
        if (accountsData) {
            accounts = JSON.parse(accountsData.toString());
        } else {
            throw new Error('accounts not found');
        }
        return accountsData.toString()
    }
     // add a account object to the blockchain state identifited by their name
    async AddAccount(ctx, name, balance) {
        // this is account data:
        let account = {
            name: name,
            balance: Number(balance),       
            type: 'account',
        };
        // create account:
        await ctx.stub.putState(name, Buffer.from(JSON.stringify(account)));
 
        // Add account to list:
        let accountsData = await ctx.stub.getState('accounts');
        if (accountsData) {
            let accounts = JSON.parse(accountsData.toString());
            if (accounts.length < maxAccounts)
            {
                accounts.push(name);
                await ctx.stub.putState('accounts', Buffer.from(JSON.stringify(accounts)));
            } else {
                throw new Error('Max accounts number reached');
            }
        } else {
            throw new Error('accounts not found');
        }
        // return  object
        return JSON.stringify(account);
    }
    // Sends money from Account to Account
    async SendFrom(ctx, fromAccount, toAccount, value) {
        // get Account from
        let fromData = await ctx.stub.getState(fromAccount);
        let from;
        if (fromData) {
            from = JSON.parse(fromData.toString());
            if (from.type !== 'account') {
                throw new Error('wrong from type');
            }   
        } else {
            throw new Error('Accout from not found');
        }
        // get Account to
        let toData = await ctx.stub.getState(toAccount);
        let to;
        if (toData) {
            to = JSON.parse(toData.toString());
            if (to.type !== 'account') {
                throw new Error('wrong to type');
            }  
        } else {
            throw new Error('Accout to not found');
        }
 
        // update the balances
        if ((from.balance - Number(value)) >= 0 ) {
            from.balance -= Number(value);
            to.balance += Number(value);
        } else {
            throw new Error('From Account: not enought balance');          
        }
 
        await ctx.stub.putState(from.name, Buffer.from(JSON.stringify(from)));
        await ctx.stub.putState(to.name, Buffer.from(JSON.stringify(to)));
                 
        // define and set Event
        let Event = {
            type: "SendFrom",
            from: from.name,
            to: to.name,
            balanceFrom: from.balance,
            balanceTo: to.balance,
            value: value
        };
        await ctx.stub.setEvent('SendFrom', Buffer.from(JSON.stringify(Event)));
 
        // return to object
        return JSON.stringify(from);
    }
 
    // get the state from key
    async GetState(ctx, key) {
        let data = await ctx.stub.getState(key);
        let jsonData = JSON.parse(data.toString());
        return JSON.stringify(jsonData);
    }
    // GetBalance   
    async GetBalance(ctx, accountName) {
        let data = await ctx.stub.getState(accountName);
        let jsonData = JSON.parse(data.toString());
        return JSON.stringify(jsonData);
    }
     
    // Refill own balance
    async RefillBalance(ctx, toAccount, value) {
        // get Account to
        let toData = await ctx.stub.getState(toAccount);
        let to;
        if (toData) {
            to = JSON.parse(toData.toString());
            if (to.type !== 'account') {
                throw new Error('wrong to type');
            }  
        } else {
            throw new Error('Accout to not found');
        }
 
        // update the balance
        to.balance += Number(value);
        await ctx.stub.putState(to.name, Buffer.from(JSON.stringify(to)));
                 
        // define and set Event
        let Event = {
            type: "RefillBalance",
            to: to.name,
            balanceTo: to.balance,
            value: value
        };
        await ctx.stub.setEvent('RefillBalance', Buffer.from(JSON.stringify(Event)));
 
        // return to object
        return JSON.stringify(from);
    }
}
module.exports = CitcoinEvents;

ਅਨੁਭਵੀ ਤੌਰ 'ਤੇ, ਇੱਥੇ ਸਭ ਕੁਝ ਸਪੱਸ਼ਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

• ਕਈ ਫੰਕਸ਼ਨ (AddAccount, GetAccounts, SendFrom, GetBalance, RefillBalance) ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਡੈਮੋ ਪ੍ਰੋਗਰਾਮ ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ API ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਾਲ ਕਰੇਗਾ।
• SendFrom ਅਤੇ RefillBalance ਫੰਕਸ਼ਨ ਇਵੈਂਟਸ ਤਿਆਰ ਕਰਦੇ ਹਨ ਜੋ ਡੈਮੋ ਪ੍ਰੋਗਰਾਮ ਪ੍ਰਾਪਤ ਕਰੇਗਾ।
• ਇੰਸਟੈਂਟੀਏਟ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਵਾਰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਇਨਸਟੈਂਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਵਾਸਤਵ ਵਿੱਚ, ਇਸਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਨਹੀਂ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਹਰ ਵਾਰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਰਜ਼ਨ ਬਦਲਦਾ ਹੈ. ਇਸ ਲਈ, ਇੱਕ ਖਾਲੀ ਐਰੇ ਨਾਲ ਇੱਕ ਸੂਚੀ ਸ਼ੁਰੂ ਕਰਨਾ ਇੱਕ ਬੁਰਾ ਵਿਚਾਰ ਹੈ, ਕਿਉਂਕਿ ਹੁਣ, ਜਦੋਂ ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਸੰਸਕਰਣ ਨੂੰ ਬਦਲਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਮੌਜੂਦਾ ਸੂਚੀ ਨੂੰ ਗੁਆ ਦੇਵਾਂਗੇ। ਪਰ ਇਹ ਠੀਕ ਹੈ, ਮੈਂ ਹੁਣੇ ਸਿੱਖ ਰਿਹਾ ਹਾਂ).
• ਖਾਤੇ ਅਤੇ ਖਾਤਿਆਂ ਦੀ ਸੂਚੀ JSON ਡੇਟਾ ਢਾਂਚੇ ਹਨ। JS ਡਾਟਾ ਹੇਰਾਫੇਰੀ ਲਈ ਵਰਤਿਆ ਗਿਆ ਹੈ.
• ਤੁਸੀਂ getState ਫੰਕਸ਼ਨ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਸੇ ਸੰਪਤੀ ਦਾ ਮੌਜੂਦਾ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਪੁਟਸਟੇਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਅੱਪਡੇਟ ਕਰ ਸਕਦੇ ਹੋ।
• ਖਾਤਾ ਬਣਾਉਂਦੇ ਸਮੇਂ, AddAccount ਫੰਕਸ਼ਨ ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਬਲਾਕਚੈਨ (maxAccounts = 5) ਵਿੱਚ ਖਾਤਿਆਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਲਈ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਤੇ ਇੱਥੇ ਇੱਕ ਜਾਮ ਹੈ (ਕੀ ਤੁਸੀਂ ਧਿਆਨ ਦਿੱਤਾ ਹੈ?), ਜਿਸ ਨਾਲ ਖਾਤਿਆਂ ਦੀ ਗਿਣਤੀ ਵਿੱਚ ਬੇਅੰਤ ਵਾਧਾ ਹੁੰਦਾ ਹੈ. ਅਜਿਹੀਆਂ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣਾ ਚਾਹੀਦਾ ਹੈ)

ਅੱਗੇ, ਅਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਚੈਨਲ ਵਿੱਚ ਲੋਡ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਤੁਰੰਤ ਬਣਾਉਂਦੇ ਹਾਂ:

ਆਉ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਥਾਪਤ ਕਰਨ ਲਈ ਲੈਣ-ਦੇਣ ਨੂੰ ਵੇਖੀਏ:

ਆਉ ਸਾਡੇ ਚੈਨਲ ਬਾਰੇ ਵੇਰਵੇ ਦੇਖੀਏ:

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

Hyperledger Fabric API ਕਾਲਾਂ ਲਈ ਇੱਕ GUI ਬਣਾਉਣਾ

ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ ਕੋਲ ਇੱਕ API ਹੈ ਜਿਸਦੀ ਵਰਤੋਂ ਇਸ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ:

• ਚੈਨਲ ਬਣਾਓ;
• ਕਨੈਕਸ਼ਨ ਪੀਅਰ ਟੂ ਚੈਨਲ;
• ਚੈਨਲ ਵਿੱਚ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੀ ਸਥਾਪਨਾ ਅਤੇ ਸ਼ੁਰੂਆਤ;
• ਕਾਲਿੰਗ ਲੈਣ-ਦੇਣ;
• ਬਲਾਕਚੈਨ ਬਾਰੇ ਜਾਣਕਾਰੀ ਲਈ ਬੇਨਤੀ ਕਰੋ।

ਐਪਲੀਕੇਸ਼ਨ ਵਿਕਾਸ

ਸਾਡੇ ਡੈਮੋ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਅਸੀਂ API ਦੀ ਵਰਤੋਂ ਸਿਰਫ ਲੈਣ-ਦੇਣ ਨੂੰ ਕਾਲ ਕਰਨ ਅਤੇ ਜਾਣਕਾਰੀ ਦੀ ਬੇਨਤੀ ਕਰਨ ਲਈ ਕਰਾਂਗੇ, ਕਿਉਂਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ IBM ਬਲਾਕਚੈਨ ਪਲੇਟਫਾਰਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬਾਕੀ ਬਚੇ ਕਦਮਾਂ ਨੂੰ ਪੂਰਾ ਕਰ ਲਿਆ ਹੈ। ਅਸੀਂ ਇੱਕ ਮਿਆਰੀ ਤਕਨਾਲੋਜੀ ਸਟੈਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ GUI ਲਿਖਦੇ ਹਾਂ: Express.js + Vue.js + Node.js. ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਇੱਕ ਵੱਖਰਾ ਲੇਖ ਲਿਖ ਸਕਦੇ ਹੋ ਕਿ ਆਧੁਨਿਕ ਵੈਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ। ਇੱਥੇ ਮੈਂ ਲੈਕਚਰਾਂ ਦੀ ਲੜੀ ਦਾ ਇੱਕ ਲਿੰਕ ਛੱਡਾਂਗਾ ਜੋ ਮੈਨੂੰ ਸਭ ਤੋਂ ਪਸੰਦ ਸੀ: Vue.js ਅਤੇ Express.js ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਪੂਰਾ ਸਟੈਕ ਵੈੱਬ ਐਪ. ਨਤੀਜਾ Google ਦੀ ਮਟੀਰੀਅਲ ਡਿਜ਼ਾਈਨ ਸ਼ੈਲੀ ਵਿੱਚ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਗ੍ਰਾਫਿਕਲ ਇੰਟਰਫੇਸ ਨਾਲ ਇੱਕ ਕਲਾਇੰਟ-ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨ ਹੈ। ਕਲਾਇੰਟ ਅਤੇ ਸਰਵਰ ਵਿਚਕਾਰ REST API ਵਿੱਚ ਕਈ ਕਾਲਾਂ ਹੁੰਦੀਆਂ ਹਨ:

• HyperledgerDemo/v1/init - ਬਲਾਕਚੈਨ ਨੂੰ ਸ਼ੁਰੂ ਕਰੋ;
• HyperledgerDemo/v1/accounts/list — ਸਾਰੇ ਖਾਤਿਆਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰੋ;
• HyperledgerDemo/v1/account?name=Bob&balance=100 — ਬੌਬ ਖਾਤਾ ਬਣਾਓ;
• HyperledgerDemo/v1/info?account=Bob — ਬੌਬ ਖਾਤੇ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰੋ;
• HyperledgerDemo/v1/transaction?from=Bob&to=Alice&volume=2 — ਬੌਬ ਤੋਂ ਐਲਿਸ ਵਿੱਚ ਦੋ ਸਿੱਕੇ ਟ੍ਰਾਂਸਫਰ ਕਰੋ;
• HyperledgerDemo/v1/ਡਿਸਕਨੈਕਟ - ਬਲਾਕਚੈਨ ਨਾਲ ਕੁਨੈਕਸ਼ਨ ਬੰਦ ਕਰੋ।

ਵਿੱਚ ਸ਼ਾਮਲ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ API ਦਾ ਵੇਰਵਾ ਪੋਸਟਮੈਨ ਵੈਬਸਾਈਟ - HTTP API ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇੱਕ ਮਸ਼ਹੂਰ ਪ੍ਰੋਗਰਾਮ।

ਐਮਾਜ਼ਾਨ ਕਲਾਉਡ ਵਿੱਚ ਡੈਮੋ ਐਪਲੀਕੇਸ਼ਨ

ਮੈਂ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਐਮਾਜ਼ਾਨ 'ਤੇ ਅਪਲੋਡ ਕੀਤਾ ਕਿਉਂਕਿ... IBM ਅਜੇ ਵੀ ਮੇਰੇ ਖਾਤੇ ਨੂੰ ਅੱਪਗ੍ਰੇਡ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੈ ਅਤੇ ਮੈਨੂੰ ਵਰਚੁਅਲ ਸਰਵਰ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦਿੰਦਾ ਹੈ। ਡੋਮੇਨ ਵਿੱਚ ਇੱਕ ਚੈਰੀ ਨੂੰ ਕਿਵੇਂ ਜੋੜਨਾ ਹੈ: www.citcoin.info. ਮੈਂ ਸਰਵਰ ਨੂੰ ਕੁਝ ਸਮੇਂ ਲਈ ਚਾਲੂ ਰੱਖਾਂਗਾ, ਫਿਰ ਇਸਨੂੰ ਬੰਦ ਕਰਾਂਗਾ, ਕਿਉਂਕਿ... ਕਿਰਾਏ ਲਈ ਸੈਂਟ ਟਪਕ ਰਹੇ ਹਨ, ਅਤੇ ਸਿਟਕੋਇਨ ਸਿੱਕੇ ਅਜੇ ਸਟਾਕ ਐਕਸਚੇਂਜ ਵਿੱਚ ਸੂਚੀਬੱਧ ਨਹੀਂ ਹਨ) ਮੈਂ ਲੇਖ ਵਿੱਚ ਡੈਮੋ ਦੇ ਸਕ੍ਰੀਨਸ਼ੌਟਸ ਸ਼ਾਮਲ ਕਰ ਰਿਹਾ ਹਾਂ ਤਾਂ ਜੋ ਕੰਮ ਦਾ ਤਰਕ ਸਪੱਸ਼ਟ ਹੋਵੇ. ਡੈਮੋ ਐਪਲੀਕੇਸ਼ਨ ਇਹ ਕਰ ਸਕਦੀ ਹੈ:

• ਬਲਾਕਚੈਨ ਸ਼ੁਰੂ ਕਰੋ;
• ਇੱਕ ਖਾਤਾ ਬਣਾਓ (ਪਰ ਹੁਣ ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ ਖਾਤਾ ਨਹੀਂ ਬਣਾ ਸਕਦੇ, ਕਿਉਂਕਿ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਨਿਰਧਾਰਤ ਖਾਤਿਆਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਬਲਾਕਚੈਨ ਵਿੱਚ ਪਹੁੰਚ ਗਈ ਹੈ);
• ਖਾਤਿਆਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰੋ;
• ਐਲਿਸ, ਬੌਬ ਅਤੇ ਐਲੇਕਸ ਵਿਚਕਾਰ ਸਿਟਕੋਇਨ ਸਿੱਕੇ ਟ੍ਰਾਂਸਫਰ ਕਰੋ;
• ਇਵੈਂਟਸ ਪ੍ਰਾਪਤ ਕਰੋ (ਪਰ ਹੁਣ ਇਵੈਂਟਸ ਨੂੰ ਦਿਖਾਉਣ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ, ਇਸਲਈ ਸਰਲਤਾ ਲਈ, ਇੰਟਰਫੇਸ ਕਹਿੰਦਾ ਹੈ ਕਿ ਇਵੈਂਟਸ ਸਮਰਥਿਤ ਨਹੀਂ ਹਨ);
• ਲੌਗ ਕਾਰਵਾਈਆਂ।

ਪਹਿਲਾਂ ਅਸੀਂ ਬਲਾਕਚੈਨ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ:

ਅੱਗੇ, ਅਸੀਂ ਆਪਣਾ ਖਾਤਾ ਬਣਾਉਂਦੇ ਹਾਂ, ਬਕਾਇਆ ਦੇ ਨਾਲ ਸਮਾਂ ਬਰਬਾਦ ਨਾ ਕਰੋ:

ਸਾਨੂੰ ਸਾਰੇ ਉਪਲਬਧ ਖਾਤਿਆਂ ਦੀ ਸੂਚੀ ਮਿਲਦੀ ਹੈ:

ਅਸੀਂ ਭੇਜਣ ਵਾਲੇ ਅਤੇ ਪ੍ਰਾਪਤਕਰਤਾ ਦੀ ਚੋਣ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਉਹਨਾਂ ਦੇ ਬਕਾਏ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ। ਜੇਕਰ ਭੇਜਣ ਵਾਲਾ ਅਤੇ ਪ੍ਰਾਪਤਕਰਤਾ ਇੱਕੋ ਹਨ, ਤਾਂ ਉਸਦਾ ਖਾਤਾ ਦੁਬਾਰਾ ਭਰਿਆ ਜਾਵੇਗਾ:

ਲੌਗ ਵਿੱਚ ਅਸੀਂ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦੇ ਹਾਂ:

ਅਸਲ ਵਿੱਚ, ਇਹ ਸਭ ਡੈਮੋ ਪ੍ਰੋਗਰਾਮ ਦੇ ਨਾਲ ਹੈ। ਹੇਠਾਂ ਤੁਸੀਂ ਬਲਾਕਚੈਨ ਵਿੱਚ ਸਾਡਾ ਲੈਣ-ਦੇਣ ਦੇਖ ਸਕਦੇ ਹੋ:

ਅਤੇ ਲੈਣ-ਦੇਣ ਦੀ ਆਮ ਸੂਚੀ:

ਇਸਦੇ ਨਾਲ, ਅਸੀਂ Citcoin ਨੈੱਟਵਰਕ ਬਣਾਉਣ ਲਈ PoC ਨੂੰ ਲਾਗੂ ਕਰਨ ਨੂੰ ਸਫਲਤਾਪੂਰਵਕ ਪੂਰਾ ਕਰ ਲਿਆ ਹੈ। ਸਿੱਕਿਆਂ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਸਿਟਕੋਇਨ ਨੂੰ ਇੱਕ ਪੂਰਾ ਨੈੱਟਵਰਕ ਬਣਨ ਲਈ ਹੋਰ ਕੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ? ਬਹੁਤ ਘੱਟ:

• ਖਾਤਾ ਬਣਾਉਣ ਦੇ ਪੜਾਅ 'ਤੇ, ਇੱਕ ਨਿੱਜੀ / ਜਨਤਕ ਕੁੰਜੀ ਦੇ ਨਿਰਮਾਣ ਨੂੰ ਲਾਗੂ ਕਰੋ। ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਨੂੰ ਖਾਤਾ ਉਪਭੋਗਤਾ ਕੋਲ ਸਟੋਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜਨਤਕ ਕੁੰਜੀ ਨੂੰ ਬਲਾਕਚੈਨ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
• ਇੱਕ ਸਿੱਕਾ ਟ੍ਰਾਂਸਫਰ ਕਰੋ ਜਿਸ ਵਿੱਚ ਉਪਭੋਗਤਾ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਇੱਕ ਨਾਮ ਦੀ ਬਜਾਏ ਇੱਕ ਜਨਤਕ ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
• ਉਪਭੋਗਤਾ ਤੋਂ ਸਰਵਰ ਤੱਕ ਜਾਣ ਵਾਲੇ ਲੈਣ-ਦੇਣ ਨੂੰ ਉਸਦੀ ਨਿੱਜੀ ਕੁੰਜੀ ਨਾਲ ਐਨਕ੍ਰਿਪਟ ਕਰੋ।

ਸਿੱਟਾ

ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨਾਂ ਦੇ ਨਾਲ Citcoin ਨੈੱਟਵਰਕ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਹੈ: ਇੱਕ ਖਾਤਾ ਜੋੜੋ, ਬਕਾਇਆ ਪ੍ਰਾਪਤ ਕਰੋ, ਆਪਣੇ ਖਾਤੇ ਨੂੰ ਟਾਪ ਅੱਪ ਕਰੋ, ਸਿੱਕੇ ਇੱਕ ਖਾਤੇ ਤੋਂ ਦੂਜੇ ਖਾਤੇ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰੋ। ਤਾਂ, ਇੱਕ PoC ਬਣਾਉਣ ਲਈ ਸਾਨੂੰ ਕੀ ਖਰਚਾ ਆਇਆ?

• ਤੁਹਾਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਬਲਾਕਚੈਨ ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ ਦਾ ਅਧਿਐਨ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ;
• IBM ਜਾਂ Amazon ਕਲਾਉਡ ਵਰਤਣਾ ਸਿੱਖੋ;
• JS ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਅਤੇ ਕੁਝ ਵੈੱਬ ਫਰੇਮਵਰਕ ਸਿੱਖੋ;
• ਜੇ ਕੁਝ ਡੇਟਾ ਨੂੰ ਬਲਾਕਚੈਨ ਵਿੱਚ ਨਹੀਂ, ਪਰ ਇੱਕ ਵੱਖਰੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਤਾਂ ਫਿਰ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ ਸਿੱਖੋ, ਉਦਾਹਰਨ ਲਈ, PostgreSQL ਨਾਲ;
• ਅਤੇ ਆਖਰੀ ਪਰ ਘੱਟੋ ਘੱਟ ਨਹੀਂ - ਤੁਸੀਂ ਲੀਨਕਸ ਦੇ ਗਿਆਨ ਤੋਂ ਬਿਨਾਂ ਆਧੁਨਿਕ ਸੰਸਾਰ ਵਿੱਚ ਨਹੀਂ ਰਹਿ ਸਕਦੇ!)

ਬੇਸ਼ੱਕ, ਇਹ ਰਾਕੇਟ ਵਿਗਿਆਨ ਨਹੀਂ ਹੈ, ਪਰ ਤੁਹਾਨੂੰ ਸਖ਼ਤ ਮਿਹਨਤ ਕਰਨੀ ਪਵੇਗੀ!

GitHub 'ਤੇ ਸਰੋਤ

'ਤੇ ਸਰੋਤ ਲਗਾਏ GitHub. ਰਿਪੋਜ਼ਟਰੀ ਦਾ ਸੰਖੇਪ ਵੇਰਵਾ:
ਕੈਟਾਲਾਗ "ਸਰਵਰ» — Node.js ਸਰਵਰ
ਕੈਟਾਲਾਗ "ਗਾਹਕ»- Node.js ਕਲਾਇੰਟ
ਕੈਟਾਲਾਗ "blockchain"(ਪੈਰਾਮੀਟਰ ਮੁੱਲ ਅਤੇ ਕੁੰਜੀਆਂ, ਬੇਸ਼ਕ, ਗੈਰ-ਕਾਰਜ ਹਨ ਅਤੇ ਸਿਰਫ ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ):

• ਕੰਟਰੈਕਟ — ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸੋਰਸ ਕੋਡ
• ਵਾਲਿਟ — ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ API ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਉਪਭੋਗਤਾ ਕੁੰਜੀਆਂ।
• *.cds - ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੇ ਕੰਪਾਇਲ ਕੀਤੇ ਸੰਸਕਰਣ
• *.json ਫਾਈਲਾਂ - ਹਾਈਪਰਲੇਜਰ ਫੈਬਰਿਕ API ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਸੰਰਚਨਾ ਫਾਈਲਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ

ਇਹ ਸਿਰਫ ਸ਼ੁਰੂਆਤ ਹੈ!

ਸਰੋਤ: www.habr.com