ਬਲਾਕਚੈਨ 'ਤੇ ਵਿਕੇਂਦਰੀਕ੍ਰਿਤ ਮੈਸੇਂਜਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

2017 ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ, ਅਸੀਂ ਕਲਾਸਿਕ P2P ਮੈਸੇਂਜਰਾਂ ਦੇ ਫਾਇਦਿਆਂ ਬਾਰੇ ਚਰਚਾ ਕਰਕੇ ਬਲਾਕਚੈਨ [ਨਾਮ ਅਤੇ ਲਿੰਕ ਪ੍ਰੋਫਾਈਲ ਵਿੱਚ ਹਨ] ਉੱਤੇ ਇੱਕ ਮੈਸੇਂਜਰ ਬਣਾਉਣਾ ਸ਼ੁਰੂ ਕੀਤਾ।

ਪਾਸ ਕੀਤਾ 2.5 ਸਾਲ, ਅਤੇ ਅਸੀਂ ਆਪਣੀ ਧਾਰਨਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਦੇ ਯੋਗ ਹੋ ਗਏ: ਮੈਸੇਂਜਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਹੁਣ iOS, Web PWA, Windows, GNU/Linux, Mac OS ਅਤੇ Android ਲਈ ਉਪਲਬਧ ਹਨ।

ਅੱਜ ਅਸੀਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗੇ ਕਿ ਬਲਾਕਚੈਨ ਮੈਸੇਂਜਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਕਲਾਇੰਟ ਐਪਲੀਕੇਸ਼ਨ ਇਸ ਦੇ API ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰ ਸਕਦੀਆਂ ਹਨ।


ਅਸੀਂ ਚਾਹੁੰਦੇ ਸੀ ਕਿ ਬਲਾਕਚੈਨ ਕਲਾਸਿਕ P2P ਮੈਸੇਂਜਰਾਂ ਦੀ ਸੁਰੱਖਿਆ ਅਤੇ ਗੋਪਨੀਯਤਾ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰੇ:

