ຜູ້ສົ່ງຂ່າວທີ່ມີການແບ່ງຂັ້ນຄຸ້ມຄອງເຮັດວຽກຢູ່ໃນ blockchain ແນວໃດ?

ໃນຕອນຕົ້ນຂອງ 2017, ພວກເຮົາໄດ້ເລີ່ມສ້າງຜູ້ສົ່ງຂ່າວກ່ຽວກັບ blockchain [ຊື່ແລະການເຊື່ອມຕໍ່ຢູ່ໃນໂປຣໄຟລ໌] ໂດຍການສົນທະນາຂໍ້ໄດ້ປຽບຫຼາຍກວ່າຜູ້ສົ່ງຂ່າວ P2P ຄລາສສິກ.

ຜ່ານ 2.5 ປີ, ແລະພວກເຮົາສາມາດຢືນຢັນແນວຄວາມຄິດຂອງພວກເຮົາ: ຄໍາຮ້ອງສະຫມັກ messenger ແມ່ນມີຢູ່ໃນ iOS, Web PWA, Windows, GNU/Linux, Mac OS ແລະ Android.

ມື້ນີ້ພວກເຮົາຈະບອກທ່ານວ່າ blockchain messenger ເຮັດວຽກແນວໃດແລະວິທີການລູກຄ້າສາມາດເຮັດວຽກກັບ API ຂອງມັນໄດ້ແນວໃດ.


ພວກເຮົາຕ້ອງການໃຫ້ blockchain ແກ້ໄຂບັນຫາຄວາມປອດໄພແລະຄວາມເປັນສ່ວນຕົວຂອງຜູ້ສົ່ງຂ່າວ P2P ຄລາສສິກ:

• ຄລິກດຽວເພື່ອສ້າງບັນຊີ - ບໍ່ມີໂທລະສັບ ຫຼືອີເມວ, ບໍ່ມີການເຂົ້າເຖິງປຶ້ມທີ່ຢູ່ ຫຼືສະຖານທີ່ຕັ້ງພູມສາດ.
• interlocutors ບໍ່ເຄີຍສ້າງການເຊື່ອມຕໍ່ໂດຍກົງ; ການສື່ສານທັງຫມົດເກີດຂຶ້ນໂດຍຜ່ານລະບົບການແຈກຢາຍຂອງ nodes. ທີ່ຢູ່ IP ຂອງຜູ້ໃຊ້ບໍ່ສາມາດເຂົ້າເຖິງກັນແລະກັນ.
• ຂໍ້ຄວາມທັງໝົດຖືກເຂົ້າລະຫັດແບບ End-to-End curve25519xsalsa20poly1305. ມັນເບິ່ງຄືວ່ານີ້ຈະບໍ່ແປກໃຈໃຜ, ແຕ່ລະຫັດແຫຼ່ງຂອງພວກເຮົາແມ່ນເປີດ.
• ການໂຈມຕີ MITM ແມ່ນຖືກຍົກເວັ້ນ - ແຕ່ລະຂໍ້ຄວາມແມ່ນການເຮັດທຸລະກໍາແລະຖືກເຊັນໂດຍ Ed25519 EdDSA.
• ຂໍ້ຄວາມສິ້ນສຸດລົງໃນບລັອກຂອງຕົນເອງ. ຄວາມສອດຄ່ອງແລະ timestamp ທ່ານບໍ່ສາມາດແກ້ໄຂຕັນໄດ້, ແລະດັ່ງນັ້ນຄໍາສັ່ງຂອງຂໍ້ຄວາມ.
• "ຂ້ອຍບໍ່ໄດ້ເວົ້າແນວນັ້ນ" ຈະບໍ່ເຮັດວຽກກັບຂໍ້ຄວາມໃນ blockchain.
• ບໍ່ມີໂຄງສ້າງສູນກາງທີ່ກວດສອບ "ຄວາມຖືກຕ້ອງ" ຂອງຂໍ້ຄວາມ. ນີ້ແມ່ນເຮັດໂດຍລະບົບການແຈກຢາຍຂອງ nodes ໂດຍອີງໃສ່ຄວາມເຫັນດີເຫັນພ້ອມ, ແລະມັນແມ່ນເປັນເຈົ້າຂອງໂດຍຜູ້ໃຊ້.
• ເປັນໄປບໍ່ໄດ້ຂອງການເຊັນເຊີ - ບັນຊີບໍ່ສາມາດຖືກບລັອກ ແລະຂໍ້ຄວາມບໍ່ສາມາດຖືກລຶບໄດ້.
• Blockchain 2FA ເປັນທາງເລືອກທີ່ເປັນ hellish 2FA ຜ່ານ SMS, ທໍາລາຍສຸຂະພາບຫຼາຍ.
• ຄວາມ​ສາ​ມາດ​ທີ່​ຈະ​ໄດ້​ຮັບ​ການ​ສົນ​ທະ​ນາ​ທັງ​ຫມົດ​ຂອງ​ທ່ານ​ຈາກ​ອຸ​ປະ​ກອນ​ໃດ​ຫນຶ່ງ​ໃນ​ທຸກ​ເວ​ລາ​ຫມາຍ​ຄວາມ​ວ່າ​ທ່ານ​ບໍ່​ຈໍາ​ເປັນ​ຕ້ອງ​ເກັບ​ຮັກ​ສາ​ການ​ສົນ​ທະ​ນາ​ໃນ​ທີ່​ທັງ​ຫມົດ​.
• ຢືນຢັນການສົ່ງຂໍ້ຄວາມ. ບໍ່ແມ່ນອຸປະກອນຂອງຜູ້ໃຊ້, ແຕ່ກັບເຄືອຂ່າຍ. ໂດຍພື້ນຖານແລ້ວ, ນີ້ແມ່ນການຢືນຢັນຄວາມສາມາດຂອງຜູ້ຮັບໃນການອ່ານຂໍ້ຄວາມຂອງທ່ານ. ນີ້ແມ່ນຄຸນສົມບັດທີ່ເປັນປະໂຫຍດສໍາລັບການສົ່ງການແຈ້ງເຕືອນທີ່ສໍາຄັນ.

