Kanıtlanabilir Adalet

🔐 Adil Oyun Sistemi: Çoklu Oyunculu Hash Zinciri Oluşturma

Genel Bakış

Şeffaflığı ve kanıtlanabilir adaleti sağlamak için, SHA256 çıktısının 10 milyon kez kendisine geri beslendiği bir sunucu gizli anahtarıyla başlayarak her çoklu oyunculu oyun için 10 milyon SHA256 hash'inden oluşan bir zincir oluşturduk

Platform için son hash'in SHA256'sı: eeb4d340bfaed702601b9a08faba2f8088c4810c3e3a883293accaf25053b883

Crash için son hash'in SHA256'sı: c46f0705f6ba4df891ce44accda8f89f5a6fa8b987eb7c7b445280cf6cabfbc6

Battle için son hash'in SHA256'sı: 63cb1eb64ec4eb4de02f6bad85e42365d08f37497a1b7e907bd0b9183f27e1b3

Bunu burada yayınlayarak, alternatif bir SHA256 zinciri seçme yeteneğini engelliyoruz. Şimdi oyun sunucusu, oyun sonuçlarını kanıtlanabilir şekilde adil olarak hesaplamak için bu değerleri kullanarak bu hash zincirini ters sırada oynuyor.

Nasıl Çalışır

1. Gizli Başlangıç Hash'i: Her çoklu oyunculu oyun türünün kendi özel başlangıç hash'i vardır (yalnızca sunucu tarafından bilinir), benzersiz bir hash zincirinin kökünü oluşturur.

2. Hash Zinciri Oluşturma: Gizli başlangıç hash'inden, SHA256'yı tekrar tekrar uygulayarak 10.000.000 hash'lik bir zincir oluşturuyoruz.

  func HashSeed(seed string) string {
      hash := sha256.Sum256([]byte(seed))
      return hex.EncodeToString(hash[:])
  }

  func CalculateHashChain(firstHash string) []string {
    hashes := make([]string, 10_000_000)
    for i := int64(0); i <= 10_000_000; i++ {
      firstHash = HashSeed(firstHash)
      hashes[i] = firstHash
    }
    return hashes
  }

3. Ters Tüketim: Zincirdeki son hash'i kamuya açıklıyoruz. Her oyun turu hash'leri ters sırada tüketir: Tur 1, hash[10_000_000]'ı kullanır Tur 2, hash[9_999_999]'ı kullanır ve böyle devam eder…

4. Bu tasarım, gelecekteki hash'lerin sahtesini oluşturmayı imkansız kılarken, herkesin tüm önceki hash'leri doğrulamasına olanak tanır.

🔒 Güvenlik ve Adalet Avantajları

Öngörülemezlik: Gelecekteki oyun sonuçları, sunucu tarafından bile bilinemez veya etkilenemez.

Doğrulanabilirlik: Oyuncular, yalnızca kamuya açıklanan son hash'i kullanarak herhangi bir önceki turun bütünlüğünü doğrulayabilir.

Oyun İzolasyonu: Her oyun türünün kendi zinciri vardır, bu da oyunlar arası manipülasyonu önler.

Tek Oyunculu Oyunlar İçin Adil Oyun

Tek oyunculu oyunlarda kanıtlanabilir adaleti sağlamak için, platformumuz sonuç tohumunu oluşturmak için üç ana bileşene dayanan bir sistem kullanır:

1. İstemci Tohumu: Bu, kullanıcı tarafından kontrol edilen bir tohumdur. Bir kullanıcı kayıt olduğunda otomatik olarak oluşturulur, ancak kullanıcı bunu istediği zaman değiştirebilir. İstemci tohumunu değiştirmek, yeni bir sunucu tohumunun oluşturulmasını başlatır.

2. Sunucu Tohumu: Bu, kullanıcıya açıklanmayan dahili parametreler kullanılarak sunucu tarafından oluşturulur. Mevcut istemci tohumuna benzersiz şekilde bağlıdır. Her istemci tohumu için karşılık gelen bir sunucu tohumu vardır. Kullanıcı istemci tohumunu değiştirdiğinde, önceki sunucu tohumu doğrulama amacıyla açıklanır.

3. Nonce: Bahsin zaman damgasına (milisaniye cinsinden) dayanan benzersiz bir sayı. Tekrarlanan eylemlerin bile farklı sonuçlar üretmesini sağlar.

Oyun Tohumu Oluşturma