• ਇੱਕ ਖਾਤਾ ਬਣਾਉਣ ਲਈ ਇੱਕ ਕਲਿੱਕ - ਕੋਈ ਫੋਨ ਜਾਂ ਈਮੇਲ ਨਹੀਂ, ਐਡਰੈੱਸ ਬੁੱਕ ਜਾਂ ਭੂ-ਸਥਾਨ ਤੱਕ ਕੋਈ ਪਹੁੰਚ ਨਹੀਂ।
• ਵਾਰਤਾਕਾਰ ਕਦੇ ਵੀ ਸਿੱਧੇ ਸੰਪਰਕ ਸਥਾਪਤ ਨਹੀਂ ਕਰਦੇ; ਸਾਰੇ ਸੰਚਾਰ ਨੋਡਾਂ ਦੀ ਵੰਡੀ ਪ੍ਰਣਾਲੀ ਦੁਆਰਾ ਹੁੰਦੇ ਹਨ। ਉਪਭੋਗਤਾਵਾਂ ਦੇ IP ਪਤੇ ਇੱਕ ਦੂਜੇ ਤੱਕ ਪਹੁੰਚਯੋਗ ਨਹੀਂ ਹਨ।
• ਸਾਰੇ ਸੁਨੇਹੇ Encrypted End-to-End curve25519xsalsa20poly1305 ਹਨ। ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਕਿਸੇ ਨੂੰ ਹੈਰਾਨ ਨਹੀਂ ਕਰੇਗਾ, ਪਰ ਸਾਡਾ ਸਰੋਤ ਕੋਡ ਖੁੱਲ੍ਹਾ ਹੈ.
• MITM ਹਮਲੇ ਨੂੰ ਬਾਹਰ ਰੱਖਿਆ ਗਿਆ ਹੈ - ਹਰੇਕ ਸੁਨੇਹਾ ਇੱਕ ਲੈਣ-ਦੇਣ ਹੈ ਅਤੇ Ed25519 EdDSA ਦੁਆਰਾ ਹਸਤਾਖਰਿਤ ਹੈ।
• ਸੁਨੇਹਾ ਇਸ ਦੇ ਆਪਣੇ ਬਲਾਕ ਵਿੱਚ ਖਤਮ ਹੁੰਦਾ ਹੈ. ਇਕਸਾਰਤਾ ਅਤੇ timestamp ਤੁਸੀਂ ਬਲਾਕਾਂ ਨੂੰ ਠੀਕ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਇਸਲਈ ਸੁਨੇਹਿਆਂ ਦਾ ਕ੍ਰਮ.
• "ਮੈਂ ਇਹ ਨਹੀਂ ਕਿਹਾ" ਬਲਾਕਚੈਨ 'ਤੇ ਸੰਦੇਸ਼ਾਂ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ।
• ਇੱਥੇ ਕੋਈ ਕੇਂਦਰੀ ਢਾਂਚਾ ਨਹੀਂ ਹੈ ਜੋ ਸੰਦੇਸ਼ ਦੀ "ਪ੍ਰਮਾਣਿਕਤਾ" ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਸਹਿਮਤੀ ਦੇ ਅਧਾਰ ਤੇ ਨੋਡਾਂ ਦੀ ਵੰਡੀ ਪ੍ਰਣਾਲੀ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਮਲਕੀਅਤ ਹੈ।
• ਸੈਂਸਰਸ਼ਿਪ ਦੀ ਅਸੰਭਵਤਾ - ਖਾਤਿਆਂ ਨੂੰ ਬਲੌਕ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਅਤੇ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਮਿਟਾਇਆ ਨਹੀਂ ਜਾ ਸਕਦਾ।
• ਬਲਾਕਚੈਨ 2FA SMS ਦੁਆਰਾ ਨਰਕ 2FA ਦਾ ਵਿਕਲਪ ਹੈ, ਬਹੁਤ ਸਾਰੀ ਸਿਹਤ ਬਰਬਾਦ ਕੀਤੀ।
• ਕਿਸੇ ਵੀ ਸਮੇਂ ਕਿਸੇ ਵੀ ਡਿਵਾਈਸ ਤੋਂ ਤੁਹਾਡੀਆਂ ਸਾਰੀਆਂ ਗੱਲਬਾਤਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਯੋਗਤਾ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਗੱਲਬਾਤ ਨੂੰ ਸਟੋਰ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
• ਸੁਨੇਹਾ ਡਿਲੀਵਰੀ ਦੀ ਪੁਸ਼ਟੀ. ਉਪਭੋਗਤਾ ਦੇ ਡਿਵਾਈਸ ਲਈ ਨਹੀਂ, ਪਰ ਨੈਟਵਰਕ ਲਈ. ਅਸਲ ਵਿੱਚ, ਇਹ ਤੁਹਾਡੇ ਸੰਦੇਸ਼ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਪ੍ਰਾਪਤਕਰਤਾ ਦੀ ਯੋਗਤਾ ਦੀ ਪੁਸ਼ਟੀ ਹੈ। ਇਹ ਨਾਜ਼ੁਕ ਸੂਚਨਾਵਾਂ ਭੇਜਣ ਲਈ ਇੱਕ ਉਪਯੋਗੀ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ।

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

ਅਤੇ ਫਿਰ - ਇਹ ਸਭ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ.

ਇੱਕ ਸੁਨੇਹਾ ਇੱਕ ਲੈਣ-ਦੇਣ ਹੈ

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

ਬਲਾਕਚੈਨ 'ਤੇ ਇੱਕ ਮੈਸੇਂਜਰ ਵਿੱਚ ਸੁਨੇਹਾ ਭੇਜਣ ਲਈ, ਤੁਹਾਨੂੰ ਕਈ ਪੜਾਵਾਂ ਵਿੱਚੋਂ ਲੰਘਣ ਦੀ ਲੋੜ ਹੈ:

1. ਸੁਨੇਹਾ ਟੈਕਸਟ ਨੂੰ ਐਨਕ੍ਰਿਪਟ ਕਰੋ
2. ਇੱਕ ਲੈਣ-ਦੇਣ ਵਿੱਚ ਸਿਫਰਟੈਕਸਟ ਪਾਓ
3. ਲੈਣ-ਦੇਣ 'ਤੇ ਦਸਤਖਤ ਕਰੋ
4. ਕਿਸੇ ਵੀ ਨੈੱਟਵਰਕ ਨੋਡ ਨੂੰ ਇੱਕ ਲੈਣ-ਦੇਣ ਭੇਜੋ
5. ਨੋਡਾਂ ਦੀ ਇੱਕ ਵੰਡੀ ਪ੍ਰਣਾਲੀ ਇੱਕ ਸੰਦੇਸ਼ ਦੀ "ਪ੍ਰਮਾਣਿਕਤਾ" ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ
6. ਜੇ ਸਭ ਕੁਝ ਠੀਕ ਹੈ, ਤਾਂ ਸੁਨੇਹੇ ਨਾਲ ਲੈਣ-ਦੇਣ ਨੂੰ ਅਗਲੇ ਬਲਾਕ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ
7. ਪ੍ਰਾਪਤਕਰਤਾ ਸੁਨੇਹਾ ਲੈਣ-ਦੇਣ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਡੀਕ੍ਰਿਪਟ ਕਰਦਾ ਹੈ

