តើអ្នកនាំសារវិមជ្ឈការធ្វើការលើ blockchain យ៉ាងដូចម្តេច?

នៅដើមឆ្នាំ 2017 យើងបានចាប់ផ្តើមបង្កើតអ្នកនាំសារមួយនៅលើ blockchain [ឈ្មោះ និងតំណស្ថិតនៅក្នុងទម្រង់] ដោយពិភាក្សាអំពីគុណសម្បត្តិជាងអ្នកនាំសារ P2P បុរាណ។

ឆ្លងកាត់ 2.5 ហើយយើងអាចបញ្ជាក់គោលគំនិតរបស់យើងបាន៖ ឥឡូវនេះកម្មវិធីផ្ញើសារមានសម្រាប់ iOS, Web PWA, Windows, GNU/Linux, Mac OS និង Android ។

ថ្ងៃនេះយើងនឹងប្រាប់អ្នកពីរបៀបដែល blockchain messenger ដំណើរការ និងរបៀបដែលកម្មវិធីអតិថិជនអាចធ្វើការជាមួយ API របស់វា។


យើងចង់ឱ្យ blockchain ដោះស្រាយបញ្ហាសុវត្ថិភាព និងឯកជនភាពរបស់អ្នកនាំសារ P2P បុរាណ៖

• ចុចមួយដងដើម្បីបង្កើតគណនី - គ្មានទូរស័ព្ទ ឬអ៊ីមែល គ្មានសិទ្ធិចូលប្រើសៀវភៅអាសយដ្ឋាន ឬទីតាំងភូមិសាស្ត្រ។
• អ្នកប្រាស្រ័យទាក់ទងគ្នាមិនដែលបង្កើតការភ្ជាប់ដោយផ្ទាល់ទេ ការទំនាក់ទំនងទាំងអស់កើតឡើងតាមរយៈប្រព័ន្ធចែកចាយថ្នាំង។ អាសយដ្ឋាន IP របស់អ្នកប្រើមិនអាចចូលប្រើគ្នាទៅវិញទៅមកបានទេ។
• សារទាំងអស់ត្រូវបានអ៊ិនគ្រីប End-to-End curve25519xsalsa20poly1305។ វាហាក់ដូចជាថានេះនឹងមិនធ្វើឱ្យនរណាម្នាក់ភ្ញាក់ផ្អើលនោះទេប៉ុន្តែកូដប្រភពរបស់យើងគឺបើកចំហ។
• ការវាយប្រហារ MITM ត្រូវបានដកចេញ - សារនីមួយៗគឺជាប្រតិបត្តិការមួយ ហើយត្រូវបានចុះហត្ថលេខាដោយ Ed25519 EdDSA ។
• សារបញ្ចប់នៅក្នុងប្លុករបស់វា។ ភាពជាប់លាប់និង timestamp អ្នកមិនអាចជួសជុលប្លុកបានទេ ដូច្នេះហើយតាមលំដាប់នៃសារ។
• "ខ្ញុំមិនបាននិយាយដូច្នេះទេ" នឹងមិនដំណើរការជាមួយសារនៅលើ blockchain ទេ។
• មិនមានរចនាសម្ព័ន្ធកណ្តាលដែលត្រួតពិនិត្យលើ "ភាពត្រឹមត្រូវ" នៃសារនោះទេ។ នេះត្រូវបានធ្វើដោយប្រព័ន្ធចែកចាយថ្នាំងដោយផ្អែកលើការមូលមតិគ្នា ហើយវាត្រូវបានគ្រប់គ្រងដោយអ្នកប្រើប្រាស់។
• ភាពមិនអាចទៅរួចនៃការចាប់ពិរុទ្ធ - គណនីមិនអាចត្រូវបានរារាំង ហើយសារមិនអាចលុបបានទេ។
• Blockchain 2FA គឺជាជម្រើសមួយសម្រាប់ 2FA នរកតាមរយៈសារ SMS, បំផ្លាញសុខភាពយ៉ាងច្រើន។
• សមត្ថភាពក្នុងការទទួលការសន្ទនារបស់អ្នកទាំងអស់ពីឧបករណ៍ណាមួយនៅពេលណាមួយមានន័យថាអ្នកមិនចាំបាច់រក្សាទុកការសន្ទនានៅក្នុងមូលដ្ឋានទាល់តែសោះ។
• ការបញ្ជាក់ពីការបញ្ជូនសារ។ មិនមែនទៅឧបករណ៍របស់អ្នកប្រើទេ ប៉ុន្តែសម្រាប់បណ្តាញ។ ជាការសំខាន់ នេះគឺជាការបញ្ជាក់អំពីសមត្ថភាពរបស់អ្នកទទួលក្នុងការអានសាររបស់អ្នក។ នេះគឺជាមុខងារដ៏មានប្រយោជន៍សម្រាប់ការផ្ញើការជូនដំណឹងសំខាន់ៗ។

