Discovery indexing user verification (#4035)

* Add veirfy user action

* lint

* Address comments

discovery-provider/integration_tests/tasks/entity_manager/test_user_entity_manager.py

@@ -2,6 +2,7 @@
 
 from integration_tests.challenges.index_helpers import UpdateTask
 from integration_tests.utils import populate_mock_db
+from sqlalchemy import asc
 from src.challenges.challenge_event_bus import ChallengeEventBus, setup_challenge_bus
 from src.models.users.user import User
 from src.tasks.entity_manager.entity_manager import entity_manager_update
@@ -18,6 +19,12 @@ def set_patches(mocker):
         autospec=True,
     )
 
+    mocker.patch(
+        "src.tasks.entity_manager.user.get_verifier_address",
+        return_value="0x",
+        autospec=True,
+    )
+
     def fetch_node_info(self, sp_id, sp_type, redis):
         return {
             "operator_wallet": "wallet1",
@@ -309,7 +316,7 @@ def get_events_side_effect(_, tx_receipt):
 
 
 def test_index_invalid_users(app, mocker):
-    "Tests invalid batch of useres create/update/delete actions"
+    "Tests invalid batch of users create/update/delete actions"
     set_patches(mocker)
 
     # setup db and mocked txs
@@ -518,3 +525,91 @@ def get_events_side_effect(_, tx_receipt):
         # validate db records
         all_users: List[User] = session.query(User).all()
         assert len(all_users) == 2  # no new users indexed
+
+
+def test_index_verify_users(app, mocker):
+    "Tests user verify actions"
+    set_patches(mocker)
+
+    # setup db and mocked txs
+    with app.app_context():
+        db = get_db()
+        web3 = Web3()
+        update_task = UpdateTask(None, web3, None)
+
+        tx_receipts = {
+            "VerifyUser": [
+                {
+                    "args": AttributeDict(
+                        {
+                            "_entityId": 1,
+                            "_entityType": "User",
+                            "_userId": 1,
+                            "_action": "Verify",
+                            "_metadata": "",
+                            "_signer": "0x",
+                        }
+                    )
+                },
+            ],
+            "InvalidVerifyUser": [
+                {
+                    "args": AttributeDict(
+                        {
+                            "_entityId": 2,
+                            "_entityType": "User",
+                            "_userId": 2,
+                            "_action": "Verify",
+                            "_metadata": "",
+                            "_signer": "user1wallet",
+                        }
+                    )
+                },
+            ],
+        }
+
+        entity_manager_txs = [
+            AttributeDict(
+                {"transactionHash": update_task.web3.toBytes(text=tx_receipt)}
+            )
+            for tx_receipt in tx_receipts
+        ]
+
+        def get_events_side_effect(_, tx_receipt):
+            return tx_receipts[tx_receipt.transactionHash.decode("utf-8")]
+
+        mocker.patch(
+            "src.tasks.entity_manager.entity_manager.get_entity_manager_events_tx",
+            side_effect=get_events_side_effect,
+            autospec=True,
+        )
+        entities = {
+            "users": [
+                {"user_id": 1, "handle": "user-1", "wallet": "user1wallet"},
+                {"user_id": 2, "handle": "user-1", "wallet": "user2wallet"},
+            ]
+        }
+        populate_mock_db(db, entities)
+
+        with db.scoped_session() as session:
+            # index transactions
+            entity_manager_update(
+                None,
+                update_task,
+                session,
+                entity_manager_txs,
+                block_number=0,
+                block_timestamp=1585336422,
+                block_hash=0,
+                metadata={},
+            )
+            # validate db records
+            all_users: List[User] = (
+                session.query(User)
+                .filter(User.is_current)
+                .order_by(asc(User.user_id))
+                .all()
+            )
+            assert len(all_users) == 2  # no new users indexed
+            assert all_users[0].is_verified  # user 1 is verified
+            assert not all_users[1].is_verified  # user 2 is not verified

discovery-provider/src/tasks/entity_manager/entity_manager.py

@@ -27,7 +27,7 @@
     delete_social_record,
 )
 from src.tasks.entity_manager.track import create_track, delete_track, update_track
-from src.tasks.entity_manager.user import create_user, update_user
+from src.tasks.entity_manager.user import create_user, update_user, verify_user
 from src.tasks.entity_manager.user_replica_set import update_user_replica_set
 from src.tasks.entity_manager.utils import (
     MANAGE_ENTITY_EVENT_TYPE,
@@ -168,6 +168,12 @@ def entity_manager_update(
                         and ENABLE_DEVELOPMENT_FEATURES
                     ):
                         update_user(params)
+                    elif (
+                        params.action == Action.VERIFY
+                        and params.entity_type == EntityType.USER
+                        and ENABLE_DEVELOPMENT_FEATURES
+                    ):
+                        verify_user(params)
                     elif (
                         params.action == Action.UPDATE
                         and params.entity_type == EntityType.USER_REPLICA_SET

discovery-provider/src/tasks/entity_manager/user.py

@@ -16,10 +16,16 @@
     update_user_metadata,
     validate_user_record,
 )
+from src.utils.config import shared_config
 
 logger = logging.getLogger(__name__)
 
 
+def get_verifier_address():
+    if "verified_address" in shared_config["contracts"]:
+        return shared_config["contracts"]["verified_address"]
+
+
 def validate_user_tx(params: ManageEntityParameters):
     user_id = params.user_id
 
@@ -31,7 +37,7 @@ def validate_user_tx(params: ManageEntityParameters):
             raise Exception("Invalid User Transaction, user does not exist")
         if user_id < USER_ID_OFFSET:
             raise Exception("Invalid User Transaction, user id offset incorrect")
-    else:
+    elif params.action == Action.UPDATE:
         # update / delete specific validations
         if user_id not in params.existing_records[EntityType.USER]:
             raise Exception("Invalid User Transaction, user does not exist")
@@ -40,6 +46,16 @@ def validate_user_tx(params: ManageEntityParameters):
             raise Exception(
                 "Invalid User Transaction, user wallet signer does not match"
             )
+    elif params.action == Action.VERIFY:
+        verifier_address = get_verifier_address()
+        if not verifier_address or verifier_address.lower() != params.signer.lower():
+            raise Exception(
+                "Invalid User Transaction, signer does not match verifier address"
+            )
+    else:
+        raise Exception(
+            f"Invalid User Transaction, action {params.action} is not valid"
+        )
 
 
 def update_user_record(params: ManageEntityParameters, user: User, metadata: Dict):
@@ -133,3 +149,23 @@ def update_user(params: ManageEntityParameters):
     params.add_user_record(user_id, user_record)
 
     return user_record
+
+
+def verify_user(params: ManageEntityParameters):
+    validate_user_tx(params)
+
+    user_id = params.user_id
+    existing_user = params.existing_records[EntityType.USER][user_id]
+    user_record = copy_user_record(
+        existing_user,
+        params.block_number,
+        params.event_blockhash,
+        params.txhash,
+        params.block_datetime,
+    )
+
+    user_record = validate_user_record(user_record)
+    user_record.is_verified = True
+    params.add_user_record(user_id, user_record)
+
+    return user_record

discovery-provider/src/tasks/entity_manager/utils.py

@@ -30,6 +30,7 @@ class Action(str, Enum):
     UNSAVE = "Unsave"
     REPOST = "Repost"
     UNREPOST = "Unrepost"
+    VERIFY = "Verify"
 
     def __str__(self) -> str:
         return str.__str__(self)