ຜົນປະໂຫຍດຂອງ Blockchain ຍັງປະກອບມີການເຊື່ອມໂຍງຢ່າງໃກ້ຊິດກັບ cryptocurrencies Ethereum, Dogecoin, Lisk, Dash, Bitcoin (ອັນນີ້ຍັງຢູ່ໃນຄວາມຄືບຫນ້າ) ແລະຄວາມສາມາດໃນການສົ່ງ tokens ໃນການສົນທະນາ. ພວກເຮົາຍັງໄດ້ສ້າງຕົວແລກປ່ຽນ crypto ທີ່ມີໃນຕົວ.

ແລະຫຼັງຈາກນັ້ນ - ເຮັດແນວໃດມັນທັງຫມົດເຮັດວຽກ.

ຂໍ້ຄວາມແມ່ນການເຮັດທຸລະກໍາ

ທຸກໆຄົນໄດ້ຄຸ້ນເຄີຍກັບຄວາມຈິງທີ່ວ່າການເຮັດທຸລະກໍາໃນ tokens ການໂອນ blockchain (ຫຼຽນ) ຈາກຜູ້ໃຊ້ຫນຶ່ງໄປຫາຄົນອື່ນ. ເຊັ່ນດຽວກັນກັບ Bitcoin. ພວກເຮົາໄດ້ສ້າງປະເພດພິເສດຂອງທຸລະກໍາສໍາລັບການສົ່ງຂໍ້ຄວາມ.

ເພື່ອສົ່ງຂໍ້ຄວາມໃນ messenger ໃນ blockchain, ທ່ານຈໍາເປັນຕ້ອງຜ່ານຫຼາຍຂັ້ນຕອນ:

1. ເຂົ້າລະຫັດຂໍ້ຄວາມ
2. ໃສ່ ciphertext ເຂົ້າໃນການເຮັດທຸລະກໍາ
3. ເຊັນການເຮັດທຸລະກໍາ
4. ສົ່ງທຸລະກໍາໄປຫາ node ເຄືອຂ່າຍໃດໆ
5. ລະບົບການແຈກຢາຍຂອງ nodes ກໍານົດ "ຄວາມຖືກຕ້ອງ" ຂອງຂໍ້ຄວາມ
6. ຖ້າທຸກສິ່ງທຸກຢ່າງແມ່ນ OK, ການເຮັດທຸລະກໍາທີ່ມີຂໍ້ຄວາມຖືກລວມຢູ່ໃນບລັອກຕໍ່ໄປ
7. ຜູ້ຮັບດຶງຂໍ້ມູນທຸລະກໍາຂໍ້ຄວາມແລະຖອດລະຫັດ

ຂັ້ນ​ຕອນ​ທີ 1–3 ແລະ 7 ແມ່ນ​ປະ​ຕິ​ບັດ​ຢູ່​ໃນ​ທ້ອງ​ຖິ່ນ​ກ່ຽວ​ກັບ​ລູກ​ຄ້າ, ແລະ​ຂັ້ນ​ຕອນ 5–6 ແມ່ນ​ປະ​ຕິ​ບັດ​ຢູ່​ໃນ​ການ​ເປັນ​ເຈົ້າ​ພາບ.