ਪੜਾਅ 1–3 ਅਤੇ 7 ਕਲਾਇੰਟ 'ਤੇ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਕਦਮ 5-6 ਮੇਜ਼ਬਾਨਾਂ 'ਤੇ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

ਸੁਨੇਹਾ ਇਨਕ੍ਰਿਪਸ਼ਨ

ਸੁਨੇਹਾ ਭੇਜਣ ਵਾਲੇ ਦੀ ਨਿੱਜੀ ਕੁੰਜੀ ਅਤੇ ਪ੍ਰਾਪਤਕਰਤਾ ਦੀ ਜਨਤਕ ਕੁੰਜੀ ਨਾਲ ਏਨਕ੍ਰਿਪਟ ਕੀਤਾ ਗਿਆ ਹੈ। ਅਸੀਂ ਨੈੱਟਵਰਕ ਤੋਂ ਜਨਤਕ ਕੁੰਜੀ ਲਵਾਂਗੇ, ਪਰ ਇਸਦੇ ਲਈ, ਪ੍ਰਾਪਤਕਰਤਾ ਦਾ ਖਾਤਾ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਯਾਨੀ, ਘੱਟੋ-ਘੱਟ ਇੱਕ ਲੈਣ-ਦੇਣ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਕ REST ਬੇਨਤੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ GET /api/accounts/getPublicKey?address={ADAMANT address}, ਅਤੇ ਚੈਟਾਂ ਨੂੰ ਲੋਡ ਕਰਨ ਵੇਲੇ, ਵਾਰਤਾਕਾਰਾਂ ਦੀਆਂ ਜਨਤਕ ਕੁੰਜੀਆਂ ਪਹਿਲਾਂ ਹੀ ਉਪਲਬਧ ਹੋਣਗੀਆਂ।

ਮੈਸੇਂਜਰ ਕਰਵ25519xsalsa20poly1305 ਐਲਗੋਰਿਦਮ (NaCl ਬਾਕਸ). ਕਿਉਂਕਿ ਖਾਤੇ ਵਿੱਚ Ed25519 ਕੁੰਜੀਆਂ ਹਨ, ਇੱਕ ਬਾਕਸ ਬਣਾਉਣ ਲਈ, ਕੁੰਜੀਆਂ ਨੂੰ ਪਹਿਲਾਂ Curve25519 Diffie-Hellman ਵਿੱਚ ਬਦਲਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਇੱਥੇ JavaScript ਵਿੱਚ ਇੱਕ ਉਦਾਹਰਨ ਹੈ:

/**
 * Encodes a text message for sending to ADM
 * @param {string} msg message to encode
 * @param {*} recipientPublicKey recipient's public key
 * @param {*} privateKey our private key
 * @returns {{message: string, nonce: string}}
 */
adamant.encodeMessage = function (msg, recipientPublicKey, privateKey) {
  const nonce = Buffer.allocUnsafe(24)
  sodium.randombytes(nonce)

  if (typeof recipientPublicKey === 'string') {
    recipientPublicKey = hexToBytes(recipientPublicKey)
  }

  const plainText = Buffer.from(msg)
  const DHPublicKey = ed2curve.convertPublicKey(recipientPublicKey)
  const DHSecretKey = ed2curve.convertSecretKey(privateKey)

  const encrypted = nacl.box(plainText, nonce, DHPublicKey, DHSecretKey)

  return {
    message: bytesToHex(encrypted),
    nonce: bytesToHex(nonce)
  }
}

ਇੱਕ ਸੁਨੇਹੇ ਨਾਲ ਇੱਕ ਲੈਣ-ਦੇਣ ਬਣਾਉਣਾ

ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਦੀ ਹੇਠ ਲਿਖੀ ਆਮ ਬਣਤਰ ਹੈ:

