Blockchain 'ਤੇ RSA ਬੇਤਰਤੀਬ

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

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

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

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

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

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

ਹਾਲ ਹੀ ਵਿੱਚ, Tradisys ਟੀਮ ਨੇ ਵੇਵਜ਼ ਪ੍ਰੋਟੋਕੋਲ ਵਿੱਚ ਇੱਕ ਫੰਕਸ਼ਨ ਜੋੜਨ ਦਾ ਪ੍ਰਸਤਾਵ ਕੀਤਾ ਹੈ rsaVerify(). ਇਹ ਜਨਤਕ ਅਤੇ ਨਿੱਜੀ ਕੁੰਜੀ ਦੇ ਆਧਾਰ 'ਤੇ RSA ਦਸਤਖਤ ਦੀ ਵੈਧਤਾ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ, ਵਿਸ਼ੇਸ਼ਤਾ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ ਸੀ।

ਅਸੀਂ ਤਿੰਨ ਗੇਮਾਂ ਵਿਕਸਿਤ ਕੀਤੀਆਂ ਹਨ: ਡਾਈਸ ਰੋਲਰ, ਸਿੱਕਾ ਫਲਿੱਪ и ਲਹਿਰਾਂ 'ਤੇ ਸਵਾਰੀ ਕਰੋ. ਹਰ ਇੱਕ ਬੇਤਰਤੀਬ ਨੰਬਰ ਤਕਨਾਲੋਜੀ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ. ਆਓ ਇਹ ਪਤਾ ਕਰੀਏ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।

ਆਉ ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ ਤੇ ਰਾਈਡ ਆਨ ਵੇਵਜ਼ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਬੇਤਰਤੀਬ ਨੰਬਰ ਬਣਾਉਣ ਨੂੰ ਵੇਖੀਏ। ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਲੱਭਿਆ ਜਾ ਸਕਦਾ ਹੈ ਇੱਥੇ.

ਟੈਬ 'ਤੇ ਜਾਓ ਸਕ੍ਰਿਪਟ ਅਤੇ ਚੁਣੋ ਡੀਕੰਪਾਈਲਡ. ਤੁਸੀਂ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਕੋਡ (ਉਰਫ਼ ਸਕ੍ਰਿਪਟ) ਦੇਖੋਗੇ।

ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਕੋਡ ਵਿੱਚ ਫੰਕਸ਼ਨਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੁੰਦਾ ਹੈ। ਜਿਨ੍ਹਾਂ ਨੂੰ @Callable ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਉਹਨਾਂ ਨੂੰ ਵਰਤ ਕੇ ਲਾਂਚ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਸੱਦਾ ਲੈਣ-ਦੇਣ. ਅਸੀਂ ਦੋ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ: ਬਾਜ਼ੀ и ਵਾਪਸ ਲਓ:

• ਫੰਕ ਬੇਟ (ਖਿਡਾਰੀ ਦੀ ਚੋਣ)
• ਫੰਕ ਕਢਵਾਉਣਾ (gameId,rsaSign)

1. ਉਪਭੋਗਤਾ ਹਿੱਸੇ ਦੀ ਲੰਬਾਈ ਅਤੇ ਬਾਜ਼ੀ ਦਾ ਆਕਾਰ ਚੁਣਦਾ ਹੈ।

2. ਕਲਾਇੰਟ ਇੱਕ ਬੇਟ ਫੰਕਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ। ਉਪਰੋਕਤ ਚਿੱਤਰ ਲਈ ਇਹ ਹੋਵੇਗਾ ਸੱਟਾ("50").

3. ਕਲਾਇੰਟ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਪਤੇ (ਪ੍ਰਸਾਰਣ ਇਨਵੋਕੇਸ਼ਨ ਟੀਐਕਸ) 'ਤੇ ਇੱਕ ਇਨਵੋਕੇਸ਼ਨ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਭੇਜਦਾ ਹੈ। ਲੈਣ-ਦੇਣ ਵਿੱਚ ਇੱਕ ਕਾਲ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਸੱਟਾ ਫੰਕਸ਼ਨ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਨਵੋਕੇਸ਼ਨ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਸਮਾਰਟ ਕੰਟਰੈਕਟ 'ਤੇ ਬੇਟ ਫੰਕਸ਼ਨ (ਚੋਣ: ਸਤਰ) ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਚਾਲੂ ਕਰਦਾ ਹੈ।

4. ਬਾਜ਼ੀ ਫੰਕਸ਼ਨ 'ਤੇ ਗੌਰ ਕਰੋ:

