Add p256 validator

.gitmodules

@@ -7,3 +7,9 @@
 [submodule "lib/I4337"]
 	path = lib/I4337
 	url = https://github.com/leekt/I4337
+[submodule "lib/p256-verifier"]
+	path = lib/p256-verifier
+	url = https://github.com/daimo-eth/p256-verifier
+[submodule "lib/FreshCryptoLib"]
+	path = lib/FreshCryptoLib
+	url = https://github.com/rdubois-crypto/FreshCryptoLib

foundry.toml

@@ -2,7 +2,7 @@
 src = 'src'
 out = 'out'
 libs = ['lib']
-solc_version = '0.8.19'
+solc_version = '0.8.21'
 bytecode_hash = "none"
 cbor_metadata = false
 optimize = true

remappings.txt

@@ -1,3 +1,5 @@
 ds-test/=lib/forge-std/lib/ds-test/src/
 forge-std/=lib/forge-std/src/
 solady/=lib/solady/src/
+p256-verifier/=lib/p256-verifier/src/
+FreshCryptoLib/=lib/FreshCryptoLib/solidity/src/

src/validator/P256Validator.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import {UserOperation} from "I4337/interfaces/UserOperation.sol";
+import {ECDSA} from "solady/utils/ECDSA.sol";
+import {IKernelValidator} from "../interfaces/IKernelValidator.sol";
+import {ValidationData} from "../common/Types.sol";
+import {SIG_VALIDATION_FAILED} from "../common/Constants.sol";
+import {P256} from "p256-verifier/P256.sol";
+
+contract P256Validator is IKernelValidator {
+    event P256PublicKeysChanged(address indexed kernel, PublicKey indexed oldKeys, PublicKey indexed newKeys);
+
+    struct PublicKey {
+        uint256 x;
+        uint256 y;
+    }
+
+    error BadKey();
+
+    mapping(address => PublicKey) public p256PublicKey;
+
+    function enable(bytes calldata _data) external payable override {
+        PublicKey memory key = abi.decode(_data, (PublicKey));
+        if (key.x == 0 || key.y == 0) {
+            revert BadKey();
+        }
+        PublicKey memory oldKey = p256PublicKey[msg.sender];
+        p256PublicKey[msg.sender] = key;
+        emit P256PublicKeysChanged(msg.sender, oldKey, key);
+    }
+
+    function disable(bytes calldata) external payable override {
+        delete p256PublicKey[msg.sender];
+    }
+
+    function validateUserOp(UserOperation calldata _userOp, bytes32 _userOpHash, uint256) external payable override returns (ValidationData validationData) {
+        (uint256 r, uint256 s) = abi.decode(_userOp.signature, (uint256, uint256));
+        PublicKey memory key = p256PublicKey[_userOp.sender];
+        bytes32 hash = ECDSA.toEthSignedMessageHash(_userOpHash);
+        if (P256.verifySignature(hash, r, s, key.x, key.y)) {
+            return ValidationData.wrap(0);
+        } 
+        if (!P256.verifySignature(_userOpHash, r, s, key.x, key.y)) {
+            return SIG_VALIDATION_FAILED;
+        }
+    }
+
+    function validateSignature(bytes32 hash, bytes calldata signature) external view override returns (ValidationData) {
+        (uint256 r, uint256 s) = abi.decode(signature, (uint256, uint256));
+        PublicKey memory key = p256PublicKey[msg.sender];
+        if (P256.verifySignature(hash, r, s, key.x, key.y)) {
+            return ValidationData.wrap(0);
+        }
+        bytes32 ethHash = ECDSA.toEthSignedMessageHash(hash);
+        if (!P256.verifySignature(ethHash, r, s, key.x, key.y)) {
+            return SIG_VALIDATION_FAILED;
+        }
+        return ValidationData.wrap(0);
+    }
+
+    function validCaller(address _caller, bytes calldata) external view override returns (bool) {
+        revert NotImplemented();
+    }
+}