{
  "id": "15161295239237781653",
  "height": 7585271,
  "blockId": "16391508373936326027",
  "type": 8,
  "block_timestamp": 45182260,
  "timestamp": 45182254,
  "senderPublicKey": "bd39cc708499ae91b937083463fce5e0668c2b37e78df28f69d132fce51d49ed",
  "senderId": "U16023712506749300952",
  "recipientId": "U17653312780572073341",
  "recipientPublicKey": "23d27f616e304ef2046a60b762683b8dabebe0d8fc26e5ecdb1d5f3d291dbe21",
  "amount": 204921300000000,
  "fee": 50000000,
  "signature": "3c8e551f60fedb81e52835c69e8b158eb1b8b3c89a04d3df5adc0d99017ffbcb06a7b16ad76d519f80df019c930960317a67e8d18ab1e85e575c9470000cf607",
  "signatures": [],
  "confirmations": 3660548,
  "asset": {}
}

ਇੱਕ ਸੁਨੇਹਾ ਲੈਣ-ਦੇਣ ਲਈ, ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਚੀਜ਼ ਹੈ asset - ਤੁਹਾਨੂੰ ਆਬਜੈਕਟ ਵਿੱਚ ਇੱਕ ਸੁਨੇਹਾ ਲਗਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ chat ਬਣਤਰ ਦੇ ਨਾਲ:

• message - ਏਨਕ੍ਰਿਪਟਡ ਸੰਦੇਸ਼ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ
• own_message - nonce
• type - ਸੁਨੇਹਾ ਕਿਸਮ

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

ਨਤੀਜੇ ਵਜੋਂ, ਅਸੀਂ ਇੱਕ ਲੈਣ-ਦੇਣ ਬਣਾਉਂਦੇ ਹਾਂ:

{
  "transaction": {
    "type": 8,
    "amount": 0,
    "senderId": "U12499126640447739963",
    "senderPublicKey": "e9cafb1e7b403c4cf247c94f73ee4cada367fcc130cb3888219a0ba0633230b6",
    "asset": {
      "chat": {
        "message": "cb682accceef92d7cddaaddb787d1184ab5428",
        "own_message": "e7d8f90ddf7d70efe359c3e4ecfb5ed3802297b248eacbd6",
        "type": 1
      }
    },
    "recipientId": "U15677078342684640219",
    "timestamp": 63228087,
    "signature": "тут будет подпись"
  }
}

ਲੈਣ-ਦੇਣ ਦੇ ਦਸਤਖਤ

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

ਪਰ ਹਸਤਾਖਰ ਖੁਦ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੇ ਜਾਂਦੇ ਹਨ:

ਚਿੱਤਰ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ SHA-256 ਨਾਲ ਲੈਣ-ਦੇਣ ਨੂੰ ਹੈਸ਼ ਕਰਦੇ ਹਾਂ ਅਤੇ ਫਿਰ ਇਸ 'ਤੇ ਦਸਤਖਤ ਕਰਦੇ ਹਾਂ Ed25519 EdDSA ਅਤੇ ਇੱਕ ਦਸਤਖਤ ਪ੍ਰਾਪਤ ਕਰੋ signature, ਅਤੇ ਲੈਣ-ਦੇਣ ID SHA-256 ਹੈਸ਼ ਦਾ ਹਿੱਸਾ ਹੈ।

ਲਾਗੂ ਕਰਨ ਦੀ ਉਦਾਹਰਨ:

1 — ਇੱਕ ਸੁਨੇਹਾ ਸਮੇਤ, ਇੱਕ ਡਾਟਾ ਬਲਾਕ ਬਣਾਓ

/**
 * Calls `getBytes` based on transaction type
 * @see privateTypes
 * @implements {ByteBuffer}
 * @param {transaction} trs
 * @param {boolean} skipSignature
 * @param {boolean} skipSecondSignature
 * @return {!Array} Contents as an ArrayBuffer.
 * @throws {error} If buffer fails.
 */