@Callable(i)
func bet (playerChoice) = {
    let newGameNum = IncrementGameNum()
    let gameId = toBase58String(i.transactionId)
    let pmt = extract(i.payment)
    let betNotInWaves = isDefined(pmt.assetId)
    let feeNotInWaves = isDefined(pmt.assetId)
    let winAmt = ValidateBetAndDefineWinAmt(pmt.amount, playerChoice)
    let txIdUsed = isDefined(getString(this, gameId))
    if (betNotInWaves)
        then throw ("Bet amount must be in Waves")
        else if (feeNotInWaves)
            then throw ("Transaction's fee must be in Waves")
            else if (txIdUsed)
                then throw ("Passed txId had been used before. Game aborted.")
                else {
                    let playerPubKey58 = toBase58String(i.callerPublicKey)
                    let gameDataStr = FormatGameDataStr(STATESUBMITTED, playerChoice, playerPubKey58, height, winAmt, "")
                    ScriptResult(WriteSet(cons(DataEntry(RESERVATIONKEY, ValidateAndIncreaseReservedAmt(winAmt)), cons(DataEntry(GAMESCOUNTERKEY, newGameNum), cons(DataEntry(gameId, gameDataStr), nil)))), TransferSet(cons(ScriptTransfer(SERVER, COMMISSION, unit), nil)))
                    }
    }

ਫੰਕਸ਼ਨ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੀ ਸਥਿਤੀ ਲਈ ਇੱਕ ਨਵੀਂ ਗੇਮ ਲਿਖਦਾ ਹੈ। ਅਰਥਾਤ:

• ਨਵੀਂ ਗੇਮ ਲਈ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ (ਗੇਮ ਆਈਡੀ)
• ਖੇਲ ਅਵਸਥਾ = ਪੇਸ਼ ਕੀਤੀ
• ਖਿਡਾਰੀ ਦੀ ਪਸੰਦ (ਖੰਡ ਦੀ ਲੰਬਾਈ 50)
• ਜਨਤਕ ਕੁੰਜੀ
• ਸੰਭਾਵੀ ਜਿੱਤਾਂ (ਖਿਡਾਰੀ ਦੀ ਬਾਜ਼ੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ)

ਬਲਾਕਚੈਨ ਵਿੱਚ ਡੇਟਾ ਰਿਕਾਰਡ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ (ਕੁੰਜੀ-ਮੁੱਲ):

{
    "type": "string",
    "value": "03WON_0283_448t8Jn9P3717UnXFEVD5VWjfeGE5gBNeWg58H2aJeQEgJ_06574069_09116020000_0229",
    "key": "2GKTX6NLTgUrE4iy9HtpSSHpZ3G8W4cMfdjyvvnc21dx"
  }

"ਕੁੰਜੀ" (ਕੁੰਜੀ) - ਗੇਮ ਆਈ.ਡੀ ਨਵੀਂ ਖੇਡ. ਬਾਕੀ ਡਾਟਾ "ਮੁੱਲ" ਖੇਤਰ ਦੀ ਲਾਈਨ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ। ਇਹ ਐਂਟਰੀਆਂ ਟੈਬ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਡੇਟਾ ਸਮਾਰਟ ਕੰਟਰੈਕਟ:

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

6. ਸਰਵਰ ਇੱਕ ਵਾਪਿਸ ਫੰਕਸ਼ਨ (gameId, rsaSign) ਬਣਾਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਸ ਤਰ੍ਹਾਂ:

withdraw ("FwsuaaShC6DMWdSWQ5osGWtYkVbTEZrsnxqDbVx5oUpq", "base64:Gy69dKdmXUEsAmUrpoWxDLTQOGj5/qO8COA+QjyPVYTAjxXYvEESJbSiCSBRRCOAliqCWwaS161nWqoTL/TltiIvw3nKyd4RJIBNSIgEWGM1tEtNwwnRwSVHs7ToNfZ2Dvk/GgPUqLFDSjnRQpTHdHUPj9mQ8erWw0r6cJXrzfcagKg3yY/0wJ6AyIrflR35mUCK4cO7KumdvC9Mx0hr/ojlHhN732nuG8ps4CUlRw3CkNjNIajBUlyKQwpBKmmiy3yJa/QM5PLxqdppmfFS9y0sxgSlfLOgZ51xRDYuS8NViOA7c1JssH48ZtDbBT5yqzRJXs3RnmZcMDr/q0x6Bg==")

7. ਸਰਵਰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ (ਪ੍ਰਸਾਰਣ ਇਨਵੋਕੇਸ਼ਨ ਟੀਐਕਸ) ਨੂੰ ਇੱਕ ਇਨਵੋਕੇਸ਼ਨ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਭੇਜਦਾ ਹੈ। ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿੱਚ ਬਣਾਏ ਗਏ ਵਾਪਿਸ ਫੰਕਸ਼ਨ (gameId, rsaSign) ਲਈ ਇੱਕ ਕਾਲ ਸ਼ਾਮਲ ਹੈ:

ਫੰਕਸ਼ਨ ਸ਼ਾਮਿਲ ਹੈ ਗੇਮ ਆਈ.ਡੀ ਨਵੀਂ ਗੇਮ ਅਤੇ ਇੱਕ ਨਿੱਜੀ ਕੁੰਜੀ ਦੇ ਨਾਲ ਇੱਕ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ ਦੇ RSA ਹਸਤਾਖਰ ਕਰਨ ਦਾ ਨਤੀਜਾ। ਦਸਤਖਤ ਦਾ ਨਤੀਜਾ ਬਦਲਿਆ ਨਹੀਂ ਹੈ।

ਇਸਦਾ ਕੀ ਅਰਥ ਹੈ?

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

8. ਬਲਾਕਚੈਨ ਲੈਣ-ਦੇਣ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ। ਇਹ ਵਾਪਿਸ ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ (gameId, rsaSign)

9. ਵਾਪਿਸ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ, ਕਢਵਾਉਣਾ ਹੁੰਦਾ ਹੈ ਰੈਂਡਇੰਟ ਫੰਕਸ਼ਨ ਤਿਆਰ ਕਰੋ (gameId, rsaSign)। ਇਹ ਇੱਕ ਬੇਤਰਤੀਬ ਨੰਬਰ ਜਨਰੇਟਰ ਹੈ

# @return 1 ... 100
func GenerateRandInt (gameId,rsaSign) = {
   	# verify RSA signature to proof random
    let rsaSigValid = rsaVerify (SHA256, toBytes(gameId), rsaSign, RSAPUBLIC)
    if (rsaSigValid)
        then {
            let rand = (toInt(sha256(rsaSign)) % 100)
            if ((0 > rand))
                then ((-1 * rand) + 1)
                else (rand + 1)
            }
        else throw ("Invalid RSA signature")
    }

ਰੈਡ - ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬ ਨੰਬਰ ਹੈ.

ਪਹਿਲਾਂ, ਸਤਰ ਲਈ ਜਾਂਦੀ ਹੈ, ਜੋ ਕਿ RSA ਦਸਤਖਤ ਦਾ ਨਤੀਜਾ ਹੈ ਗੇਮ ਆਈ.ਡੀ ਨਿੱਜੀ ਕੁੰਜੀ (rsaSign). ਫਿਰ SHA-256 ਨਾਲ ਹੈਸ਼ ਕੀਤਾ (sha256(rsaSign)).

ਅਸੀਂ ਦਸਤਖਤ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਹੈਸ਼ਿੰਗ ਦੇ ਨਤੀਜੇ ਦੀ ਭਵਿੱਖਬਾਣੀ ਨਹੀਂ ਕਰ ਸਕਦੇ। ਇਸ ਲਈ, ਇੱਕ ਬੇਤਰਤੀਬ ਸੰਖਿਆ ਦੇ ਉਤਪਾਦਨ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨਾ ਅਸੰਭਵ ਹੈ. ਇੱਕ ਖਾਸ ਰੇਂਜ ਵਿੱਚ ਇੱਕ ਨੰਬਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ (ਉਦਾਹਰਨ ਲਈ, 1 ਤੋਂ 100 ਤੱਕ), toInt ਪਰਿਵਰਤਨ ਫੰਕਸ਼ਨ ਅਤੇ %100 (ਇਸ ਦੇ ਸਮਾਨ) ਦੀ ਵਰਤੋਂ ਕਰੋ ਮਾਡ).

ਲੇਖ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਅਸੀਂ ਫੰਕਸ਼ਨ ਦਾ ਜ਼ਿਕਰ ਕੀਤਾ ਹੈ rsaVerify(), ਜੋ ਤੁਹਾਨੂੰ ਕਿਸੇ ਜਨਤਕ ਦੇ ਵਿਰੁੱਧ ਇੱਕ ਨਿੱਜੀ ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ RSA ਦਸਤਖਤ ਦੀ ਵੈਧਤਾ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇੱਥੇ GenerateRandInt (gameId,rsaSign) ਭਾਗ ਹੈ:

