1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.20;
3

4
contract CurveValidatorPlus {
5
    uint256 constant W0x = 7590971729312603494;
6
    uint256 constant W0y = 4025301139565492703;
7
    uint256[] public X = [
8
        2454386166295847726,
9
        1394489484373924978,
10
        61603571658607611,
11
        9993263628066138196,
12
        1304331519679318216,
13
        10202137592169949396,
14
        348470280807485805
15
    ];
16

17
    bool public isSolved;
18

19
    function modExp(uint256 base, uint256 exp, uint256 mod) public pure returns (uint256) {
20
        uint256 result = 1;
21
        base = base % mod;
22
        while (exp > 0) {
23
            if (exp % 2 == 1) {
24
                result = (result * base) % mod;
25
            }
26
            exp = exp >> 1;
27
            base = (base * base) % mod;
28
        }
29
        return result;
30
    }
31

32
    function isValidParams(uint256 p, uint256 A, uint256 B) public pure returns (bool) {
33
        if (p <= 2**63 || p >= 2**64) {
34
            return false;
35
        }
36

37
        if (A < p / 2 || A >= p || B < p / 2 || B >= p) {
38
            return false;
39
        }
40

41
        if ((4 * A**3 + 27 * B**2) % p == 0) {
42
            return false;
43
        }
44

45
        return true;
46
    }
47

48
    function isPointOnCurve(uint256 x, uint256 y, uint256 A, uint256 B, uint256 p) public pure returns (bool) {
49
        return (y**2) % p == (x**3 + A*x + B) % p;
50
    }
51

52
    function pointAdd(
53
        uint256 x1, uint256 y1,
54
        uint256 x2, uint256 y2,
55
        uint256 A, uint256 /*B*/, uint256 p
56
    ) public pure returns (uint256 x3, uint256 y3) {
57
        if (x1 == x2 && y1 == y2) {
58
            uint256 s = (3 * x1**2 + A) * modInverse(2 * y1, p) % p;
59
            x3 = (s**2 - 2 * x1) % p;
60
            y3 = (s * (p + x1 - x3) - y1) % p;
61
        } else {
62
            uint256 s = (p + y2 - y1) * modInverse(p + x2 - x1, p) % p;
63
            x3 = (s**2 - x1 - x2) % p;
64
            y3 = (s * (p + x1 - x3) - y1) % p;
65
        }
66
    }
67

68
    function modInverse(uint256 a, uint256 p) public pure returns (uint256) {
69
        return power(a, p - 2, p);
70
    }
71

72
    function power(uint256 a, uint256 b, uint256 p) public pure returns (uint256) {
73
        uint256 result = 1;
74
        a = a % p;
75
        while (b > 0) {
76
            if (b % 2 == 1) {
77
                result = (result * a) % p;
78
            }
79
            a = (a * a) % p;
80
            b = b / 2;
81
        }
82
        return result;
83
    }
84

85
    function validate(uint256 p, uint256 A, uint256 B, uint256 Gx, uint256 Gy) public {
86
        require(isValidParams(p, A, B), "Invalid parameters");
87
        require(isPointOnCurve(Gx, Gy, A, B, p), "Point G is not on the curve");
88

89
        uint256 x;
90
        uint256 y;
91
        (x, y) = (W0x, W0y);
92
        for (uint256 n = 1; n <= 7; n++) {
93
            (x, y) = pointAdd(x, y, Gx, Gy, A, B, p);
94
            require(x == X[n-1], "Mismatch in x-coordinates for n");
95
        }
96

97
        isSolved = true;
98
    }
99
}

1
function validator(uint256 p, uint256 A, uint256 B, uint256 Gx, uint256 Gy) public {
2
  require(isValidParams(p, A, B), "Invalid parameters");
3
  require(isPointOnCurve(Gx, Gy, A, B, p), "Point G is not on the curve");
4

5
  uint256 x;
6
  uint256 y;
7
  (x, y) = (W0x, W0y);
8
  for (uint256 n = 1; n <= 7; n++) {
9
    (x, y) = pointAdd(x, y, Gx, Gy, A, B, p);
10
    require(x == X[n-1], "Mismatch in x-coordinates for n");
11
  }
12

13
  isSolved = true;
14
}