Optimize variable name

Author: mohanson

doc/en/markdown/content/prikey_crypto_ecdsa.md

@@ -32,21 +32,22 @@ import pabtc.secp256k1
 def sign(prikey: pabtc.secp256k1.Fr, m: pabtc.secp256k1.Fr) -> typing.Tuple[pabtc.secp256k1.Fr, pabtc.secp256k1.Fr, int]:
     # https://www.secg.org/sec1-v2.pdf
     # 4.1.3 Signing Operation
-    for _ in itertools.repeat(0):
+    for _ in range(64):
         k = pabtc.secp256k1.Fr(max(1, secrets.randbelow(pabtc.secp256k1.N)))
         R = pabtc.secp256k1.G * k
-        r = pabtc.secp256k1.Fr(R.x.x)
-        if r.x == 0:
+        r = pabtc.secp256k1.Fr(R.x.n)
+        if r.n == 0:
             continue
         s = (m + prikey * r) / k
-        if s.x == 0:
+        if s.n == 0:
             continue
         v = 0
-        if R.y.x & 1 == 1:
+        if R.y.n & 1 == 1:
             v |= 1
-        if R.x.x >= pabtc.secp256k1.N:
+        if R.x.n >= pabtc.secp256k1.N:
             v |= 2
         return r, s, v
+    raise Exception('unreachable')
 ```
 
 You may notice in the code implementation that the signature function not only returns (r, s), but also returns an additional v value. This is the recovery identifier used to determine the signer's public key from the signature. It uses two bits, the lowest bit marks the parity of the y-axis coordinate of c, so that we can uniquely recover the actual value of c based on r in the signature (elliptic curves are symmetric with respect to the x-axis, and each x corresponds to two possible y-values). Another bit is used to verify that the r value has not overflowed, because the range of coordinates of points on the elliptic curve is 0 to P, but in the signature operation we convert the x-coordinate of c to a scalar, which reduces the range to 0 to N, and therefore overflow truncation may occur.
@@ -81,7 +82,7 @@ def verify(pubkey: pabtc.secp256k1.Pt, m: pabtc.secp256k1.Fr, r: pabtc.secp256k1
     b = r / s
     R = pabtc.secp256k1.G * a + pubkey * b
     assert R != pabtc.secp256k1.I
-    return r == pabtc.secp256k1.Fr(R.x.x)
+    return r == pabtc.secp256k1.Fr(R.x.n)
 ```
 
 ## ECDSA Public Key Recovery

doc/en/markdown/content/prikey_crypto_eddsa.md

@@ -18,7 +18,7 @@ def pt_encode(pt: pxsol.ed25519.Pt) -> bytearray:
     # To form the encoding of the point, copy the least significant bit of the x-coordinate to the most significant bit
     # of the final octet.
     # See https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.2
-    n = pt.y.x | ((pt.x.x & 1) << 255)
+    n = pt.y.n | ((pt.x.n & 1) << 255)
     return bytearray(n.to_bytes(32, 'little'))
 ```
 

doc/en/markdown/content/prikey_crypto_secp256k1.md

@@ -255,6 +255,6 @@ import pabtc
 
 prikey = pabtc.secp256k1.Fr(0x5f6717883bef25f45a129c11fcac1567d74bda5a9ad4cbffc8203c0da2a1473c)
 pubkey = pabtc.secp256k1.G * prikey
-assert(pubkey.x.x == 0xfb95541bf75e809625f860758a1bc38ac3c1cf120d899096194b94a5e700e891)
-assert(pubkey.y.x == 0xc7b6277d32c52266ab94af215556316e31a9acde79a8b39643c6887544fdf58c)
+assert(pubkey.x.n == 0xfb95541bf75e809625f860758a1bc38ac3c1cf120d899096194b94a5e700e891)
+assert(pubkey.y.n == 0xc7b6277d32c52266ab94af215556316e31a9acde79a8b39643c6887544fdf58c)
 ```

doc/zh/markdown/content/prikey_crypto_ecdsa.md

@@ -32,21 +32,22 @@ import pabtc.secp256k1
 def sign(prikey: pabtc.secp256k1.Fr, m: pabtc.secp256k1.Fr) -> typing.Tuple[pabtc.secp256k1.Fr, pabtc.secp256k1.Fr, int]:
     # https://www.secg.org/sec1-v2.pdf
     # 4.1.3 Signing Operation