អត្ថប្រយោជន៍ Blockchain ក៏រួមបញ្ចូលការរួមបញ្ចូលយ៉ាងជិតស្និទ្ធជាមួយនឹងរូបិយប័ណ្ណអេឡិចត្រូនិក Ethereum, Dogecoin, Lisk, Dash, Bitcoin (មួយនេះកំពុងដំណើរការនៅឡើយ) និងសមត្ថភាពក្នុងការផ្ញើសញ្ញាសម្ងាត់ក្នុងការជជែក។ យើងថែមទាំងបានបង្កើតឧបករណ៍ផ្លាស់ប្តូរគ្រីបតូដែលមានស្រាប់។

ហើយបន្ទាប់មក - របៀបដែលវាដំណើរការទាំងអស់។

សារគឺជាប្រតិបត្តិការមួយ។

មនុស្សគ្រប់គ្នាបានទម្លាប់ធ្វើការកត់សំគាល់រួចហើយចំពោះការពិតដែលថាប្រតិបត្តិការនៅក្នុង blockchain ផ្ទេរសញ្ញាសម្ងាត់ (កាក់) ពីអ្នកប្រើប្រាស់ម្នាក់ទៅមួយផ្សេងទៀត។ ដូចជា Bitcoin ។ យើងបានបង្កើតប្រភេទពិសេសនៃប្រតិបត្តិការសម្រាប់ការបញ្ជូនសារ។

ដើម្បីផ្ញើសារនៅក្នុងកម្មវិធីផ្ញើសារនៅលើ blockchain អ្នកត្រូវឆ្លងកាត់ជំហានជាច្រើន៖

1. អ៊ិនគ្រីបអត្ថបទសារ
2. ដាក់លេខកូដសម្ងាត់ទៅក្នុងប្រតិបត្តិការ
3. ចុះហត្ថលេខាលើប្រតិបត្តិការ
4. ផ្ញើប្រតិបត្តិការទៅថ្នាំងបណ្តាញណាមួយ។
5. ប្រព័ន្ធចែកចាយថ្នាំងកំណត់ "ភាពត្រឹមត្រូវ" នៃសារ
6. ប្រសិនបើអ្វីៗទាំងអស់មិនអីទេ ប្រតិបត្តិការជាមួយសារត្រូវបានបញ្ចូលក្នុងប្លុកបន្ទាប់
7. អ្នកទទួលយកប្រតិបត្តិការសារ និងឌិគ្រីប

ជំហានទី 1–3 និង 7 ត្រូវបានអនុវត្តនៅក្នុងមូលដ្ឋាននៅលើម៉ាស៊ីនភ្ញៀវ ហើយជំហាន 5–6 ត្រូវបានអនុវត្តនៅលើម៉ាស៊ីន។

ការអ៊ិនគ្រីបសារ

សារត្រូវបានអ៊ិនគ្រីបដោយប្រើសោឯកជនរបស់អ្នកផ្ញើ និងសោសាធារណៈរបស់អ្នកទទួល។ យើងនឹងយកសោសាធារណៈពីបណ្តាញ ប៉ុន្តែសម្រាប់បញ្ហានេះ គណនីរបស់អ្នកទទួលត្រូវតែត្រូវបានចាប់ផ្តើម ពោលគឺមានប្រតិបត្តិការយ៉ាងហោចណាស់មួយ។ អ្នកអាចប្រើសំណើ REST GET /api/accounts/getPublicKey?address={ADAMANT address}ហើយនៅពេលផ្ទុកការជជែក សោសាធារណៈរបស់ interlocutors នឹងមានរួចហើយ។

