using System;

using System.Numerics;

using NBitcoin;

using AngouriMath;

using AngouriMath.Extensions;

using AngouriMath.Functions;

​

class Program

{

    static void Main()

    {

        // Orden del grupo n para la curva secp256k1

        BigInteger n = BigInteger.Parse("115792089237316195423570985008687907852837564279074904382605163141518161494337");

​

        int primeCount = 0; // Contador de claves privadas que son números primos

​

        for (int i = 0; i < 1000; i++)

        {

            // Generar una clave privada aleatoria en el rango [1, n-1]

            BigInteger privateKey;

            do

            {

                privateKey = GenerateRandomBigInteger(256);

            } while (privateKey <= 0 || privateKey >= n);

​

            // Mostrar la clave privada

            Console.WriteLine($"Private Key: {privateKey}");

            Console.WriteLine("Clave Privada (hex): " + privateKey.ToString("X"));

​

            // Calcular el logaritmo en base 2 de la clave privada

            var y = MathS.Log(2, privateKey);

            Console.WriteLine($"Log Base 2: {y.EvalNumerical()}");

​

            // Verificar si la clave privada es un número primo

            bool isPrime = IsProbablyPrime(privateKey, 20); // 20 iteraciones para mayor precisión

            Console.WriteLine($"{privateKey} es primo: {isPrime}");

​

            // Incrementar el contador si es primo

            if (isPrime)

            {

                primeCount++;

            }

​

            Console.WriteLine("--------------------------------------------------------------");

        }

​

        // Imprimir el total de claves privadas que son números primos

        Console.WriteLine($"Total de claves privadas que son números primos: {primeCount}");

    }

​

    static BigInteger GenerateRandomBigInteger(int bitLength)

    {

        Random random = new Random();

        byte[] bytes = new byte[(bitLength + 7) / 8];

        random.NextBytes(bytes);

        bytes[bytes.Length - 1] &= (byte)(0xFF >> (bytes.Length * 8 - bitLength)); // Asegurar que el número está dentro del rango de bits

​

        return new BigInteger(bytes);

    }

​

    static bool IsProbablyPrime(BigInteger n, int k)

    {

        if (n <= 1) return false;

        if (n == 2 || n == 3) return true;

        if (n % 2 == 0) return false;

​

        BigInteger d = n - 1;

        int s = 0;

​

        while (d % 2 == 0)

        {

            d /= 2;

            s += 1;

        }

​

        Random rng = new Random();

​

        for (int i = 0; i < k; i++)

        {

            BigInteger a = RandomBigInteger(2, n - 2, rng);

            BigInteger x = BigInteger.ModPow(a, d, n);

​

            if (x == 1 || x == n - 1)

                continue;

​

            bool continueOuterLoop = false;

​

            for (int r = 1; r < s; r++)

            {

                x = BigInteger.ModPow(x, 2, n);

​

                if (x == 1)

                    return false;

​

                if (x == n - 1)

                {

                    continueOuterLoop = true;

                    break;

                }

            }

​

            if (!continueOuterLoop)

                return false;

        }

​

        return true;

    }

​

    static BigInteger RandomBigInteger(BigInteger min, BigInteger max, Random rng)

    {

        byte[] bytes = max.ToByteArray();

        BigInteger result;

​

        do

        {

            rng.NextBytes(bytes);

            bytes[bytes.Length - 1] &= 0x7F; // Fuerza signo positivo

            result = new BigInteger(bytes);

        } while (result < min || result > max);

​

        return result;

    }

}

​