-    for _ in itertools.repeat(0):
+    for _ in range(64):
         k = pabtc.secp256k1.Fr(max(1, secrets.randbelow(pabtc.secp256k1.N)))
         R = pabtc.secp256k1.G * k
-        r = pabtc.secp256k1.Fr(R.x.x)
-        if r.x == 0:
+        r = pabtc.secp256k1.Fr(R.x.n)
+        if r.n == 0:
             continue
         s = (m + prikey * r) / k
-        if s.x == 0:
+        if s.n == 0:
             continue
         v = 0
-        if R.y.x & 1 == 1:
+        if R.y.n & 1 == 1:
             v |= 1
-        if R.x.x >= pabtc.secp256k1.N:
+        if R.x.n >= pabtc.secp256k1.N:
             v |= 2
         return r, s, v
+    raise Exception('unreachable')
 ```
 
 您可能发现在代码实现上, 签名函数不但返回了 (r, s), 还额外返回了一个 v 值. 这是恢复标识符, 用于从签名中确定签名者的公钥. 它使用了两个标志位, 最低标识位标志 c 的 y 轴坐标的奇偶位, 以便我们可以根据签名中的 r 来唯一还原 c 的实际值(椭圆曲线是关于 x 轴对称的曲线, 每一个 x 都对应两个可能的 y 值). 另一个比特位用于确认 r 值是否发生过溢出, 因为椭圆曲线上的点的坐标范围是 0 到 P, 但在签名运算中我们会将 c 的 x 坐标转换为一个标量, 范围将缩小到 0 到 N, 因此可能会发生溢出截断.
@@ -81,7 +82,7 @@ def verify(pubkey: pabtc.secp256k1.Pt, m: pabtc.secp256k1.Fr, r: pabtc.secp256k1
     b = r / s
     R = pabtc.secp256k1.G * a + pubkey * b
     assert R != pabtc.secp256k1.I
-    return r == pabtc.secp256k1.Fr(R.x.x)
+    return r == pabtc.secp256k1.Fr(R.x.n)
 ```
 
 ## Ecdsa 公钥恢复

doc/zh/markdown/content/prikey_crypto_eddsa.md

@@ -19,7 +19,7 @@ def pt_encode(pt: pxsol.ed25519.Pt) -> bytearray:
     # To form the encoding of the point, copy the least significant bit of the x-coordinate to the most significant bit
     # of the final octet.
     # See https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.2
-    n = pt.y.x | ((pt.x.x & 1) << 255)
+    n = pt.y.n | ((pt.x.n & 1) << 255)
     return bytearray(n.to_bytes(32, 'little'))
 ```
 

doc/zh/markdown/content/prikey_crypto_secp256k1.md

@@ -253,6 +253,6 @@ import pabtc
 
 prikey = pabtc.secp256k1.Fr(0x5f6717883bef25f45a129c11fcac1567d74bda5a9ad4cbffc8203c0da2a1473c)
 pubkey = pabtc.secp256k1.G * prikey
-assert(pubkey.x.x == 0xfb95541bf75e809625f860758a1bc38ac3c1cf120d899096194b94a5e700e891)
-assert(pubkey.y.x == 0xc7b6277d32c52266ab94af215556316e31a9acde79a8b39643c6887544fdf58c)
+assert(pubkey.x.n == 0xfb95541bf75e809625f860758a1bc38ac3c1cf120d899096194b94a5e700e891)
+assert(pubkey.y.n == 0xc7b6277d32c52266ab94af215556316e31a9acde79a8b39643c6887544fdf58c)
 ```

pxsol/ed25519.py

@@ -9,43 +9,43 @@ class Fp:
 
     p = 0
 
-    def __init__(self, x: int) -> None:
-        self.x = x % self.p
+    def __init__(self, n: int) -> None:
+        self.n = n % self.p
 
     def __add__(self, data: typing.Self) -> typing.Self:
         assert self.p == data.p
-        return self.__class__(self.x + data.x)
+        return self.__class__(self.n + data.n)
 
     def __eq__(self, data: object) -> bool:
         assert isinstance(data, self.__class__)
         assert self.p == data.p
-        return self.x == data.x
+        return self.n == data.n
 
     def __mul__(self, data: typing.Self) -> typing.Self:
         assert self.p == data.p
-        return self.__class__(self.x * data.x)
+        return self.__class__(self.n * data.n)
 
     def __neg__(self) -> typing.Self:
-        return self.__class__(self.p - self.x)
+        return self.__class__(self.p - self.n)
 
     def __repr__(self) -> str:
         return json.dumps(self.json())
 
     def __sub__(self, data: typing.Self) -> typing.Self:
         assert self.p == data.p