ການເຂົ້າລະຫັດຂໍ້ຄວາມ

ຂໍ້ຄວາມຖືກເຂົ້າລະຫັດດ້ວຍກະແຈສ່ວນຕົວຂອງຜູ້ສົ່ງ ແລະກະແຈສາທາລະນະຂອງຜູ້ຮັບ. ພວກເຮົາຈະເອົາລະຫັດສາທາລະນະຈາກເຄືອຂ່າຍ, ແຕ່ສໍາລັບການນີ້, ບັນຊີຂອງຜູ້ຮັບຕ້ອງໄດ້ຮັບການເລີ່ມຕົ້ນ, ນັ້ນແມ່ນ, ມີຢ່າງຫນ້ອຍຫນຶ່ງທຸລະກໍາ. ທ່ານສາມາດນໍາໃຊ້ຄໍາຮ້ອງຂໍ REST ໄດ້ GET /api/accounts/getPublicKey?address={ADAMANT address}, ແລະໃນເວລາທີ່ໂຫລດການສົນທະນາ, ກະແຈສາທາລະນະຂອງ interlocutors ຈະມີຢູ່ແລ້ວ.

Messenger ເຂົ້າລະຫັດຂໍ້ຄວາມໂດຍໃຊ້ algorithm curve25519xsalsa20poly1305 (ກ່ອງ 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 - ບໍ່ແມ່ນ
• type — ປະ​ເພດ​ຂໍ້​ຄວາມ​

ຂໍ້ຄວາມຍັງຖືກແບ່ງອອກເປັນປະເພດ. ໂດຍພື້ນຖານແລ້ວ, ພາລາມິເຕີ type ບອກທ່ານວິທີການເຂົ້າໃຈ message. ທ່ານສາມາດສົ່ງຂໍ້ຄວາມພຽງແຕ່, ຫຼືທ່ານສາມາດສົ່ງວັດຖຸທີ່ມີສິ່ງທີ່ຫນ້າສົນໃຈພາຍໃນ - ຕົວຢ່າງ, ນີ້ແມ່ນວິທີທີ່ຜູ້ສົ່ງຂ່າວເຮັດໃຫ້ການໂອນເງິນ cryptocurrency ໃນການສົນທະນາ.

ດັ່ງນັ້ນ, ພວກເຮົາສ້າງທຸລະກໍາ:

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

ລາຍເຊັນການເຮັດທຸລະກໍາ

ເພື່ອຮັບປະກັນວ່າທຸກຄົນມີຄວາມຫມັ້ນໃຈໃນຄວາມຖືກຕ້ອງຂອງຜູ້ສົ່ງແລະຜູ້ຮັບ, ເວລາຂອງການສົ່ງແລະເນື້ອໃນຂອງຂໍ້ຄວາມ, ການເຮັດທຸລະກໍາໄດ້ຖືກເຊັນ. ລາຍເຊັນດິຈິຕອນຊ່ວຍໃຫ້ທ່ານສາມາດກວດສອບຄວາມຖືກຕ້ອງຂອງທຸລະກໍາໂດຍໃຊ້ລະຫັດສາທາລະນະ - ລະຫັດສ່ວນຕົວແມ່ນບໍ່ຈໍາເປັນສໍາລັບການນີ້.

ແຕ່ລາຍເຊັນຕົວມັນເອງຖືກປະຕິບັດໂດຍໃຊ້ລະຫັດສ່ວນຕົວ:

ແຜນວາດສະແດງໃຫ້ເຫັນວ່າພວກເຮົາທໍາອິດ hash ທຸລະກໍາກັບ SHA-256 ແລະຫຼັງຈາກນັ້ນເຊັນມັນ Ed25519 EdDSA ແລະໄດ້ຮັບລາຍເຊັນ signature, ແລະ ID ທຸລະກໍາແມ່ນສ່ວນຫນຶ່ງຂອງ SHA-256 hash.

ຕົວຢ່າງການປະຕິບັດ:

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'))
}

ການສົ່ງທຸລະກໍາດ້ວຍຂໍ້ຄວາມໄປຫາໂຫນດເຄືອຂ່າຍ

ເນື່ອງຈາກເຄືອຂ່າຍຖືກແບ່ງຂັ້ນຄຸ້ມຄອງ, ໃດໆຂອງ nodes ທີ່ມີ API ເປີດຈະເຮັດ. ເຮັດການຮ້ອງຂໍ POST ໄປຫາຈຸດສິ້ນສຸດ api/transactions:

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