test/foundry/KernelECDSA.t.sol

@@ -68,8 +68,7 @@ contract KernelECDSATest is KernelTestBase {
     }
 
     function test_default_validator_enable() external override {
-        UserOperation memory op = entryPoint.fillUserOp(
-            address(kernel),
+        UserOperation memory op = buildUserOperation(
             abi.encodeWithSelector(
                 IKernel.execute.selector,
                 address(defaultValidator),
@@ -78,17 +77,13 @@ contract KernelECDSATest is KernelTestBase {
                 Operation.Call
             )
         );
-        op.signature = signUserOp(op);
-        UserOperation[] memory ops = new UserOperation[](1);
-        ops[0] = op;
-        entryPoint.handleOps(ops, beneficiary);
+        performUserOperationWithSig(op);
         (address owner) = ECDSAValidator(address(defaultValidator)).ecdsaValidatorStorage(address(kernel));
         assertEq(owner, address(0xdeadbeef), "owner should be 0xdeadbeef");
     }
 
     function test_default_validator_disable() external override {
-        UserOperation memory op = entryPoint.fillUserOp(
-            address(kernel),
+        UserOperation memory op = buildUserOperation(
             abi.encodeWithSelector(
                 IKernel.execute.selector,
                 address(defaultValidator),
@@ -97,10 +92,7 @@ contract KernelECDSATest is KernelTestBase {
                 Operation.Call
             )
         );
-        op.signature = signUserOp(op);
-        UserOperation[] memory ops = new UserOperation[](1);
-        ops[0] = op;
-        entryPoint.handleOps(ops, beneficiary);
+        performUserOperationWithSig(op);
         (address owner) = ECDSAValidator(address(defaultValidator)).ecdsaValidatorStorage(address(kernel));
         assertEq(owner, address(0), "owner should be 0");
     }

test/foundry/KernelLiteECDSA.t.sol

@@ -57,16 +57,12 @@ contract KernelECDSATest is KernelTestBase {
     function test_set_default_validator() external override {
         TestValidator newValidator = new TestValidator();
         bytes memory empty;
-        UserOperation memory op = entryPoint.fillUserOp(
-            address(kernel),
+        UserOperation memory op = buildUserOperation(
             abi.encodeWithSelector(KernelStorage.setDefaultValidator.selector, address(newValidator), empty)
         );
-        op.signature = signUserOp(op);
-        UserOperation[] memory ops = new UserOperation[](1);
-        ops[0] = op;
         vm.expectEmit(true, true, true, false, address(entryPoint));
         emit UserOperationEvent(entryPoint.getUserOpHash(op), address(kernel), address(0), op.nonce, false, 0, 0);
-        entryPoint.handleOps(ops, beneficiary);
+        performUserOperationWithSig(op);
     }
 
     function signUserOp(UserOperation memory op) internal view override returns (bytes memory) {
@@ -101,14 +97,9 @@ contract KernelECDSATest is KernelTestBase {
 
     function test_transfer_ownership() external {
         address newOwner = makeAddr("new owner");
-        UserOperation memory op = entryPoint.fillUserOp(
-            address(kernel), abi.encodeWithSelector(KernelLiteECDSA.transferOwnership.selector, newOwner)
-        );
-        op.signature = signUserOp(op);
-        UserOperation[] memory ops = new UserOperation[](1);
-        ops[0] = op;
+        UserOperation memory op = buildUserOperation(abi.encodeWithSelector(KernelLiteECDSA.transferOwnership.selector, newOwner));
         vm.expectEmit(true, true, true, false, address(entryPoint));
         emit UserOperationEvent(entryPoint.getUserOpHash(op), address(kernel), address(0), op.nonce, false, 0, 0);
-        entryPoint.handleOps(ops, beneficiary);
+        performUserOperationWithSig(op);
     }
 }