Bu üç değer birleştirilir ve nihai oyun tohumunu oluşturmak için HMAC-SHA256 kullanılarak hash'lenir, bu daha sonra oyunun sonucunu belirlemek için kullanılır.

  func GenerateUserGameSeed(userSeed string, userServerSeed string, nonce int64) (string, error) {
    data := fmt.Sprintf("%s:%s:%d", userServerSeed, userSeed, nonce)
    mac := hmac.New(sha256.New, []byte(data))
    gameSeed := hex.EncodeToString(mac.Sum(nil))
    return gameSeed, nil
  }

Doğrulama

Sunucu, herhangi bir bahis yapılmadan önce mevcut sunucu tohumunun hash'lenmiş versiyonunu sağlar.

Kullanıcı istemci tohumunu değiştirdikten sonra, önceden kullanılan sunucu tohumu açıklanır.

Bu, kullanıcıların önceki sunucu tohumuyla oluşturulan tüm sonuçların tutarlı ve adil olduğunu doğrulamasına olanak tanır.

🎲 Zar Oyunu – Sonuç Hesaplama

Zar oyununda, bir kullanıcı 1 ila 5 sayı arasından (6 olası taraftan) seçim yapar. Oluşturulan oyun tohumu kullanılarak tek bir zar atışı simüle edilir. Atılan sayı, kullanıcının seçimlerinden biriyle eşleşirse, kullanıcı kazanır.

  func rollDice(seed string, selectedNumbers []int64) (int64, bool, error) {
    if len(selectedNumbers) < 1 || len(selectedNumbers) > 5 {
      return 0, false, fmt.Errorf("incorrect number of selected numbers: %d", len(selectedNumbers))
    }

    bigSeed, ok := new(big.Int).SetString(seed, 16)
    if !ok {
      return 0, false, fmt.Errorf("failed to convert seed to big.Int")
    }

    // Simulate dice roll: number from 1 to 6
    dice := new(big.Int).Mod(bigSeed, big.NewInt(6))
    diceFace := dice.Int64() + 1

    for _, num := range selectedNumbers {
      if num == diceFace {
        return diceFace, true, nil
      }
    }

    return diceFace, false, nil
  }

💣 Mines Oyunu – Mayın Yerleştirme Mantığı

Mines oyununda amaç, bir mayına çarpmadan mümkün olduğunca çok kareyi açmaktır. Mayınların yerleştirilmesi, kriptografik olarak güvenli bir oyun tohumu kullanılarak deterministik olarak türetilir. Bu, adaleti ve şeffaflığı sağlar ve kullanıcının oyun tahtasının manipüle edilmediğini doğrulamasına olanak tanır.

Girdiler:

seed: ClientSeed, ServerSeed ve Nonce'un HMAC-SHA256 kullanılarak birleşiminden türetilen 64 karakterlik bir hex dizesi.

numberOfMines: tahtaya yerleştirilecek mayın sayısı.