ໃນການຕອບສະຫນອງພວກເຮົາຈະໄດ້ຮັບ ID ການເຮັດທຸລະກໍາຂອງປະເພດ

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

ການກວດສອບການເຮັດທຸລະກໍາ

ລະບົບການແຈກຢາຍຂອງ nodes, ໂດຍອີງໃສ່ຄວາມເຫັນດີເຫັນພ້ອມ, ກໍານົດ "ຄວາມຖືກຕ້ອງ" ຂອງຂໍ້ຄວາມທຸລະກໍາ. ຈາກໃຜແລະໃຜ, ເວລາໃດ, ຂໍ້ຄວາມຖືກແທນທີ່ດ້ວຍຂໍ້ຄວາມອື່ນ, ແລະເວລາຂອງການສົ່ງຖືກຊີ້ບອກຢ່າງຖືກຕ້ອງ. ນີ້ແມ່ນປະໂຫຍດທີ່ສໍາຄັນຫຼາຍຂອງ blockchain - ບໍ່ມີໂຄງສ້າງສູນກາງທີ່ຮັບຜິດຊອບໃນການກວດສອບ, ແລະລໍາດັບຂອງຂໍ້ຄວາມແລະເນື້ອຫາຂອງພວກມັນບໍ່ສາມາດຖືກປອມແປງໄດ້.

ຫນ້າທໍາອິດ, ຫນຶ່ງໃນ node ກວດເບິ່ງຄວາມຖືກຕ້ອງ, ແລະຫຼັງຈາກນັ້ນສົ່ງໃຫ້ຜູ້ອື່ນ - ຖ້າສ່ວນໃຫຍ່ບອກວ່າທຸກສິ່ງທຸກຢ່າງແມ່ນຢູ່ໃນຄໍາສັ່ງ, ການເຮັດທຸລະກໍາຈະຖືກລວມຢູ່ໃນຕັນຕໍ່ໄປຂອງຕ່ອງໂສ້ - ນີ້ແມ່ນຄວາມເຫັນດີນໍາ.

ສ່ວນຂອງລະຫັດ node ທີ່ຮັບຜິດຊອບສໍາລັບການກວດສອບສາມາດເບິ່ງໄດ້ໃນ GitHub - validator.js и verify.js. ແມ່ນແລ້ວ, node ແລ່ນຢູ່ໃນ Node.js.

ລວມທັງການເຮັດທຸລະກໍາທີ່ມີຂໍ້ຄວາມຢູ່ໃນບລັອກ

ຖ້າການຕົກລົງເຫັນດີ, ການເຮັດທຸລະກໍາກັບຂໍ້ຄວາມຂອງພວກເຮົາຈະຖືກລວມຢູ່ໃນບລັອກຕໍ່ໄປພ້ອມກັບການເຮັດທຸລະກໍາທີ່ຖືກຕ້ອງອື່ນໆ.

ຕັນມີລໍາດັບທີ່ເຄັ່ງຄັດ, ແລະແຕ່ລະຕັນຕໍ່ມາແມ່ນສ້າງຕັ້ງຂຶ້ນໂດຍອີງໃສ່ hashes ຂອງຕັນທີ່ຜ່ານມາ.

ຈຸດສໍາຄັນແມ່ນວ່າຂໍ້ຄວາມຂອງພວກເຮົາຖືກລວມຢູ່ໃນລໍາດັບນີ້ແລະບໍ່ສາມາດ "ຈັດລຽງໃຫມ່". ຖ້າຂໍ້ຄວາມຈໍານວນຫນຶ່ງຕົກຢູ່ໃນບລັອກ, ຄໍາສັ່ງຂອງພວກເຂົາຈະຖືກກໍານົດໂດຍ timestamp ຂໍ້ຄວາມ.

ກຳລັງອ່ານຂໍ້ຄວາມ

