test: Token gated communities

tests-functional/clients/foundry.py

@@ -188,3 +188,23 @@ def get_archive(self, container_path):
                 return os.path.join(temp_dir, tar.getmembers()[0].name)
 
         return temp_dir
+
+    def generate_tokens(self, controller_address, to_address, token_amount, private_key):
+        if not self.container:
+            raise Exception("Container not found")
+
+        generate_cmd = (
+            f"cast send {controller_address} 'generateTokens(address,uint256)' "
+            f"{to_address} {token_amount} --rpc-url http://anvil:8545 "
+            f"--private-key {private_key}"
+        )
+        result = self.container.exec_run(generate_cmd)
+        return result
+
+    def get_erc20_balance(self, token_address, owner_address):
+        if not self.container:
+            raise Exception("Container not found")
+
+        balance_cmd = f"cast call {token_address} 'balanceOf(address)' {owner_address} --rpc-url http://anvil:8545"
+        result = self.container.exec_run(balance_cmd)
+        return result

tests-functional/clients/services/wakuext.py

@@ -1,5 +1,6 @@
+from dataclasses import dataclass
 from enum import Enum
-from typing import TypedDict, Union
+from typing import TypedDict, Union, Optional
 
 from clients.rpc import RpcClient
 from clients.services.service import Service
@@ -88,6 +89,40 @@ class CommunityPermissionsAccess(Enum):
     MANUAL_ACCEPT = 3
 
 
+class CommunityTokenPermissionType(Enum):
+    BECOME_MEMBER = 1
+    BECOME_ADMIN = 2
+    BECOME_TOKEN_MASTER = 3
+    CAN_VIEW_CHANNEL = 4
+    CAN_VIEW_AND_POST_CHANNEL = 5
+
+
+class CommunityTokenType(Enum):
+    ERC20 = 1
+    ERC721 = 2
+    ENS = 3
+
+
+class CommunityTokenPrivilegesLevel(Enum):
+    OWNER_LEVEL = 1
+    MASTER_LEVEL = 2
+    COMMUNITY_LEVEL = 3
+
+
+class CommunityRoles(Enum):
+    ROLE_NONE = 0
+    ROLE_OWNER = 1
+    ROLE_ADMIN = 4
+    ROLE_TOKEN_MASTER = 5
+
+
+@dataclass
+class SignParams:
+    data: bytes
+    account: str
+    password: str
+
+
 class Error(Exception):
     def __init__(self, message):
         self.message = message
@@ -276,8 +311,15 @@ def fetch_community(self, community_key):
         response = self.rpc_request("fetchCommunity", params)
         return response
 
-    def request_to_join_community(self, community_id, address="fakeaddress"):
-        params = [{"communityId": community_id, "addressesToReveal": [address], "airdropAddress": address}]
+    def request_to_join_community(self, community_id: str, addresses_to_reveal: list[str] = [], signatures: list[str] = []):
+        params = [
+            {
+                "communityId": community_id,
+                "addressesToReveal": addresses_to_reveal,
+                "airdropAddress": addresses_to_reveal[0] if len(addresses_to_reveal) > 0 else "",
+                "signatures": signatures,
+            }
+        ]
         response = self.rpc_request("requestToJoinCommunity", params)
         return response
 
@@ -341,7 +383,7 @@ def check_permissions_to_join_community(self, community_id: str):
         response = self.rpc_request("checkPermissionsToJoinCommunity", params)
         return response
 
-    def generate_joining_community_requests_for_signing(self, member_pub_key: str, community_id: str, addresses_to_reveal: list):
+    def generate_joining_community_requests_for_signing(self, member_pub_key: str, community_id: str, addresses_to_reveal: list[str]):
         params = [member_pub_key, community_id, addresses_to_reveal]
         response = self.rpc_request("generateJoiningCommunityRequestsForSigning", params)
         return response
@@ -770,3 +812,108 @@ def get_verification_request_sent_to(self, contact_id: str):
         params = [contact_id]
         response = self.rpc_request("getVerificationRequestSentTo", params)
         return response