rsaVerify (SHA256, toBytes(gameId), rsaSign, RSAPUBLIC)

ਜਨਤਕ ਕੁੰਜੀ RSAPUBLIC ਅਤੇ rsaSign ਸਤਰ ਨੂੰ ਇਨਪੁਟ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਹਸਤਾਖਰ ਦੀ ਵੈਧਤਾ ਲਈ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਜੇਕਰ ਜਾਂਚ ਸਫਲ ਹੁੰਦੀ ਹੈ ਤਾਂ ਨੰਬਰ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਨਹੀਂ ਤਾਂ, ਸਿਸਟਮ ਸਮਝਦਾ ਹੈ ਕਿ ਦਸਤਖਤ ਵੈਧ ਨਹੀਂ ਹਨ (ਅਵੈਧ RSA ਦਸਤਖਤ)।

ਸਰਵਰ ਨੂੰ ਇੱਕ ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀ ਨਾਲ ਗੇਮ ਆਈਡੀ 'ਤੇ ਦਸਤਖਤ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ ਅਤੇ 2880 ਬਲਾਕਾਂ ਦੇ ਅੰਦਰ ਇੱਕ ਵੈਧ Rsa ਦਸਤਖਤ ਭੇਜਣੇ ਚਾਹੀਦੇ ਹਨ। ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਤੈਨਾਤ ਕਰਦੇ ਸਮੇਂ ਪੈਰਾਮੀਟਰ ਕੌਂਫਿਗਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਨਿਰਧਾਰਤ ਸਮੇਂ ਦੇ ਅੰਦਰ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਉਪਭੋਗਤਾ ਜਿੱਤ ਜਾਂਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇਨਾਮ ਤੁਹਾਡੇ ਪਤੇ 'ਤੇ ਖੁਦ ਭੇਜਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ "ਸਰਵਰ ਨੂੰ ਧੋਖਾ ਦੇਣਾ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹੈ", ਕਿਉਂਕਿ ਇਸ ਨਾਲ ਨੁਕਸਾਨ ਹੁੰਦਾ ਹੈ। ਹੇਠਾਂ ਇੱਕ ਉਦਾਹਰਨ ਹੈ।

ਉਪਭੋਗਤਾ ਖੇਡ ਰਿਹਾ ਹੈ ਡਾਈਸ ਰੋਲਰ. ਮੈਂ ਘਣ ਦੇ 2 ਪਾਸਿਆਂ ਵਿੱਚੋਂ 6 ਨੂੰ ਚੁਣਿਆ ਹੈ, 14 ਤਰੰਗਾਂ ਹਨ। ਜੇਕਰ ਸਰਵਰ ਨਿਸ਼ਚਿਤ ਸਮੇਂ (2880 ਬਲਾਕ) ਦੇ ਅੰਦਰ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨੂੰ ਇੱਕ ਵੈਧ RSA ਦਸਤਖਤ ਨਹੀਂ ਭੇਜਦਾ ਹੈ, ਤਾਂ ਉਪਭੋਗਤਾ 34.44 ਵੇਵਜ਼ ਲਵੇਗਾ।

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

ਇਹ ਇੱਕ ਇਮਾਨਦਾਰ ਪੀੜ੍ਹੀ ਵਿਧੀ ਹੈ, ਕਿਉਂਕਿ ਹੇਰਾਫੇਰੀ ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ ਅਸੰਭਵ ਹੈ. ਸਾਰੀਆਂ Tradisys ਗੇਮਾਂ ਵਰਣਿਤ ਐਲਗੋਰਿਦਮ ਦੇ ਆਧਾਰ 'ਤੇ ਕੰਮ ਕਰਦੀਆਂ ਹਨ। ਬਲਾਕਚੈਨ ਗੇਮਾਂ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ। ਹਰ ਚੀਜ਼ ਪਾਰਦਰਸ਼ੀ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਹੈ। ਕਿਸੇ ਹੋਰ ਬਲਾਕਚੈਨ ਵਿੱਚ ਅਜਿਹੀ ਪ੍ਰਣਾਲੀ ਦੇ ਕੋਈ ਐਨਾਲਾਗ ਨਹੀਂ ਹਨ। ਇਹ ਇੱਕ ਨਿਰਪੱਖ ਬੇਤਰਤੀਬ ਹੈ.

ਸਰੋਤ: www.habr.com