Probably broken bls sig verifify

account-abstraction/contracts/samples/bls/lib/IBLS.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.7.0 <0.9.0;
+
+interface IBLS {
+    function verifySingle(
+        uint256[2] memory signature,
+        uint256[4] memory pubkey,
+        uint256[2] memory message
+    ) external view returns (bool);
+
+    function verifyMultiple(
+        uint256[2] memory signature,
+        uint256[4][] memory pubkeys,
+        uint256[2][] memory messages
+    ) external view returns (bool);
+
+    function hashToPoint(
+        bytes32 domain,
+        bytes memory message
+    ) external view returns (uint256[2] memory);
+
+    function isZeroBLSKey(uint256[4] memory blsKey) external pure returns (bool);
+
+}

account-abstraction/contracts/samples/gnosis/EIP4337Manager.sol

@@ -29,6 +29,7 @@ contract EIP4337Manager is IAccount, SafeStorage, Executor {
     address public immutable eip4337Fallback;
     address public immutable entryPoint;
     ECDSAVerifier public immutable ecdsaVerifier;
+    BLSGroupVerifier public immutable blsVerifier;
 
     mapping(IVerifier=>bool) trustedVerifiers; //TODO Fallback to Safe modules
 
@@ -43,6 +44,9 @@ contract EIP4337Manager is IAccount, SafeStorage, Executor {
         eip4337Fallback = address(new EIP4337Fallback(address(this)));
         ecdsaVerifier = new ECDSAVerifier();
         enableVerifier(ecdsaVerifier);
+
+        blsVerifier = new BLSGroupVerifier();
+        enableVerifier(blsVerifier);
     }
 
     function enableVerifier(IVerifier verifier) public {
@@ -102,6 +106,18 @@ contract EIP4337Manager is IAccount, SafeStorage, Executor {
             )) {
                 result = SIG_VALIDATION_FAILED;
             }
+        } else if (uint8(verificationDataType) == 2) {
+            IVerifier verifier = blsVerifier; // TODO address from bytes
+            // require(trustedVerifiers[verifier], "V: verifier not trusted");
+            require(threshold == 1, "account: only threshold 1");
+            bytes calldata blsSig = verificationData[1:];
+            if (!blsVerifier.verify(
+                Safe(payable(address(this))),
+                userOpHash,
+                blsSig
+            )) {
+                result = SIG_VALIDATION_FAILED;
+            }
         }
         else {
             result = SIG_VALIDATION_FAILED;

account-abstraction/contracts/samples/gnosis/Verifiers.sol

@@ -6,6 +6,7 @@ import "../../safe-contracts/contracts/examples/libraries/Migrate_1_3_0_to_1_2_0
 
 import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import "./EIP4337Manager.sol";
+import "../bls/lib/IBLS.sol";
 
 interface IVerifier {
     function verify(
@@ -33,21 +34,36 @@ contract ECDSAVerifier is IVerifier, SafeStorage {
 contract BLSGroupVerifier is IVerifier, SafeStorage {
     uint8 public constant BLS_KEY_LEN = 4;
     uint256[BLS_KEY_LEN][] public groupMembers;
+
+    bytes32 public constant BLS_DOMAIN = keccak256("quorumPay");
+    IBLS public immutable blsOpen;
+
+    constructor() {
+        // TODO Replace with real deploy
+        blsOpen = IBLS(0x13DCf97b6B94bDA883492AB46d556E8919445876);
+    }
     
     function addMember(uint256[BLS_KEY_LEN] calldata newMember) public {
         groupMembers.push(newMember);
     }
 
-    function setupGroup(uint256[BLS_KEY_LEN][] calldata newMember) public {
-        //add members
+    function setupGroup(uint256[BLS_KEY_LEN][] calldata newGroupMembers) public {
+        groupMembers = newGroupMembers;
     }
 
     function verify(
         Safe safe,
         bytes32 hash,
-        bytes calldata ecdsaSignature
-    ) public pure returns (bool) {
-        (safe); (hash); (ecdsaSignature);
-        return true;
+        bytes calldata blsSignature
+    ) public view returns (bool) {
+        uint256[2] memory sig = abi.decode(blsSignature, (uint256[2]));
+        uint256[2] memory point = blsOpen.hashToPoint(BLS_DOMAIN, abi.encodePacked(hash));
+
+        uint256[2][] memory hashPoints = new uint256[2][](groupMembers.length);
+        for (uint256 i = 0; i < groupMembers.length; i++) {
+            hashPoints[i] = point;
+        }
+
+        return blsOpen.verifyMultiple(sig, groupMembers, hashPoints);
     }
 }