Merge branch 'main' into leaderboard-metadata-sm

engineapi/engineapi/actions.py

@@ -5,7 +5,13 @@ from typing import List, Any, Optional, Dict, Union, Tuple, cast
 import uuid
 import logging
 
-from bugout.data import BugoutResource, BugoutSearchResult
+from bugout.data import (
+    BugoutResource,
+    BugoutSearchResult,
+    ResourcePermissions,
+    HolderType,
+    BugoutResourceHolder,
+)
 from eth_typing import Address
 from hexbytes import HexBytes
 import requests  # type: ignore
@@ -103,6 +109,10 @@ class LeaderboardVersionNotFound(Exception):
     pass
 
 
+class LeaderboardAssignResourceError(Exception):
+    pass
+
+
 BATCH_SIGNATURE_PAGE_SIZE = 500
 
 logger = logging.getLogger(__name__)
@@ -1515,19 +1525,20 @@ def create_leaderboard(
         db_session.add(leaderboard)
         db_session.commit()
 
+        user = None
+        if token is not None:
+            user = bc.get_user(token=token)
+
         resource = create_leaderboard_resource(
             leaderboard_id=str(leaderboard.id),
-            token=token,
+            user_id=str(user.id) if user is not None else None,
         )
-
         leaderboard.resource_id = resource.id
-
         db_session.commit()
     except Exception as e:
         db_session.rollback()
         logger.error(f"Error creating leaderboard: {e}")
         raise LeaderboardCreateError(f"Error creating leaderboard: {e}")
-
     return leaderboard
 
 
@@ -1701,38 +1712,62 @@ def add_scores(
 # leaderboard access actions
 
 
-def create_leaderboard_resource(
+def create_leaderboard_resource(leaderboard_id: str, user_id: Optional[str] = None):
-    leaderboard_id: str, token: Union[Optional[uuid.UUID], str] = None
-) -> BugoutResource:
     resource_data: Dict[str, Any] = {
         "type": LEADERBOARD_RESOURCE_TYPE,
         "leaderboard_id": leaderboard_id,
     }
 
-    if token is None:
-        token = MOONSTREAM_ADMIN_ACCESS_TOKEN
     try:
         resource = bc.create_resource(
-            token=token,
+            token=MOONSTREAM_ADMIN_ACCESS_TOKEN,
             application_id=MOONSTREAM_APPLICATION_ID,
             resource_data=resource_data,
             timeout=10,
         )
     except Exception as e:
         raise LeaderboardCreateError(f"Error creating leaderboard resource: {e}")
+
+    if user_id is not None:
+        try:
+            bc.add_resource_holder_permissions(
+                token=MOONSTREAM_ADMIN_ACCESS_TOKEN,
+                resource_id=resource.id,
+                holder_permissions=BugoutResourceHolder(
+                    holder_type=HolderType.user,
+                    holder_id=user_id,
+                    permissions=[
+                        ResourcePermissions.ADMIN,
+                        ResourcePermissions.READ,
+                        ResourcePermissions.UPDATE,
+                        ResourcePermissions.DELETE,
+                    ],
+                ),
+            )
+        except Exception as e:
+            raise LeaderboardCreateError(
+                f"Error adding resource holder permissions: {e}"
+            )
+
     return resource
 
 
 def assign_resource(
     db_session: Session,
     leaderboard_id: uuid.UUID,
-    user_token: Union[uuid.UUID, str],
+    user_token: Optional[Union[uuid.UUID, str]] = None,
     resource_id: Optional[uuid.UUID] = None,
 ):
     """
     Assign a resource handler to a leaderboard
     """
 
+    ### get user_name from token
+
+    user = None
+    if user_token is not None:
+        user = bc.get_user(token=user_token)
+
     leaderboard = (
         db_session.query(Leaderboard).filter(Leaderboard.id == leaderboard_id).one()  # type: ignore
     )
@@ -1740,11 +1775,9 @@ def assign_resource(
     if resource_id is not None:
         leaderboard.resource_id = resource_id
     else:
-        # Create resource via admin token
-
         resource = create_leaderboard_resource(
             leaderboard_id=str(leaderboard_id),
-            token=user_token,
+            user_id=user.id if user is not None else None,
         )
 
         leaderboard.resource_id = resource.id

engineapi/requirements.txt

@@ -7,7 +7,7 @@ base58==2.1.1
 bitarray==2.7.6
 boto3==1.27.0
 botocore==1.30.0
-bugout==0.2.14
+bugout==0.2.15
 certifi==2023.5.7
 charset-normalizer==3.1.0
 click==8.1.3

engineapi/setup.py

@@ -13,7 +13,7 @@ setup(
     packages=find_packages(),
     install_requires=[
         "boto3",
-        "bugout>=0.2.14",
+        "bugout>=0.2.15",
         "eip712==0.1.0",
         "eth-typing>=2.3.0",
         "fastapi",

moonstreamapi/moonstreamapi/actions.py

@@ -15,6 +15,9 @@ from bugout.data import (
     BugoutResources,
     BugoutSearchResult,
     BugoutSearchResults,
+    BugoutResourceHolder,
+    HolderType,
+    ResourcePermissions,
 )
 from bugout.exceptions import BugoutResponseException
 from bugout.journal import SearchOrder
@@ -711,11 +714,7 @@ def generate_journal_for_user(
     }
 
     try:
-        bc.create_resource(
+        create_resource_for_user(user_id=user_id, resource_data=resource_data)
-            token=token,
-            application_id=MOONSTREAM_APPLICATION_ID,
-            resource_data=resource_data,
-        )
     except BugoutResponseException as e:
         raise MoonstreamHTTPException(status_code=e.status_code, detail=e.detail)
     except Exception as e:
@@ -851,6 +850,8 @@ def get_list_of_support_interfaces(
     Returns list of interfaces supported by given address
     """
 
+    result = {}
+
     try:
         _, _, is_contract = check_if_smart_contract(
             blockchain_type=blockchain_type, address=address, user_token=user_token
@@ -866,8 +867,6 @@ def get_list_of_support_interfaces(
             abi=supportsInterface_abi,
         )
 
-        result = {}
-
         if blockchain_type in multicall_contracts:
             calls = []
 
@@ -952,3 +951,57 @@ def check_if_smart_contract(
         is_contract = True
 
     return blockchain_type, address, is_contract
+
+
+def create_resource_for_user(
+    user_id: uuid.UUID,
+    resource_data: Dict[str, Any],
+) -> BugoutResource:
+    """
+    Create resource for user
+    """
+    try:
+        resource = bc.create_resource(
+            token=MOONSTREAM_ADMIN_ACCESS_TOKEN,
+            application_id=MOONSTREAM_APPLICATION_ID,
+            resource_data=resource_data,
+            timeout=BUGOUT_REQUEST_TIMEOUT_SECONDS,
+        )
+    except BugoutResponseException as e:
+        raise MoonstreamHTTPException(status_code=e.status_code, detail=e.detail)
+    except Exception as e:
+        logger.error(f"Error creating resource: {str(e)}")
+        raise MoonstreamHTTPException(status_code=500, internal_error=e)
+
+    try:
+        bc.add_resource_holder_permissions(
+            token=MOONSTREAM_ADMIN_ACCESS_TOKEN,
+            resource_id=resource.id,
+            holder_permissions=BugoutResourceHolder(
+                holder_type=HolderType.user,
+                holder_id=user_id,
+                permissions=[
+                    ResourcePermissions.ADMIN,
+                    ResourcePermissions.READ,
+                    ResourcePermissions.UPDATE,
+                    ResourcePermissions.DELETE,
+                ],
+            ),
+            timeout=BUGOUT_REQUEST_TIMEOUT_SECONDS,
+        )
+    except BugoutResponseException as e:
+        logger.error(
+            f"Error adding resource holder permissions to resource resource {str(resource.id)}  {str(e)}"
+        )
+        raise MoonstreamHTTPException(status_code=e.status_code, detail=e.detail)
+    except Exception as e:
+        bc.delete_resource(
+            token=MOONSTREAM_ADMIN_ACCESS_TOKEN,
+            resource_id=resource.id,
+        )
+        logger.error(
+            f"Error adding resource holder permissions to resource {str(resource.id)}  {str(e)}"
+        )
+        raise MoonstreamHTTPException(status_code=500, internal_error=e)
+
+    return resource

moonstreamapi/moonstreamapi/routes/queries.py

@@ -25,11 +25,11 @@ from ..actions import (
     get_query_by_name,
     name_normalization,
     query_parameter_hash,
+    create_resource_for_user,
 )
 from ..middleware import MoonstreamHTTPException
 from ..settings import (
     MOONSTREAM_ADMIN_ACCESS_TOKEN,
-    MOONSTREAM_APPLICATION_ID,
     MOONSTREAM_CRAWLERS_SERVER_PORT,
     MOONSTREAM_CRAWLERS_SERVER_URL,
     MOONSTREAM_INTERNAL_REQUEST_TIMEOUT_SECONDS,
@@ -130,11 +130,8 @@ async def create_query_handler(
     except Exception as e:
         raise MoonstreamHTTPException(status_code=500, internal_error=e)
 
-    try:
+    create_resource_for_user(
-        # create resource query_name_resolver
+        user_id=user.id,
-        bc.create_resource(
-            token=token,
-            application_id=MOONSTREAM_APPLICATION_ID,
         resource_data={
             "type": data.BUGOUT_RESOURCE_QUERY_RESOLVER,
             "user_id": str(user.id),
@@ -143,11 +140,6 @@ async def create_query_handler(
             "entry_id": str(entry.id),
         },
     )
-    except BugoutResponseException as e:
-        logger.error(f"Error creating name resolving resource: {str(e)}")
-        raise MoonstreamHTTPException(status_code=e.status_code, detail=e.detail)
-    except Exception as e:
-        raise MoonstreamHTTPException(status_code=500, internal_error=e)
 
     try:
         bc.update_tags(
@@ -355,7 +347,7 @@ async def update_query_handler(
             token=MOONSTREAM_ADMIN_ACCESS_TOKEN,
             journal_id=MOONSTREAM_QUERIES_JOURNAL_ID,
             entry_id=query_id,
-            title=query_name,
+            title=f"Query:{query_name}",
             content=request_update.query,
             tags=["preapprove"],
         )
@@ -620,7 +612,9 @@ async def remove_query_handler(
         raise MoonstreamHTTPException(status_code=404, detail="Query does not exists")
 
     try:
-        bc.delete_resource(token=token, resource_id=query_ids[query_name][0])
+        bc.delete_resource(
+            token=MOONSTREAM_ADMIN_ACCESS_TOKEN, resource_id=query_ids[query_name][0]
+        )
     except BugoutResponseException as e:
         raise MoonstreamHTTPException(status_code=e.status_code, detail=e.detail)
     except Exception as e:

moonstreamapi/requirements.txt

@@ -9,7 +9,7 @@ base58==2.1.1
 bitarray==2.6.0
 boto3==1.26.5
 botocore==1.29.5
-bugout>=0.2.13
+bugout>=0.2.15
 certifi==2022.9.24
 charset-normalizer==2.1.1
 click==8.1.3

moonstreamapi/setup.py

@@ -13,7 +13,7 @@ setup(
     install_requires=[
         "appdirs",
         "boto3",
-        "bugout>=0.2.13",
+        "bugout>=0.2.15",
         "fastapi",
         "moonstreamdb>=0.3.5",
         "humbug",