-        return self.__class__(self.x - data.x)
+        return self.__class__(self.n - data.n)
 
     def __truediv__(self, data: typing.Self) -> typing.Self:
         return self * data ** -1
 
     def __pos__(self) -> typing.Self:
-        return self.__class__(self.x)
+        return self.__class__(self.n)
 
     def __pow__(self, data: int) -> typing.Self:
-        return self.__class__(pow(self.x, data, self.p))
+        return self.__class__(pow(self.n, data, self.p))
 
     def json(self) -> str:
-        return f'{self.x:064x}'
+        return f'{self.n:064x}'
 
     @classmethod
     def nil(cls) -> typing.Self:
@@ -115,7 +115,7 @@ def __add__(self, data: typing.Self) -> typing.Self:
     def __mul__(self, k: Fr) -> Pt:
         # Point multiplication: Double-and-add
         # https://en.wikipedia.org/wiki/Elliptic_curve_point_multiplication
-        n = k.x
+        n = k.n
         result = I
         addend = self
         while n:

pxsol/eddsa.py

@@ -15,7 +15,7 @@ def pt_encode(pt: pxsol.ed25519.Pt) -> bytearray:
     # To form the encoding of the point, copy the least significant bit of the x-coordinate to the most significant bit
     # of the final octet.
     # See https://datatracker.ietf.org/doc/html/rfc8032#section-5.1.2
-    n = pt.y.x | ((pt.x.x & 1) << 255)
+    n = pt.y.n | ((pt.x.n & 1) << 255)
     return bytearray(n.to_bytes(32, 'little'))
 
 
@@ -48,7 +48,7 @@ def pt_decode(pt: bytearray) -> pxsol.ed25519.Pt:
     # Finally, use the x_0 bit to select the right square root. If x = 0, and x_0 = 1, decoding fails. Otherwise, if
     # x_0 != x mod 2, set x <-- p - x.  Return the decoded point (x,y).
     assert x != pxsol.ed25519.Fq(0) or not bit0
-    if x.x & 1 != bit0:
+    if x.n & 1 != bit0:
         x = -x
     return pxsol.ed25519.Pt(x, y)
 
@@ -101,7 +101,7 @@ def sign(prikey: bytearray, m: bytearray) -> bytearray:
     digest = pt_encode(R)
     h = pxsol.ed25519.Fr(int.from_bytes(hash(digest + pubkey + m), 'little'))
     s = r + a * h
-    return digest + bytearray(s.x.to_bytes(32, 'little'))
+    return digest + bytearray(s.n.to_bytes(32, 'little'))
 
 
 def verify(pubkey: bytearray, m: bytearray, v: bytearray) -> bool:

test/test_ed25519.py

@@ -3,11 +3,11 @@
 
 def test_g():
     q = pxsol.ed25519.G * pxsol.ed25519.Fr(1)
-    assert q.x.x == 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a
-    assert q.y.x == 0x6666666666666666666666666666666666666666666666666666666666666658
+    assert q.x.n == 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a
+    assert q.y.n == 0x6666666666666666666666666666666666666666666666666666666666666658
     q = pxsol.ed25519.G * pxsol.ed25519.Fr(2)
-    assert q.x.x == 0x36ab384c9f5a046c3d043b7d1833e7ac080d8e4515d7a45f83c5a14e2843ce0e
-    assert q.y.x == 0x2260cdf3092329c21da25ee8c9a21f5697390f51643851560e5f46ae6af8a3c9
+    assert q.x.n == 0x36ab384c9f5a046c3d043b7d1833e7ac080d8e4515d7a45f83c5a14e2843ce0e
+    assert q.y.n == 0x2260cdf3092329c21da25ee8c9a21f5697390f51643851560e5f46ae6af8a3c9
     q = pxsol.ed25519.G * pxsol.ed25519.Fr(3)
-    assert q.x.x == 0x67ae9c4a22928f491ff4ae743edac83a6343981981624886ac62485fd3f8e25c
-    assert q.y.x == 0x1267b1d177ee69aba126a18e60269ef79f16ec176724030402c3684878f5b4d4
+    assert q.x.n == 0x67ae9c4a22928f491ff4ae743edac83a6343981981624886ac62485fd3f8e25c
+    assert q.y.n == 0x1267b1d177ee69aba126a18e60269ef79f16ec176724030402c3684878f5b4d4