+
+    def save_community_token(self, token_data: dict):
+        params = [token_data]
+        response = self.rpc_request("saveCommunityToken", params)
+        return response
+
+    def add_community_token(self, community_id: str, chain_id: int, contract_address: str):
+        params = [community_id, chain_id, contract_address]
+        response = self.rpc_request("addCommunityToken", params)
+        return response
+
+    def create_history_archive_torrent_from_db(self, community_id: str, topics: list, start_date, end_date, partition_duration, encrypted: bool):
+        params = [
+            community_id,
+            topics,
+            start_date.isoformat() if hasattr(start_date, "isoformat") else str(start_date),
+            end_date.isoformat() if hasattr(end_date, "isoformat") else str(end_date),
+            partition_duration,
+            encrypted,
+        ]
+        response = self.rpc_request("createHistoryArchiveTorrentFromDB", params)
+        return response
+
+    def load_history_archive_index_from_file(self, community_id: str):
+        params = [community_id]
+        response = self.rpc_request("loadHistoryArchiveIndexFromFile", params)
+        return response
+
+    def save_message_archive_id(self, community_id: str, archive_hash: str):
+        params = [community_id, archive_hash]
+        response = self.rpc_request("saveMessageArchiveID", params)
+        return response
+
+    def import_history_archives(self, community_id: str):
+        params = [community_id]
+        response = self.rpc_request("importHistoryArchives", params)
+        return response
+
+    def backup_community(self, community_id: str, clock: int):
+        params = [community_id, clock]
+        response = self.rpc_request("backupCommunity", params)
+        return response
+
+    def handle_local_backup_communities(self, communities_data: dict):
+        params = [communities_data]
+        response = self.rpc_request("handleLocalBackupCommunities", params)
+        return response
+
+    def generate_hash_ratchet_key(self, group_id: str):
+        params = [group_id]
+        response = self.rpc_request("generateHashRatchetKey", params)
+        return response
+
+    def create_community_token_permission(
+        self, community_id: str, permission_type: CommunityTokenPermissionType, token_criteria: list, chat_ids: Optional[list] = None
+    ):
+        params = [
+            {
+                "communityId": community_id,
+                "type": permission_type.value,
+                "tokenCriteria": token_criteria,
+            }
+        ]
+        if chat_ids:
+            params[0]["chatIds"] = chat_ids
+        response = self.rpc_request("createCommunityTokenPermission", params)
+        return response
+
+    def edit_community_token_permission(
+        self,
+        permission_id: str,
+        community_id: str,
+        permission_type: CommunityTokenPermissionType,
+        token_criteria: list,
+        chat_ids: Optional[list] = None,
+    ):
+        params = [
+            {
+                "permissionId": permission_id,
+                "createCommunityTokenPermission": {
+                    "communityId": community_id,
+                    "type": permission_type.value,
+                    "tokenCriteria": token_criteria,
+                },
+            }
+        ]
+        if chat_ids:
+            params[0]["createCommunityTokenPermission"]["chatIds"] = chat_ids
+        response = self.rpc_request("editCommunityTokenPermission", params)
+        return response
+
+    def delete_community_token_permission(self, community_id: str, permission_id: str):
+        params = [
+            {
+                "communityId": community_id,
+                "permissionId": permission_id,
+            }
+        ]
+        response = self.rpc_request("deleteCommunityTokenPermission", params)
+        return response
+
+    def sign_data(self, sign_params: list[dict]):
+        params = [sign_params]
+        response = self.rpc_request("signData", params)
+        return response

tests-functional/clients/services/wallet.py

@@ -92,3 +92,6 @@ def stop_suggested_routes_async_calculation(self):
     def fetch_or_get_cached_wallet_balances(self, addresses: list, force_refresh: bool = False):
         params = [addresses, force_refresh]
         return self.rpc_request("fetchOrGetCachedWalletBalances", params)
+
+    def restart_wallet_reload_timer(self):
+        return self.rpc_request("restartWalletReloadTimer")

tests-functional/clients/signals.py

@@ -35,6 +35,7 @@ class SignalType(Enum):
     CONNECTOR_DAPP_PERMISSION_GRANTED = "connector.dAppPermissionGranted"
     CONNECTOR_DAPP_PERMISSION_REVOKED = "connector.dAppPermissionRevoked"
     CONNECTOR_DAPP_CHAIN_ID_SWITCHED = "connector.dAppChainIdSwitched"
+    COMMUNITY_MEMBER_REEVALUATION_STATUS = "community.memberReevaluationStatus"
 
 
 class WalletEventType(Enum):

tests-functional/docker-compose.anvil.yml

@@ -5,7 +5,7 @@ services:
     command:
       - anvil --host 0.0.0.0 --block-time 2
     ports:
-      - 8545
+      - "8545:8545"
 
   foundry:
     platform: linux/amd64

tests-functional/tests/conftest.py

@@ -6,6 +6,7 @@
 
 from clients.anvil import Anvil
 from clients.contract_deployers.multicall3 import Multicall3Deployer
+from clients.contract_deployers.snt import SNTDeployer
 from clients.foundry import Foundry
 from clients.status_backend import StatusBackend
 from resources.constants import USE_IPV6
