Add Point type with addition, doubling, scalar multiplication

1 files changed, 195 insertions, 0 deletions

diff --git a/point_test.go b/point_test.go
new file mode 100644
index 0000000..ba12977
--- /dev/null
+++ b/point_test.go
@@ -0,0 +1,195 @@
+package main
+
+import (
+        "math/big"
+        "testing"
+)
+
+func TestGeneratorIsOnCurve(t *testing.T) {
+        if !G.IsOnCurve() {
+                t.Error("generator point G should be on the curve")
+        }
+}
+
+func TestInfinityIsOnCurve(t *testing.T) {
+        inf := Infinity()
+        if !inf.IsOnCurve() {
+                t.Error("point at infinity should be considered on curve")
+        }
+}
+
+func TestPointNotOnCurve(t *testing.T) {
+        // (1, 1) is not on y² = x³ + 7
+        // y² = 1, x³ + 7 = 8, so 1 ≠ 8
+        x := NewFieldElementFromInt64(1)
+        y := NewFieldElementFromInt64(1)
+        _, err := NewPoint(x, y)
+        if err == nil {
+                t.Error("(1, 1) should not be on the curve")
+        }
+}
+
+func TestAddInfinity(t *testing.T) {
+        inf := Infinity()
+
+        // G + infinity = G
+        result := G.Add(inf)
+        if !result.Equal(G) {
+                t.Error("G + infinity should equal G")
+        }
+
+        // infinity + G = G
+        result = inf.Add(G)
+        if !result.Equal(G) {
+                t.Error("infinity + G should equal G")
+        }
+
+        // infinity + infinity = infinity
+        result = inf.Add(inf)
+        if !result.IsInfinity() {
+                t.Error("infinity + infinity should be infinity")
+        }
+}
+
+func TestAddInverseGivesInfinity(t *testing.T) {
+        // G + (-G) = infinity
+        negG := G.Negate()
+        result := G.Add(negG)
+        if !result.IsInfinity() {
+                t.Error("G + (-G) should be infinity")
+        }
+}
+
+func TestDoubleGenerator(t *testing.T) {
+        // 2G should be on the curve
+        twoG := G.Double()
+        if !twoG.IsOnCurve() {
+                t.Error("2G should be on the curve")
+        }
+
+        // 2G should not be infinity
+        if twoG.IsInfinity() {
+                t.Error("2G should not be infinity")
+        }
+
+        // 2G should not equal G
+        if twoG.Equal(G) {
+                t.Error("2G should not equal G")
+        }
+}
+
+func TestAddEqualsDouble(t *testing.T) {
+        // G + G should equal G.Double()
+        sum := G.Add(G)
+        doubled := G.Double()
+        if !sum.Equal(doubled) {
+                t.Error("G + G should equal 2G")
+        }
+}
+
+func TestScalarMulByOne(t *testing.T) {
+        // 1 * G = G
+        one := big.NewInt(1)
+        result := G.ScalarMul(one)
+        if !result.Equal(G) {
+                t.Error("1 * G should equal G")
+        }
+}
+
+func TestScalarMulByTwo(t *testing.T) {
+        // 2 * G = G + G
+        two := big.NewInt(2)
+        result := G.ScalarMul(two)
+        expected := G.Double()
+        if !result.Equal(expected) {
+                t.Error("2 * G should equal G.Double()")
+        }
+}
+
+func TestScalarMulByThree(t *testing.T) {
+        // 3 * G = G + G + G
+        three := big.NewInt(3)
+        result := G.ScalarMul(three)
+        expected := G.Double().Add(G)
+        if !result.Equal(expected) {
+                t.Error("3 * G should equal 2G + G")
+        }
+
+        // Result should be on curve
+        if !result.IsOnCurve() {
+                t.Error("3G should be on the curve")
+        }
+}
+
+func TestScalarMulByN(t *testing.T) {
+        // N * G = infinity (curve order)
+        result := G.ScalarMul(N)
+        if !result.IsInfinity() {
+                t.Error("N * G should be infinity (curve order)")
+        }
+}
+
+func TestScalarMulAssociative(t *testing.T) {
+        // (a * b) * G = a * (b * G)
+        a := big.NewInt(7)
+        b := big.NewInt(11)
+        ab := new(big.Int).Mul(a, b) // 77
+
+        left := G.ScalarMul(ab)
+        right := G.ScalarMul(b).ScalarMul(a)
+
+        if !left.Equal(right) {
+                t.Error("scalar multiplication should be associative")
+        }
+}
+
+func TestNegateOnCurve(t *testing.T) {
+        negG := G.Negate()
+        if !negG.IsOnCurve() {
+                t.Error("-G should be on the curve")
+        }
+}
+
+func TestDoubleNegateEqualsOriginal(t *testing.T) {
+        // -(-G) = G
+        result := G.Negate().Negate()
+        if !result.Equal(G) {
+                t.Error("-(-G) should equal G")
+        }
+}
+
+func TestPointEquality(t *testing.T) {
+        // Same point should be equal
+        if !G.Equal(G) {
+                t.Error("G should equal itself")
+        }
+
+        // Different points should not be equal
+        twoG := G.Double()
+        if G.Equal(twoG) {
+                t.Error("G should not equal 2G")
+        }
+
+        // Infinity equals infinity
+        inf1 := Infinity()
+        inf2 := Infinity()
+        if !inf1.Equal(inf2) {
+                t.Error("infinity should equal infinity")
+        }
+}
+
+// Known test vector from Bitcoin
+func TestKnownVector2G(t *testing.T) {
+        // 2G has known coordinates (verified against bitcoin wiki)
+        expectedX, _ := new(big.Int).SetString("C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5", 16)
+        expectedY, _ := new(big.Int).SetString("1AE168FEA63DC339A3C58419466CEAEEF7F632653266D0E1236431A950CFE52A", 16)
+
+        twoG := G.Double()
+
+        if twoG.x.value.Cmp(expectedX) != 0 {
+                t.Errorf("2G.x = %s, want %x", twoG.x.String(), expectedX)
+        }
+        if twoG.y.value.Cmp(expectedY) != 0 {
+                t.Errorf("2G.y = %s, want %x", twoG.y.String(), expectedY)
+        }
+}