adamant.getBytes = function (transaction) {

  ...

  switch (transaction.type) {
    case constants.Transactions.SEND:
      break
    case constants.Transactions.CHAT_MESSAGE:
      assetBytes = this.chatGetBytes(transaction)
      assetSize = assetBytes.length
      break

…

    default:
      alert('Not supported yet')
  }

  var bb = new ByteBuffer(1 + 4 + 32 + 8 + 8 + 64 + 64 + assetSize, true)

  bb.writeByte(transaction.type)
  bb.writeInt(transaction.timestamp)

  ...

  bb.flip()
  var arrayBuffer = new Uint8Array(bb.toArrayBuffer())
  var buffer = []

  for (var i = 0; i < arrayBuffer.length; i++) {
    buffer[i] = arrayBuffer[i]
  }

  return Buffer.from(buffer)
}

2 - ਡਾਟਾ ਬਲਾਕ ਤੋਂ SHA-256 ਦੀ ਗਿਣਤੀ ਕਰੋ

/**
 * Creates hash based on transaction bytes.
 * @implements {getBytes}
 * @implements {crypto.createHash}
 * @param {transaction} trs
 * @return {hash} sha256 crypto hash
 */
adamant.getHash = function (trs) {
  return crypto.createHash('sha256').update(this.getBytes(trs)).digest()
}

3 - ਲੈਣ-ਦੇਣ 'ਤੇ ਦਸਤਖਤ ਕਰੋ

adamant.transactionSign = function (trs, keypair) {
  var hash = this.getHash(trs)
  return this.sign(hash, keypair).toString('hex')
}

/**
 * Creates a signature based on a hash and a keypair.
 * @implements {sodium}
 * @param {hash} hash
 * @param {keypair} keypair
 * @return {signature} signature
 */
adamant.sign = function (hash, keypair) {
  return sodium.crypto_sign_detached(hash, Buffer.from(keypair.privateKey, 'hex'))
}

ਇੱਕ ਨੈੱਟਵਰਕ ਨੋਡ ਨੂੰ ਇੱਕ ਸੁਨੇਹੇ ਦੇ ਨਾਲ ਇੱਕ ਲੈਣ-ਦੇਣ ਭੇਜਣਾ

ਕਿਉਂਕਿ ਨੈਟਵਰਕ ਵਿਕੇਂਦਰੀਕ੍ਰਿਤ ਹੈ, ਇੱਕ ਓਪਨ API ਵਾਲਾ ਕੋਈ ਵੀ ਨੋਡ ਕਰੇਗਾ। ਅੰਤਮ ਬਿੰਦੂ ਨੂੰ ਇੱਕ POST ਬੇਨਤੀ ਕਰਨਾ api/transactions:

curl 'api/transactions' -X POST 
  -d 'TX_DATA'

ਜਵਾਬ ਵਿੱਚ ਸਾਨੂੰ ਕਿਸਮ ਦੀ ਇੱਕ ਲੈਣ-ਦੇਣ ID ਪ੍ਰਾਪਤ ਹੋਵੇਗੀ

{
    "success": true,
    "nodeTimestamp": 63228852,
    "transactionId": "6146865104403680934"
}

ਲੈਣ-ਦੇਣ ਪ੍ਰਮਾਣਿਕਤਾ

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

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

ਨੋਡ ਕੋਡ ਦਾ ਉਹ ਹਿੱਸਾ ਜੋ ਜਾਂਚਾਂ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ GitHub 'ਤੇ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ - validator.js и verify.js. ਹਾਂ, ਨੋਡ Node.js 'ਤੇ ਚੱਲਦਾ ਹੈ।

ਇੱਕ ਬਲਾਕ ਵਿੱਚ ਇੱਕ ਸੁਨੇਹੇ ਦੇ ਨਾਲ ਇੱਕ ਲੈਣ-ਦੇਣ ਸਮੇਤ

ਜੇਕਰ ਸਹਿਮਤੀ ਬਣ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਾਡੇ ਸੁਨੇਹੇ ਨਾਲ ਲੈਣ-ਦੇਣ ਨੂੰ ਹੋਰ ਵੈਧ ਲੈਣ-ਦੇਣ ਦੇ ਨਾਲ ਅਗਲੇ ਬਲਾਕ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਵੇਗਾ।

ਬਲਾਕਾਂ ਦਾ ਇੱਕ ਸਖ਼ਤ ਕ੍ਰਮ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਅਗਲੇ ਬਲਾਕ ਦਾ ਗਠਨ ਪਿਛਲੇ ਬਲਾਕਾਂ ਦੇ ਹੈਸ਼ਾਂ ਦੇ ਅਧਾਰ ਤੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

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