@@ -145,3 +146,36 @@ def foundry_client():
 @pytest.fixture(scope="session")
 def multicall3_deployer(foundry_client):
     return Multicall3Deployer(foundry_client)
+
+
+@pytest.fixture(scope="function")
+def snt_deployment(foundry_client, request):
+    deployer = SNTDeployer(foundry_client)
+    request.cls.snt_deployer = deployer
+    request.cls.snt_address = deployer.snt_contract_address
+    request.cls.snt_controller_address = deployer.snt_token_controller_address
+    yield deployer
+
+
+@pytest.fixture(scope="function")
+def snt_token_overrides(snt_deployment):
+    return [{"symbol": "SNT", "address": snt_deployment.snt_contract_address}]
+
+
+@pytest.fixture(scope="function", autouse=False)
+def owner_backend(backend_new_profile, snt_token_overrides, multicall3_deployer):
+    return backend_new_profile(name="owner", token_overrides=snt_token_overrides, multicall_contract_address=multicall3_deployer.contract_address)
+
+
+@pytest.fixture(scope="function", autouse=False)
+def member_backend(backend_new_profile, snt_token_overrides, multicall3_deployer):
+    return backend_new_profile(name="member", token_overrides=snt_token_overrides, multicall_contract_address=multicall3_deployer.contract_address)
+
+
+@pytest.fixture(scope="function", autouse=False)
+def member_with_snt_backend(backend_new_profile, snt_token_overrides, multicall3_deployer):
+    return backend_new_profile(
+        name="member_with_snt",
+        token_overrides=snt_token_overrides,
+        multicall_contract_address=multicall3_deployer.contract_address,
+    )

tests-functional/tests/test_wakuext_community_membership_requests.py

@@ -1,8 +1,10 @@
 from uuid import uuid4
+
 import pytest
+
 from clients.signals import SignalType
-from steps.messenger import MessengerSteps
 from resources.enums import RequestToJoinState
+from steps.messenger import MessengerSteps
 from utils.retry_utils import retry_call
 
 
@@ -18,7 +20,7 @@ def setup_backends(self, backend_new_profile):
         self.fetch_community(self.requester)
 
     def test_pending_request_to_join_community_and_cancel(self):
-        req_resp = self.requester.wakuext_service.request_to_join_community(self.community_id, self.fake_address)
+        req_resp = self.requester.wakuext_service.request_to_join_community(self.community_id, [self.fake_address])
         assert len(req_resp.get("requestsToJoinCommunity")) == 1
         assert req_resp.get("requestsToJoinCommunity")[0].get("state") == RequestToJoinState.RequestToJoinStatePending.value
         req_id = req_resp.get("requestsToJoinCommunity")[0].get("id")
@@ -67,7 +69,7 @@ def test_pending_request_to_join_community_and_cancel(self):
         assert pending is None
 
     def test_pending_request_to_join_community_and_accept(self):
-        req_resp = self.requester.wakuext_service.request_to_join_community(self.community_id, self.fake_address)
+        req_resp = self.requester.wakuext_service.request_to_join_community(self.community_id, [self.fake_address])
         assert len(req_resp.get("requestsToJoinCommunity")) == 1
         assert req_resp.get("requestsToJoinCommunity")[0].get("state") == RequestToJoinState.RequestToJoinStatePending.value
         req_id = req_resp.get("requestsToJoinCommunity")[0].get("id")
@@ -120,7 +122,7 @@ def test_pending_request_to_join_community_and_accept(self):
         assert all_non_approved == []
 
     def test_pending_request_to_join_community_and_decline(self):
-        req_resp = self.requester.wakuext_service.request_to_join_community(self.community_id, self.fake_address)
+        req_resp = self.requester.wakuext_service.request_to_join_community(self.community_id, [self.fake_address])
         assert len(req_resp.get("requestsToJoinCommunity")) == 1
         assert req_resp.get("requestsToJoinCommunity")[0].get("state") == RequestToJoinState.RequestToJoinStatePending.value
         req_id = req_resp.get("requestsToJoinCommunity")[0].get("id")
@@ -163,7 +165,7 @@ def test_pending_request_to_join_community_and_decline(self):
         assert pending is None
 
     def test_check_and_delete_pending_request_to_join_community(self):
-        req_resp = self.requester.wakuext_service.request_to_join_community(self.community_id, self.fake_address)
+        req_resp = self.requester.wakuext_service.request_to_join_community(self.community_id, [self.fake_address])
         assert len(req_resp.get("requestsToJoinCommunity")) == 1
         req_id = req_resp.get("requestsToJoinCommunity")[0].get("id")