maxCells: tahtadaki toplam kare sayısı (örneğin, 5x5'lik bir ızgara için 25).

Go Kodu

func generateMines(seedHex string, numberOfMines int) ([]int64, error) {
	if numberOfMines > 25 {
		return nil, fmt.Errorf("invalid number of mines: %d", numberOfMines)
	}

	var mines []int64
	used := make(map[int]bool)
	i := 0

	for len(mines) < numberOfMines {
		mac := hmac.New(sha256.New, []byte(seedHex))
		mac.Write([]byte(fmt.Sprintf("mine-%d", i)))
		sum := mac.Sum(nil)

		val := binary.BigEndian.Uint32(sum)
		pos := int(val%25) + 1

		if !used[pos] {
			used[pos] = true
			mines = append(mines, int64(pos))
		}
		i++
	}

	return mines, nil
}

Örnek

numberOfMines = 3 ve maxCells = 25 ise, fonksiyon mayınların yerleştirildiği 3 benzersiz kare indeksini (1'den 25'e kadar) deterministik olarak döndürecektir.

🕹 Platforms — Oyun Mantığı

Platforms oyununda, her turun sonucu, önceden yayınlanmış bir hash zincirinin parçası olan kamuya açık, doğrulanabilir bir hash tarafından belirlenir.

📌 Platform Düşüş Mantığı

Her tur, "son platformu" - oyunun sonunda kaybolacak platformu - belirlemek için zincirden bir hash kullanır.

    func generateLastPlatform(hash string) (int64, error) {
      h, err := hex.DecodeString(hash)
      if err != nil {
        return 0, err
      }

      number := binary.BigEndian.Uint64(h[:8])

      rng := rand.New(rand.NewSource(int64(number)))
      randomNumber := rng.Intn(25) + 1 // Platforms are numbered 1 through 25

      return int64(randomNumber), nil
    }

🎯 Gerçek Zamanlı Platform Düşüşü

Oyun oynanışı sırasında, oyuncular farklı platformlarda dururlar. Düşen platform, mevcut platformlar arasından rastgele seçilir ve önceden düşen platformla asla aynı olmaması sağlanır.

🚀 Rocket — Oyun Mantığı

Rocket'ta, her tur sonucu (çarpma katsayısı), önceden oluşturulmuş hash zincirinden (her oyuna özel) kamuya açık bir hash kullanılarak belirlenir. Sonuç, hash'i bir katsayıya dönüştüren deterministik bir fonksiyon kullanılarak hesaplanır.

  func generateMultiplier(hash string) (float64, error) {
    const N = 40

    bigH, ok := new(big.Int).SetString(hash, 16)
    if !ok {
      return 0, fmt.Errorf("failed to convert seed to big.Int")
    }

    mod := new(big.Int).Mod(bigH, big.NewInt(N))
    if mod.Cmp(big.NewInt(0)) == 0 {
      return 1, nil
    }

    if len(hash) < 13 {
      return 0, fmt.Errorf("hash too short")
    }
    h13Str := hash[:13]
    bigH13, ok := new(big.Int).SetString(h13Str, 16)
    if !ok {
      return 0, fmt.Errorf("failed to convert first 13 hex digits to big.Int")
    }

    // Compute 100 * (2^52 - h) / (2^52 - h)
    e := new(big.Int).Lsh(big.NewInt(1), 52) // 2^52
    hundred := big.NewInt(100)
    hundredE := new(big.Int).Mul(hundred, e)
    numerator := new(big.Int).Sub(hundredE, bigH13)
    denom := new(big.Int).Sub(e, bigH13)

    numFloat := new(big.Float).SetInt(numerator)
    denomFloat := new(big.Float).SetInt(denom)
    ratio, _ := new(big.Float).Quo(numFloat, denomFloat).Float64()

    floored := math.Floor(ratio)
    result := floored / 100.0

    return result, nil
  }

Her oyuncu turdan önce hash'i alır ve sonucun yayınlanan formülle eşleştiğini bağımsız olarak doğrulayabilir, bu da tam şeffaflık ve kanıtlanabilir adaleti sağlar.

🎲 Battle — Ağırlıklı Rulet Adaleti

Battle'da, bir oyuncu, bahsinin toplam havuza oranına göre kazanan olarak seçilir. Bu, daha büyük bahislerin daha yüksek kazanma şansıyla sonuçlandığı anlamına gelir.

Deterministik ve kanıtlanabilir şekilde adil bir seçim mekanizması kullanıyoruz:

1. [0.0, 1.0) aralığında sözde rastgele bir sayı oluşturmak için kamuya açık bir oyun hash'i kullanılır.

2. Her oyuncuya, bahsiyle orantılı bir aralık segmenti atanır (örneğin, %20'lik bir bahis, aralığın %20'sini kapsar).

3. Rastgele sayı, kazanan segmenti ve dolayısıyla kazananı belirler.

  func pickWinner(hash string, chances []float64) (int, error) {
    if len(chances) == 0 {
      return -1, fmt.Errorf("zero participants")
    }

    total := 0.0
    for _, chance := range chances {
      if chance < 0 {
        return -1, fmt.Errorf("chance cannot be negative")
      }
      total += chance
    }

    if total < 99.99 || total > 100.01 {
      return -1, fmt.Errorf("sum of chances must be 100%%, got: %.2f%%", total)
    }

    randomValue, err := deterministicFloatFromHash(hash)
    if err != nil {
      return -1, fmt.Errorf("random generation failed: %w", err)
    }

    cumulative := 0.0
    for i, chance := range chances {
      cumulative += chance / 100.0
      if randomValue < cumulative {
        return i, nil
      }
    }

    return -1, fmt.Errorf("failed to pick winner")
  }

  func deterministicFloatFromHash(hash string) (float64, error) {
    bytes, err := hex.DecodeString(hash)
    if err != nil {
      return 0, err
    }
    if len(bytes) < 8 {
      return 0, fmt.Errorf("hash too short")
    }
    num := binary.BigEndian.Uint64(bytes[:8])
    return float64(num) / float64(math.MaxUint64), nil
  }