refactor: rename struct

Author: heueristik

contracts/src/ProtocolAdapter.sol

@@ -35,7 +35,7 @@ contract ProtocolAdapter is
     CommitmentTree,
     NullifierSet
 {
-    using Delta for Delta.CurvePoint;
+    using Delta for Delta.Point;
     using MerkleTree for bytes32[];
     using Logic for Logic.VerifierInput[];
     using Logic for Logic.VerifierInput;
@@ -61,7 +61,7 @@ contract ProtocolAdapter is
         bytes32[] tags;
         bytes32[] logicRefs;
         bytes32 latestCommitmentTreeRoot;
-        Delta.CurvePoint transactionDelta;
+        Delta.Point transactionDelta;
         uint256 tagCounter;
         /* Proof aggregation-related variables */
         bool isProofAggregated;
@@ -146,7 +146,7 @@ contract ProtocolAdapter is
                 // Add the unit delta to the transaction delta.
                 vars.transactionDelta = vars.transactionDelta
                     .add(
-                        Delta.CurvePoint({
+                        Delta.Point({
                             x: uint256(complianceVerifierInput.instance.unitDeltaX),
                             y: uint256(complianceVerifierInput.instance.unitDeltaY)
                         })

contracts/src/libs/proving/Delta.sol

@@ -10,12 +10,12 @@ import {EfficientHashLib} from "@solady/utils/EfficientHashLib.sol";
 /// @notice A library containing methods of the delta proving system.
 /// @custom:security-contact [email protected]
 library Delta {
-    using Delta for CurvePoint;
+    using Delta for Point;
 
     /// @notice An elliptic curve point representing a delta value.
     /// @param x The x component of the point.
     /// @param y The y component of the point.
-    struct CurvePoint {
+    struct Point {
         uint256 x;
         uint256 y;
     }
@@ -39,19 +39,19 @@ library Delta {
     error DeltaMismatch(address expected, address actual);
 
     /// @notice Thrown when a provided point is not on the curve.
-    error PointNotOnCurve(CurvePoint point);
+    error PointNotOnCurve(Point point);
 
     /// @notice Returns the elliptic curve point representing the zero delta.
     /// @return zeroDelta The zero delta.
-    function zero() internal pure returns (CurvePoint memory zeroDelta) {
-        zeroDelta = CurvePoint({x: 0, y: 0});
+    function zero() internal pure returns (Point memory zeroDelta) {
+        zeroDelta = Point({x: 0, y: 0});
     }
 
     /// @notice Adds two elliptic curve points and returns the resulting value.
     /// @param p1 The first curve point.
     /// @param p2 The second curve point.
     /// @return sum The resulting curve point.
-    function add(CurvePoint memory p1, CurvePoint memory p2) internal pure returns (CurvePoint memory sum) {
+    function add(Point memory p1, Point memory p2) internal pure returns (Point memory sum) {
         if (!EllipticCurve.isOnCurve({_x: p2.x, _y: p2.y, _aa: _AA, _bb: _BB, _pp: _PP})) {
             revert PointNotOnCurve(p2);
         }
@@ -62,7 +62,7 @@ library Delta {
     /// @notice Converts an elliptic curve point to an Ethereum account address.
     /// @param delta The elliptic curve point.
     /// @return account The associated account.
-    function toAccount(CurvePoint memory delta) internal pure returns (address account) {
+    function toAccount(Point memory delta) internal pure returns (address account) {
         // Hash the public key with Keccak-256.
         bytes32 hashedKey = EfficientHashLib.hash(delta.x, delta.y);
 
@@ -82,7 +82,7 @@ library Delta {
     /// @param proof The delta proof.
     /// @param instance The transaction delta.
     /// @param verifyingKey The Keccak-256 hash of all nullifiers and commitments as ordered in the compliance units.
-    function verify(bytes memory proof, CurvePoint memory instance, bytes32 verifyingKey) internal pure {
+    function verify(bytes memory proof, Point memory instance, bytes32 verifyingKey) internal pure {
         // Verify the delta proof using the ECDSA.recover API to obtain the address
         address recovered = ECDSA.recover({hash: verifyingKey, signature: proof});
 

contracts/test/libs/DeltaGen.sol

@@ -49,7 +49,7 @@ library DeltaGen {
     /// @return instance The delta instance corresponding to the parameters
     function generateInstance(VmSafe vm, InstanceInputs memory deltaInputs)
         internal
-        returns (Delta.CurvePoint memory instance)
+        returns (Delta.Point memory instance)
     {
         deltaInputs.valueCommitmentRandomness = deltaInputs.valueCommitmentRandomness.modOrder();
         if (deltaInputs.valueCommitmentRandomness == 0) {
@@ -69,7 +69,7 @@ library DeltaGen {
         VmSafe.Wallet memory valueWallet = vm.createWallet(preDelta);
 
         // Extract the transaction delta from the wallet
-        instance = Delta.CurvePoint({x: valueWallet.publicKeyX, y: valueWallet.publicKeyY});
+        instance = Delta.Point({x: valueWallet.publicKeyX, y: valueWallet.publicKeyY});
     }
 
     /// @notice Generates a transaction delta proof by signing verifyingKey with

contracts/test/libs/EllipticCurve.t.sol

@@ -107,8 +107,7 @@ contract EllipticCurvePropertiesTest is Test {
             EllipticCurve.ecAdd({_x1: x, _y1: y, _x2: invX, _y2: invY, _aa: Delta._AA, _pp: Delta._PP});
 
         assertTrue(
-            _isPointAtInfinity(Delta.CurvePoint(resultX, resultY)),
-            "GROUP PROPERTY: P + (-P) must equal point at infinity"
+            _isPointAtInfinity(Delta.Point(resultX, resultY)), "GROUP PROPERTY: P + (-P) must equal point at infinity"
         );
     }
 
@@ -168,7 +167,7 @@ contract EllipticCurvePropertiesTest is Test {
             EllipticCurve.ecAdd({_x1: x1, _y1: y1, _x2: x2, _y2: y2, _aa: Delta._AA, _pp: Delta._PP});
 
         // Result must be on curve or at infinity
-        bool atInfinity = _isPointAtInfinity(Delta.CurvePoint(resultX, resultY));
+        bool atInfinity = _isPointAtInfinity(Delta.Point(resultX, resultY));
         bool onCurve =
             EllipticCurve.isOnCurve({_x: resultX, _y: resultY, _aa: Delta._AA, _bb: Delta._BB, _pp: Delta._PP});
 
@@ -188,7 +187,7 @@ contract EllipticCurvePropertiesTest is Test {
 
         // P + (-P) should equal point at infinity
         assertTrue(
-            _isPointAtInfinity(Delta.CurvePoint(rx, ry)),
+            _isPointAtInfinity(Delta.Point(rx, ry)),
             "With REDUCED coordinates: (3,5) + (3,2) correctly gives point at infinity"
         );
     }
@@ -225,7 +224,7 @@ contract EllipticCurvePropertiesTest is Test {
         (uint256 rx, uint256 ry) =
             EllipticCurve.ecAdd({_x1: Delta._GX, _y1: Delta._GY, _x2: invX, _y2: invY, _aa: Delta._AA, _pp: Delta._PP});
 
-        assertTrue(_isPointAtInfinity(Delta.CurvePoint(rx, ry)), "G + (-G) should be point at infinity");
+        assertTrue(_isPointAtInfinity(Delta.Point(rx, ry)), "G + (-G) should be point at infinity");
     }
 
     /// @notice Concrete: (G + 2G) + 3G = G + (2G + 3G) = 6G
@@ -264,7 +263,7 @@ contract EllipticCurvePropertiesTest is Test {
     /// @notice Returns whether a point is at infinity or not..
     /// @param p The point to check.
     /// @return isAtInfinity Whether the point is at infinity or not.
-    function _isPointAtInfinity(Delta.CurvePoint memory p) internal pure returns (bool isAtInfinity) {
+    function _isPointAtInfinity(Delta.Point memory p) internal pure returns (bool isAtInfinity) {
         isAtInfinity = p.x == 0 && p.y == 0;
     }
 }

contracts/test/libs/TxGen.sol

@@ -50,7 +50,7 @@ library TxGen {
         bytes32 cm = commitment(created);
 
         // Construct the delta for consumption based on kind and quantity
-        Delta.CurvePoint memory unitDelta = DeltaGen.generateInstance(
+        Delta.Point memory unitDelta = DeltaGen.generateInstance(
             vm,
             DeltaGen.InstanceInputs({
                 kind: kind(consumed), quantity: consumed.quantity, consumed: true, valueCommitmentRandomness: 1

contracts/test/proofs/DeltaProof.t.sol

@@ -20,14 +20,14 @@ library DeltaFuzzing {
     }
 
     /// @dev This function exposes `Delta.verify` for the fuzzer.
-    function verify(bytes memory proof, Delta.CurvePoint memory instance, bytes32 verifyingKey) public pure {
+    function verify(bytes memory proof, Delta.Point memory instance, bytes32 verifyingKey) public pure {
         Delta.verify({proof: proof, instance: instance, verifyingKey: verifyingKey});
     }
 }
 
 contract DeltaProofTest is Test {
     using SignMagnitude for SignMagnitude.Number;
-    using Delta for Delta.CurvePoint;
+    using Delta for Delta.Point;
     using DeltaGen for DeltaGen.InstanceInputs[];
     using DeltaGen for DeltaGen.InstanceInputs;
     using DeltaGen for uint256;
@@ -52,7 +52,7 @@ contract DeltaProofTest is Test {
             DeltaGen.ProofInputs({valueCommitmentRandomness: valueCommitmentRandomness, verifyingKey: verifyingKey});
 
         // Generate a delta instance from the above inputs
-        Delta.CurvePoint memory instance = DeltaGen.generateInstance(vm, deltaInstanceInputs);
+        Delta.Point memory instance = DeltaGen.generateInstance(vm, deltaInstanceInputs);
 
         // Generate a delta proof from the above inputs
         bytes memory proof = DeltaGen.generateProof(vm, deltaProofInputs);
@@ -110,12 +110,12 @@ contract DeltaProofTest is Test {
         vm.assume(summedDeltaInputs.computePreDelta() != 0);
 
         // Generate a delta proof and instance from the above tags and preimage
-        Delta.CurvePoint memory instance1 = DeltaGen.generateInstance(vm, deltaInputs1);
-        Delta.CurvePoint memory instance2 = DeltaGen.generateInstance(vm, deltaInputs2);
-        Delta.CurvePoint memory expectedDelta = DeltaGen.generateInstance(vm, summedDeltaInputs);
+        Delta.Point memory instance1 = DeltaGen.generateInstance(vm, deltaInputs1);
+        Delta.Point memory instance2 = DeltaGen.generateInstance(vm, deltaInputs2);
+        Delta.Point memory expectedDelta = DeltaGen.generateInstance(vm, summedDeltaInputs);
 
         // Verify that the deltas add correctly
-        Delta.CurvePoint memory computedDelta = Delta.add(instance1, instance2);
+        Delta.Point memory computedDelta = Delta.add(instance1, instance2);
 
         assertEq(computedDelta.x, expectedDelta.x);
         assertEq(computedDelta.y, expectedDelta.y);
@@ -140,7 +140,7 @@ contract DeltaProofTest is Test {
         });
 
         // Generate a delta proof and instance from the above tags and preimage
-        Delta.CurvePoint memory instance = DeltaGen.generateInstance(vm, deltaInstanceInputs);
+        Delta.Point memory instance = DeltaGen.generateInstance(vm, deltaInstanceInputs);
         bytes memory proof = DeltaGen.generateProof(vm, deltaProofInputs);
         vm.expectPartialRevert(Delta.DeltaMismatch.selector);
         DeltaFuzzing.verify({proof: proof, instance: instance, verifyingKey: deltaProofInputs.verifyingKey});
@@ -165,7 +165,7 @@ contract DeltaProofTest is Test {
             DeltaGen.ProofInputs({valueCommitmentRandomness: valueCommitmentRandomness1, verifyingKey: verifyingKey})
         );
 
-        Delta.CurvePoint memory instanceRcv2;
+        Delta.Point memory instanceRcv2;
         {
             DeltaGen.InstanceInputs memory deltaInputs2 = DeltaGen.InstanceInputs({
                 kind: kind, quantity: 0, consumed: consumed, valueCommitmentRandomness: valueCommitmentRandomness2
@@ -195,7 +195,7 @@ contract DeltaProofTest is Test {
             DeltaGen.ProofInputs({valueCommitmentRandomness: valueCommitmentRandomness, verifyingKey: verifyingKey1})
         );
 
-        Delta.CurvePoint memory instance;
+        Delta.Point memory instance;
         {
             DeltaGen.InstanceInputs memory deltaInputs2 = DeltaGen.InstanceInputs({
                 kind: kind, quantity: 0, consumed: consumed, valueCommitmentRandomness: valueCommitmentRandomness
@@ -218,7 +218,7 @@ contract DeltaProofTest is Test {
         kind = bound(kind, 1, DeltaGen.SECP256K1_ORDER - 1);
         DeltaGen.InstanceInputs[] memory deltaInputs = _getBoundedDeltaInstances(kind, fuzzerInputs);
 
-        Delta.CurvePoint memory deltaAcc = Delta.zero();
+        Delta.Point memory deltaAcc = Delta.zero();
 
         // Make sure that the delta quantities balance out
         (
@@ -248,7 +248,7 @@ contract DeltaProofTest is Test {
             vm.assume(wrappedDeltaInputs[i].valueCommitmentRandomness != 0);
             vm.assume(wrappedDeltaInputs[i].computePreDelta() != 0);
 
-            Delta.CurvePoint memory instance = DeltaGen.generateInstance(vm, wrappedDeltaInputs[i]);
+            Delta.Point memory instance = DeltaGen.generateInstance(vm, wrappedDeltaInputs[i]);
             deltaAcc = deltaAcc.add(instance);
         }
 
@@ -270,7 +270,7 @@ contract DeltaProofTest is Test {
         kind = bound(kind, 1, DeltaGen.SECP256K1_ORDER - 1);
         DeltaGen.InstanceInputs[] memory deltaInputs = _getBoundedDeltaInstances(kind, fuzzerInputs);
 
-        Delta.CurvePoint memory deltaAcc = Delta.zero();
+        Delta.Point memory deltaAcc = Delta.zero();
 
         // Accumulate the total quantity and randomness commitment
         (
@@ -289,7 +289,7 @@ contract DeltaProofTest is Test {
             vm.assume(wrappedDeltaInputs[i].valueCommitmentRandomness != 0);
             vm.assume(wrappedDeltaInputs[i].computePreDelta() != 0);
 
-            Delta.CurvePoint memory instance = DeltaGen.generateInstance(vm, wrappedDeltaInputs[i]);
+            Delta.Point memory instance = DeltaGen.generateInstance(vm, wrappedDeltaInputs[i]);
             deltaAcc = deltaAcc.add(instance);
         }
         // Compute the proof for the balanced transaction
@@ -307,7 +307,7 @@ contract DeltaProofTest is Test {
 
         DeltaFuzzing.verify({
             proof: txn.deltaProof,
-            instance: Delta.CurvePoint({
+            instance: Delta.Point({
                 x: uint256(txn.actions[0].complianceVerifierInputs[0].instance.unitDeltaX),
                 y: uint256(txn.actions[0].complianceVerifierInputs[0].instance.unitDeltaY)
             }),
@@ -338,4 +338,8 @@ contract DeltaProofTest is Test {
             });
         }
     }
+
+    function _mul(Delta.Point memory p, uint256 k) internal pure returns (Delta.Point memory product) {
+        (product.x, product.y) = EllipticCurve.ecMul({_k: k, _x: p.x, _y: p.y, _aa: Delta._AA, _pp: Delta._PP});
+    }
 }