ਸੁਨੇਹੇ ਪੜ੍ਹ ਰਹੇ ਹਨ

ਮੈਸੇਂਜਰ ਐਪਲੀਕੇਸ਼ਨ ਬਲਾਕਚੈਨ ਤੋਂ ਲੈਣ-ਦੇਣ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ ਜੋ ਪ੍ਰਾਪਤਕਰਤਾ ਨੂੰ ਭੇਜੇ ਜਾਂਦੇ ਹਨ। ਇਸਦੇ ਲਈ ਅਸੀਂ ਇੱਕ ਅੰਤਮ ਬਿੰਦੂ ਬਣਾਇਆ ਹੈ api/chatrooms.

ਸਾਰੇ ਲੈਣ-ਦੇਣ ਹਰ ਕਿਸੇ ਲਈ ਉਪਲਬਧ ਹਨ - ਤੁਸੀਂ ਐਨਕ੍ਰਿਪਟਡ ਸੁਨੇਹੇ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ। ਪਰ ਕੇਵਲ ਪ੍ਰਾਪਤਕਰਤਾ ਆਪਣੀ ਨਿੱਜੀ ਕੁੰਜੀ ਅਤੇ ਭੇਜਣ ਵਾਲੇ ਦੀ ਜਨਤਕ ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡੀਕ੍ਰਿਪਟ ਕਰ ਸਕਦਾ ਹੈ:

**
 * Decodes the incoming message
 * @param {any} msg encoded message
 * @param {string} senderPublicKey sender public key
 * @param {string} privateKey our private key
 * @param {any} nonce nonce
 * @returns {string}
 */
adamant.decodeMessage = function (msg, senderPublicKey, privateKey, nonce) {
  if (typeof msg === 'string') {
    msg = hexToBytes(msg)
  }

  if (typeof nonce === 'string') {
    nonce = hexToBytes(nonce)
  }

  if (typeof senderPublicKey === 'string') {
    senderPublicKey = hexToBytes(senderPublicKey)
  }

  if (typeof privateKey === 'string') {
    privateKey = hexToBytes(privateKey)
  }

  const DHPublicKey = ed2curve.convertPublicKey(senderPublicKey)
  const DHSecretKey = ed2curve.convertSecretKey(privateKey)
  const decrypted = nacl.box.open(msg, nonce, DHPublicKey, DHSecretKey)

  return decrypted ? decode(decrypted) : ''
}

ਅਤੇ ਹੋਰ ਕੀ?

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

ਐਡਰੈੱਸ ਬੁੱਕ ਸਟੋਰ ਕਰਨ ਲਈ, ਅਸੀਂ ਕੇਵੀਐਸ - ਕੀ-ਵੈਲਯੂ ਸਟੋਰੇਜ - ਇਹ ਇੱਕ ਹੋਰ ਕਿਸਮ ਦਾ ਲੈਣ-ਦੇਣ ਹੈ ਜਿਸ ਵਿੱਚ asset ਇਹ NaCl-ਬਾਕਸ ਨਹੀਂ ਹੈ ਜੋ ਐਨਕ੍ਰਿਪਟਡ ਹੈ, ਪਰ NaCl-ਸੀਕ੍ਰੇਟਬਾਕਸ. ਇਸ ਤਰ੍ਹਾਂ ਮੈਸੇਂਜਰ ਦੂਜੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ।

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

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

ਅਸੀਂ ਸਾਬਤ ਕੀਤਾ ਹੈ ਕਿ ਬਲਾਕਚੈਨ 'ਤੇ ਇੱਕ ਦੂਤ ਮੌਜੂਦ ਹੋ ਸਕਦਾ ਹੈ. ਪਹਿਲਾਂ, 2012 ਵਿੱਚ ਸਿਰਫ ਇੱਕ ਕੋਸ਼ਿਸ਼ ਸੀ - ਬਿੱਟਮੈਸੇਜ, ਜੋ ਲੰਬੇ ਸੁਨੇਹੇ ਡਿਲੀਵਰੀ ਸਮੇਂ, CPU ਲੋਡ, ਅਤੇ ਮੋਬਾਈਲ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਘਾਟ ਕਾਰਨ ਅਸਫਲ ਰਿਹਾ।

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

ਸਰੋਤ: www.habr.com