កម្មវិធីផ្ញើសារអ៊ិនគ្រីបសារដោយប្រើក្បួនដោះស្រាយ 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. អ្នកអាចផ្ញើត្រឹមតែជាអត្ថបទ ឬអ្នកអាចផ្ញើវត្ថុមួយដែលមានអ្វីដែលគួរឱ្យចាប់អារម្មណ៍នៅខាងក្នុង - ឧទាហរណ៍ នេះជារបៀបដែលអ្នកនាំសារធ្វើឱ្យការផ្ទេររូបិយប័ណ្ណគ្រីបតូនៅក្នុងការជជែក។

ជាលទ្ធផល យើងបង្កើតប្រតិបត្តិការមួយ៖

{
  "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ហើយលេខសម្គាល់ប្រតិបត្តិការគឺជាផ្នែកមួយនៃសញ្ញា 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'

ជាការឆ្លើយតប យើងនឹងទទួលបានលេខសម្គាល់ប្រតិបត្តិការនៃប្រភេទ

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

សុពលភាពប្រតិបត្តិការ

ប្រព័ន្ធចែកចាយថ្នាំង ដោយផ្អែកលើការយល់ស្រប កំណត់ "ភាពត្រឹមត្រូវ" នៃសារប្រតិបត្តិការ។ ពីអ្នកណា និងទៅអ្នកណា នៅពេលណា ថាតើសារត្រូវបានជំនួសដោយសារផ្សេងទៀត និងថាតើពេលវេលានៃការផ្ញើត្រូវបានចង្អុលបង្ហាញយ៉ាងត្រឹមត្រូវ។ នេះគឺជាអត្ថប្រយោជន៍ដ៏សំខាន់បំផុតនៃ blockchain - មិនមានរចនាសម្ព័ន្ធកណ្តាលដែលទទួលខុសត្រូវសម្រាប់ការផ្ទៀងផ្ទាត់ទេហើយលំដាប់នៃសារនិងមាតិការបស់ពួកគេមិនអាចក្លែងបន្លំបានទេ។

ទីមួយថ្នាំងមួយពិនិត្យមើលភាពត្រឹមត្រូវ ហើយបន្ទាប់មកផ្ញើវាទៅអ្នកផ្សេងទៀត - ប្រសិនបើភាគច្រើននិយាយថាអ្វីគ្រប់យ៉ាងគឺស្ថិតនៅក្នុងលំដាប់ ប្រតិបត្តិការនឹងត្រូវបានរួមបញ្ចូលនៅក្នុងប្លុកបន្ទាប់នៃខ្សែសង្វាក់នេះ - នេះគឺជាការយល់ស្រប។

ផ្នែកនៃលេខកូដថ្នាំងដែលទទួលខុសត្រូវចំពោះការត្រួតពិនិត្យអាចមើលបាននៅលើ GitHub - សុពលភាព и ផ្ទៀងផ្ទាត់.js. បាទ ថ្នាំងដំណើរការលើ Node.js ។

រួមទាំងប្រតិបត្តិការជាមួយសារនៅក្នុងប្លុក

ប្រសិនបើការយល់ស្របត្រូវបានឈានដល់ ប្រតិបត្តិការជាមួយសាររបស់យើងនឹងត្រូវបានបញ្ចូលក្នុងប្លុកបន្ទាប់ រួមជាមួយនឹងប្រតិបត្តិការដែលមានសុពលភាពផ្សេងទៀត។

ប្លុកមានលំដាប់តឹងរ៉ឹង ហើយប្លុកបន្តបន្ទាប់នីមួយៗត្រូវបានបង្កើតឡើងដោយផ្អែកលើសញ្ញានៃប្លុកមុនៗ។

ចំនុចនោះគឺថាសាររបស់យើងក៏ត្រូវបានបញ្ចូលក្នុងលំដាប់នេះផងដែរ ហើយមិនអាច "រៀបចំឡើងវិញ" បានទេ។ ប្រសិនបើសារជាច្រើនធ្លាក់ចូលទៅក្នុងប្លុក ការបញ្ជាទិញរបស់ពួកគេនឹងត្រូវបានកំណត់ដោយ timestamp សារ។

ការអានសារ

កម្មវិធីផ្ញើសារទៅយកប្រតិបត្តិការពី 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 វិនាទី - នេះគឺជាពេលដែលប្លុកបណ្តាញថ្មីលេចឡើង - យើងបានភ្ជាប់មកជាមួយនូវការតភ្ជាប់រន្ធ client-to-node និង node-to-node ។ នៅពេលដែលថ្នាំងទទួលបានប្រតិបត្តិការថ្មី វាពិនិត្យសុពលភាពរបស់វា ហើយបញ្ជូនវាទៅថ្នាំងផ្សេងទៀត។ ប្រតិបត្តិការនេះមានសម្រាប់អតិថិជនផ្ញើសារ សូម្បីតែមុនពេលការឯកភាពកើតឡើង និងការដាក់បញ្ចូលក្នុងប្លុកក៏ដោយ។ វិធីនេះ យើងនឹងបញ្ជូនសារភ្លាមៗ ដូចអ្នកផ្ញើសារបន្ទាន់ធម្មតាដែរ។

ដើម្បីរក្សាទុកសៀវភៅអាសយដ្ឋាន យើងបានបង្កើត KVS - Key-Value Storage - នេះគឺជាប្រភេទប្រតិបត្តិការមួយផ្សេងទៀតដែលនៅក្នុងនោះ។ asset វាមិនមែនជាប្រអប់ NaCl ដែលត្រូវបានអ៊ិនគ្រីបទេ ប៉ុន្តែ NaCl-ប្រអប់សម្ងាត់. នេះជារបៀបដែលអ្នកនាំសាររក្សាទុកទិន្នន័យផ្សេងទៀត។

ការផ្ទេរឯកសារ/រូបភាព និងការជជែកជាក្រុមនៅតែត្រូវការការងារច្រើន។ ជា​ការ​ពិត​ណាស់ នៅ​ក្នុង​ទម្រង់​ដែល​មិន​ច្បាស់​លាស់​និង​ភាព​មិន​ច្បាស់​នេះ​អាច​ត្រូវ​បាន "បិទ" យ៉ាង​ឆាប់​រហ័ស ប៉ុន្តែ​យើង​ចង់​រក្សា​កម្រិត​ឯកជនភាព​ដដែល។

បាទ / ចាស វានៅតែមានការងារដែលត្រូវធ្វើ - តាមឧត្ដមគតិ ឯកជនភាពពិតប្រាកដសន្មត់ថាអ្នកប្រើប្រាស់នឹងមិនភ្ជាប់ទៅថ្នាំងបណ្តាញសាធារណៈទេ ប៉ុន្តែនឹងលើកឡើងដោយខ្លួនឯង។ តើ​អ្នក​គិត​ថា​អ្នក​ប្រើ​នេះ​មាន​ភាគរយ​ប៉ុន្មាន? ត្រឹមត្រូវហើយ 0. យើងអាចដោះស្រាយបញ្ហានេះដោយផ្នែកជាមួយកំណែ Tor របស់អ្នកនាំសារ។

យើងបានបង្ហាញថាអ្នកនាំសារនៅលើ blockchain អាចមាន។ កាល​ពី​មុន​មាន​ការ​ប៉ុនប៉ង​តែ​មួយ​គត់​ក្នុង​ឆ្នាំ ២០១២ - សារប៊ីតដែលបរាជ័យដោយសារតែពេលវេលាបញ្ជូនសារយូរ ការផ្ទុកស៊ីភីយូ និងកង្វះកម្មវិធីទូរស័ព្ទ។

ហើយការសង្ស័យគឺដោយសារតែការពិតដែលថាអ្នកនាំសារនៅលើ blockchain គឺមុនពេលវេលារបស់ពួកគេ - មនុស្សមិនទាន់ត្រៀមខ្លួនរួចជាស្រេចដើម្បីទទួលខុសត្រូវចំពោះគណនីរបស់ពួកគេការកាន់កាប់ព័ត៌មានផ្ទាល់ខ្លួនមិនទាន់ជានិន្នាការទេហើយបច្ចេកវិទ្យាមិនអនុញ្ញាតឱ្យមានល្បឿនលឿននៅលើ blockchain ទេ។ analogues បច្ចេកវិទ្យាជាច្រើនទៀតនៃគម្រោងរបស់យើងនឹងបង្ហាញនៅពេលក្រោយ។ អ្នកនឹងឃើញ។

ប្រភព: www.habr.com