ແອັບພລິເຄຊັນ messenger ດຶງເອົາທຸລະກໍາຈາກ blockchain ທີ່ຖືກສົ່ງໄປຫາຜູ້ຮັບ. ສໍາລັບການນີ້ພວກເຮົາໄດ້ເຮັດຈຸດສິ້ນສຸດ 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 ວິນາທີ - ນີ້ແມ່ນເວລາທີ່ບລັອກເຄືອຂ່າຍໃຫມ່ປາກົດ - ພວກເຮົາມາພ້ອມກັບການເຊື່ອມຕໍ່ socket client-to-node ແລະ node-to-node. ເມື່ອ node ໄດ້ຮັບທຸລະກໍາໃຫມ່, ມັນຈະກວດສອບຄວາມຖືກຕ້ອງຂອງມັນແລະສົ່ງຕໍ່ໄປຫາ nodes ອື່ນໆ. ການເຮັດທຸລະກໍາແມ່ນມີໃຫ້ລູກຄ້າ messenger ເຖິງແມ່ນວ່າກ່ອນທີ່ຈະເປັນເອກະສັນເກີດຂຶ້ນແລະລວມຢູ່ໃນຕັນ. ດ້ວຍວິທີນີ້, ພວກເຮົາຈະສົ່ງຂໍ້ຄວາມທັນທີ, ຄືກັນກັບຜູ້ສົ່ງຂໍ້ຄວາມທັນທີ.

ເພື່ອເກັບຮັກສາປື້ມທີ່ຢູ່, ພວກເຮົາເຮັດ KVS - Key-Value Storage - ນີ້ແມ່ນການເຮັດທຸລະກໍາປະເພດອື່ນ asset ມັນບໍ່ແມ່ນ NaCl-box ທີ່ຖືກເຂົ້າລະຫັດ, ແຕ່ NaCl-secretbox. ນີ້ແມ່ນວິທີທີ່ຜູ້ສົ່ງຂ່າວເກັບຂໍ້ມູນອື່ນໆ.

ການໂອນໄຟລ໌/ຮູບພາບ ແລະການສົນທະນາກຸ່ມຍັງຕ້ອງການວຽກຫຼາຍ. ແນ່ນອນ, ໃນຮູບແບບ blunder-and-blunder ນີ້ສາມາດໄດ້ຮັບການ "screwed" ຢ່າງວ່ອງໄວ, ແຕ່ພວກເຮົາຕ້ອງການທີ່ຈະຮັກສາລະດັບດຽວກັນຂອງຄວາມເປັນສ່ວນຕົວ.

ແມ່ນແລ້ວ, ຍັງມີວຽກທີ່ຕ້ອງເຮັດ - ໂດຍຫລັກການແລ້ວ, ຄວາມເປັນສ່ວນຕົວທີ່ແທ້ຈິງສົມມຸດວ່າຜູ້ໃຊ້ຈະບໍ່ເຊື່ອມຕໍ່ກັບ nodes ເຄືອຂ່າຍສາທາລະນະ, ແຕ່ຈະຍົກສູງບົດບາດຂອງຕົນເອງ. ອັດຕາສ່ວນຂອງຜູ້ໃຊ້ໃດທີ່ທ່ານຄິດວ່າເຮັດສິ່ງນີ້? ຖືກຕ້ອງແລ້ວ, 0. ພວກເຮົາສາມາດແກ້ໄຂບັນຫານີ້ໄດ້ບາງສ່ວນດ້ວຍສະບັບ Tor ຂອງຜູ້ສົ່ງຂ່າວ.

ພວກເຮົາໄດ້ພິສູດແລ້ວວ່າຜູ້ສົ່ງຂ່າວໃນ blockchain ສາມາດມີຢູ່. ກ່ອນຫນ້ານີ້, ມີພຽງແຕ່ຫນຶ່ງຄວາມພະຍາຍາມໃນປີ 2012 - ຂໍ້ຄວາມ, ເຊິ່ງລົ້ມເຫລວເນື່ອງຈາກເວລາສົ່ງຂໍ້ຄວາມຍາວ, ການໂຫຼດ CPU, ແລະການຂາດແອັບພລິເຄຊັນມືຖື.

ແລະຄວາມບໍ່ຄ່ອຍເຊື່ອງ່າຍໆແມ່ນຍ້ອນຄວາມຈິງທີ່ວ່າຜູ້ສົ່ງຂ່າວໃນ blockchain ແມ່ນຢູ່ກ່ອນເວລາຂອງພວກເຂົາ - ປະຊາຊົນບໍ່ພ້ອມທີ່ຈະຮັບຜິດຊອບບັນຊີຂອງເຂົາເຈົ້າ, ການເປັນເຈົ້າຂອງຂໍ້ມູນສ່ວນບຸກຄົນຍັງບໍ່ທັນເປັນແນວໂນ້ມ, ແລະເຕັກໂນໂລຢີບໍ່ອະນຸຍາດໃຫ້ມີຄວາມໄວສູງໃນ blockchain. ການປຽບທຽບດ້ານເຕັກໂນໂລຢີເພີ່ມເຕີມຂອງໂຄງການຂອງພວກເຮົາຈະປາກົດຕໍ່ໄປ. ເຈົ້າຈະເຫັນ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com