tmp

apps/cic-cache/docker/Dockerfile

@@ -47,9 +47,6 @@ RUN git clone https://gitlab.com/grassrootseconomics/cic-contracts.git && \
 	mkdir -p /usr/local/share/cic/solidity && \
 	cp -R cic-contracts/abis /usr/local/share/cic/solidity/abi
 
-COPY cic-cache/docker/start_tracker.sh ./start_tracker.sh
-COPY cic-cache/docker/db.sh ./db.sh
-RUN chmod 755 ./*.sh
 # Tracker
 # ENTRYPOINT ["/usr/local/bin/cic-cache-tracker", "-vv"]
 # Server

apps/cic-cache/docker/db.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-
-set -e
->&2 echo executing database migration
-python scripts/migrate.py -c /usr/local/etc/cic-cache --migrations-dir /usr/local/share/cic-cache/alembic -vv
-set +e

apps/cic-cache/docker/start_tracker.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-. ./db.sh
-
-/usr/local/bin/cic-cache-trackerd $@

apps/cic-cache/requirements.txt

@@ -1,12 +1,13 @@
-cic-base~=0.1.2a76
+cic-base~=0.1.2a66
 alembic==1.4.2
 confini~=0.3.6rc3
 uwsgi==2.0.19.1
 moolb~=0.1.0
-cic-eth-registry~=0.5.4a16
+cic-eth-registry~=0.5.4a13
 SQLAlchemy==1.3.20
 semver==2.13.0
 psycopg2==2.8.6
 celery==4.4.7
 redis==3.5.3
+chainlib~=0.0.2a10
 chainsyncer[sql]~=0.0.2a1

apps/cic-ussd/cic_ussd/metadata/base.py

@@ -1,126 +1,7 @@
-# standard imports
-import json
-import logging
-import os
-from typing import Dict, Union
-
-# third-part imports
-import requests
-from cic_types.models.person import generate_metadata_pointer, Person
-
-# local imports
-from cic_ussd.metadata import make_request
-from cic_ussd.metadata.signer import Signer
-from cic_ussd.redis import cache_data
-from cic_ussd.error import MetadataStoreError
-
-
-logg = logging.getLogger().getChild(__name__)
-
-
 class Metadata:
     """
-    :cvar base_url: The base url or the metadata server.
-    :type base_url: str
+    :cvar base_url:
+    :type base_url:
     """
 
     base_url = None
-
-
-def metadata_http_error_handler(result: requests.Response):
-    """ This function handles and appropriately raises errors from http requests interacting with the metadata server.
-    :param result: The response object from a http request.
-    :type result: requests.Response
-    """
-    status_code = result.status_code
-
-    if 100 <= status_code < 200:
-        raise MetadataStoreError(f'Informational errors: {status_code}, reason: {result.reason}')
-
-    elif 300 <= status_code < 400:
-        raise MetadataStoreError(f'Redirect Issues: {status_code}, reason: {result.reason}')
-
-    elif 400 <= status_code < 500:
-        raise MetadataStoreError(f'Client Error: {status_code}, reason: {result.reason}')
-
-    elif 500 <= status_code < 600:
-        raise MetadataStoreError(f'Server Error: {status_code}, reason: {result.reason}')
-
-
-class MetadataRequestsHandler(Metadata):
-
-    def __init__(self, cic_type: str, identifier: bytes, engine: str = 'pgp'):
-        """
-        :param cic_type: The salt value with which to hash a specific metadata identifier.
-        :type cic_type: str
-        :param engine: Encryption used for sending data to the metadata server.
-        :type engine: str
-        :param identifier: A unique element of data in bytes necessary for creating a metadata pointer.
-        :type identifier: bytes
-        """
-        self.cic_type = cic_type
-        self.engine = engine
-        self.headers = {
-            'X-CIC-AUTOMERGE': 'server',
-            'Content-Type': 'application/json'
-        }
-        self.identifier = identifier
-        self.metadata_pointer = generate_metadata_pointer(
-            identifier=self.identifier,
-            cic_type=self.cic_type
-        )
-        if self.base_url:
-            self.url = os.path.join(self.base_url, self.metadata_pointer)
-
-    def create(self, data: Union[Dict, str]):
-        """ This function is responsible for posting data to the metadata server with a corresponding metadata pointer
-        for storage.
-        :param data: The data to be stored in the metadata server.
-        :type data: dict|str
-        """
-        data = json.dumps(data).encode('utf-8')
-        result = make_request(method='POST', url=self.url, data=data, headers=self.headers)
-        metadata_http_error_handler(result=result)
-        metadata = result.content
-        self.edit(data=metadata)
-
-    def edit(self, data: bytes):
-        """ This function is responsible for editing data in the metadata server corresponding to a unique pointer.
-        :param data: The data to be edited in the metadata server.
-        :type data: bytes
-        """
-        cic_meta_signer = Signer()
-        signature = cic_meta_signer.sign_digest(data=data)
-        algorithm = cic_meta_signer.get_operational_key().get('algo')
-        decoded_data = data.decode('utf-8')
-        formatted_data = {
-            'm': data.decode('utf-8'),
-            's': {
-                'engine': self.engine,
-                'algo': algorithm,
-                'data': signature,
-                'digest': json.loads(data).get('digest'),
-            }
-        }
-        formatted_data = json.dumps(formatted_data).encode('utf-8')
-        result = make_request(method='PUT', url=self.url, data=formatted_data, headers=self.headers)
-        logg.info(f'signed metadata submission status: {result.status_code}.')
-        metadata_http_error_handler(result=result)
-        try:
-            decoded_identifier = self.identifier.decode("utf-8")
-        except UnicodeDecodeError:
-            decoded_identifier = self.identifier.hex()
-        logg.info(f'identifier: {decoded_identifier}. metadata pointer: {self.metadata_pointer} set to: {decoded_data}.')
-
-    def query(self):
-        """This function is responsible for querying the metadata server for data corresponding to a unique pointer."""
-        result = make_request(method='GET', url=self.url)
-        metadata_http_error_handler(result=result)
-        response_data = result.content
-        data = json.loads(response_data.decode('utf-8'))
-        if result.status_code == 200 and self.cic_type == 'cic.person':
-            person = Person()
-            deserialized_person = person.deserialize(person_data=json.loads(data))
-            data = json.dumps(deserialized_person.serialize())
-            cache_data(self.metadata_pointer, data=data)
-            logg.debug(f'caching: {data} with key: {self.metadata_pointer}')

apps/cic-ussd/cic_ussd/metadata/person.py

@@ -1,12 +0,0 @@
-# standard imports
-
-# third-party imports
-
-# local imports
-from .base import MetadataRequestsHandler
-
-
-class PersonMetadata(MetadataRequestsHandler):
-
-    def __init__(self, identifier: bytes):
-        super().__init__(cic_type='cic.person', identifier=identifier)

apps/cic-ussd/cic_ussd/metadata/phone.py

@@ -1,13 +1,85 @@
 # standard imports
+import json
 import logging
+import os
 
 # external imports
+import requests
+from cic_types.models.person import generate_metadata_pointer
+from cic_ussd.metadata import make_request
+from cic_ussd.metadata.signer import Signer
 
 # local imports
-from .base import MetadataRequestsHandler
+from cic_ussd.error import MetadataStoreError
+from .base import Metadata
+
+logg = logging.getLogger().getChild(__name__)
 
 
-class PhonePointerMetadata(MetadataRequestsHandler):
+class PhonePointerMetadata(Metadata):
+
+    def __init__(self, identifier: bytes, engine: str):
+        """
+        :param identifier:
+        :type identifier:
+        """
+    
+        self.headers = {
+            'X-CIC-AUTOMERGE': 'server',
+            'Content-Type': 'application/json'
+        }
+        self.identifier = identifier
+        self.metadata_pointer = generate_metadata_pointer(
+                identifier=self.identifier,
+                cic_type=':cic.phone'
+        )
+        if self.base_url:
+            self.url = os.path.join(self.base_url, self.metadata_pointer)
+
+        self.engine = engine
+
+
+    def create(self, data: str):
+        try:
+            data = json.dumps(data).encode('utf-8')
+            result = make_request(method='POST', url=self.url, data=data, headers=self.headers)
+            metadata = result.content
+            logg.debug('data {} meta {} resp {} stats {}'.format(data, metadata, result.reason, result.status_code))
+            self.edit(data=metadata, engine=self.engine)
+            result.raise_for_status()
+        except requests.exceptions.HTTPError as error:
+            raise MetadataStoreError(error)
+
+
+    def edit(self, data: bytes, engine: str):
+        """
+        :param data:
+        :type data:
+        :param engine:
+        :type engine:
+        :return:
+        :rtype:
+        """
+        cic_meta_signer = Signer()
+        signature = cic_meta_signer.sign_digest(data=data)
+        algorithm = cic_meta_signer.get_operational_key().get('algo')
+        decoded_data = data.decode('utf-8')
+        formatted_data = {
+            'm': decoded_data,
+            's': {
+                'engine': engine,
+                'algo': algorithm,
+                'data': signature,
+                'digest': json.loads(data).get('digest'),
+            }
+        }
+        formatted_data = json.dumps(formatted_data).encode('utf-8')
+
+        try:
+            result = make_request(method='PUT', url=self.url, data=formatted_data, headers=self.headers)
+            logg.debug(f'signed phone pointer metadata submission status: {result.status_code}.')
+            result.raise_for_status()
+            logg.info('phone {} metadata pointer {} set to {}'.format(self.identifier.decode('utf-8'), self.metadata_pointer, decoded_data))
+        except requests.exceptions.HTTPError as error:
+            raise MetadataStoreError(error)
 
-    def __init__(self, identifier: bytes):
-        super().__init__(cic_type='cic.msisdn', identifier=identifier)

apps/cic-ussd/cic_ussd/metadata/user.py

@@ -0,0 +1,100 @@
+# standard imports
+import json
+import logging
+import os
+
+# third-party imports
+import requests
+from cic_types.models.person import generate_metadata_pointer, Person
+
+# local imports
+from cic_ussd.chain import Chain
+from cic_ussd.metadata import make_request
+from cic_ussd.metadata.signer import Signer
+from cic_ussd.redis import cache_data
+from cic_ussd.error import MetadataStoreError
+from .base import Metadata
+
+logg = logging.getLogger()
+
+
+class UserMetadata(Metadata):
+    
+
+    def __init__(self, identifier: bytes):
+        """
+        :param identifier:
+        :type identifier:
+        """
+        self.headers = {
+            'X-CIC-AUTOMERGE': 'server',
+            'Content-Type': 'application/json'
+        }
+        self.identifier = identifier
+        self.metadata_pointer = generate_metadata_pointer(
+                identifier=self.identifier,
+                cic_type=':cic.person'
+        )
+        if self.base_url:
+            self.url = os.path.join(self.base_url, self.metadata_pointer)
+
+    def create(self, data: dict):
+        try:
+            data = json.dumps(data).encode('utf-8')
+            result = make_request(method='POST', url=self.url, data=data, headers=self.headers)
+            metadata = result.content
+            self.edit(data=metadata, engine='pgp')
+            logg.info(f'Get sign material response status: {result.status_code}')
+            result.raise_for_status()
+        except requests.exceptions.HTTPError as error:
+            raise MetadataStoreError(error)
+
+    def edit(self, data: bytes, engine: str):
+        """
+        :param data:
+        :type data:
+        :param engine:
+        :type engine:
+        :return:
+        :rtype:
+        """
+        cic_meta_signer = Signer()
+        signature = cic_meta_signer.sign_digest(data=data)
+        algorithm = cic_meta_signer.get_operational_key().get('algo')
+        formatted_data = {
+            'm': data.decode('utf-8'),
+            's': {
+                'engine': engine,
+                'algo': algorithm,
+                'data': signature,
+                'digest': json.loads(data).get('digest'),
+            }
+        }
+        formatted_data = json.dumps(formatted_data).encode('utf-8')
+
+        try:
+            result = make_request(method='PUT', url=self.url, data=formatted_data, headers=self.headers)
+            logg.debug(f'signed user metadata submission status: {result.status_code}.')
+            result.raise_for_status()
+        except requests.exceptions.HTTPError as error:
+            raise MetadataStoreError(error)
+
+    def query(self):
+        result = make_request(method='GET', url=self.url)
+        status = result.status_code
+        logg.info(f'Get latest data status: {status}')
+        try:
+            if status == 200:
+                response_data = result.content
+                data = json.loads(response_data.decode())
+
+                # validate data
+                person = Person()
+                deserialized_person = person.deserialize(person_data=json.loads(data))
+
+                cache_data(key=self.metadata_pointer, data=json.dumps(deserialized_person.serialize()))
+            elif status == 404:
+                logg.info('The data is not available and might need to be added.')
+            result.raise_for_status()
+        except requests.exceptions.HTTPError as error:
+            raise MetadataNotFoundError(error)

apps/cic-ussd/cic_ussd/processor.py

@@ -235,7 +235,7 @@ def process_display_user_metadata(user: User, display_key: str):
             products=products
         )
     else:
-        raise MetadataNotFoundError(f'Expected person metadata but found none in cache for key: {key}')
+        raise MetadataNotFoundError(f'Expected user metadata but found none in cache for key: {user.blockchain_address}')
 
 
 def process_account_statement(user: User, display_key: str, ussd_session: dict):
@@ -331,11 +331,11 @@ def process_start_menu(display_key: str, user: User):
     operational_balance = compute_operational_balance(balances=balances_data)
 
     # retrieve and cache account's metadata
-    s_query_person_metadata = celery.signature(
-        'cic_ussd.tasks.metadata.query_person_metadata',
+    s_query_user_metadata = celery.signature(
+        'cic_ussd.tasks.metadata.query_user_metadata',
         [blockchain_address]
     )
-    s_query_person_metadata.apply_async(queue='cic-ussd')
+    s_query_user_metadata.apply_async(queue='cic-ussd')
 
     # retrieve and cache account's statement
     retrieve_account_statement(blockchain_address=blockchain_address)
@@ -389,11 +389,14 @@ def process_request(user_input: str, user: User, ussd_session: Optional[dict] =
                 identifier=blockchain_address_to_metadata_pointer(blockchain_address=user.blockchain_address),
                 cic_type='cic.person'
             )
-            person_metadata = get_cached_data(key=key)
+            logg.debug(f'METADATA POINTER: {key}')
+            user_metadata = get_cached_data(key=key)
+            logg.debug(f'METADATA: {user_metadata}')
 
             if last_ussd_session:
                 # get last state
                 last_state = last_ussd_session.state
+                logg.debug(f'LAST USSD SESSION STATE: {last_state}')
                 # if last state is account_creation_prompt and metadata exists, show start menu
                 if last_state in [
                     'account_creation_prompt',
@@ -402,7 +405,7 @@ def process_request(user_input: str, user: User, ussd_session: Optional[dict] =
                     'exit_invalid_new_pin',
                     'exit_pin_mismatch',
                     'exit_invalid_request'
-                ] and person_metadata is not None:
+                ] and user_metadata is not None:
                     return UssdMenu.find_by_name(name='start')
                 else:
                     return UssdMenu.find_by_name(name=last_state)

apps/cic-ussd/cic_ussd/state_machine/logic/transaction.py

@@ -97,11 +97,11 @@ def retrieve_recipient_metadata(state_machine_data: Tuple[str, dict, User]):
     recipient = get_user_by_phone_number(phone_number=user_input)
     blockchain_address = recipient.blockchain_address
     # retrieve and cache account's metadata
-    s_query_person_metadata = celery.signature(
-        'cic_ussd.tasks.metadata.query_person_metadata',
+    s_query_user_metadata = celery.signature(
+        'cic_ussd.tasks.metadata.query_user_metadata',
         [blockchain_address]
     )
-    s_query_person_metadata.apply_async(queue='cic-ussd')
+    s_query_user_metadata.apply_async(queue='cic-ussd')
 
 
 def save_transaction_amount_to_session_data(state_machine_data: Tuple[str, dict, User]):

apps/cic-ussd/cic_ussd/state_machine/logic/user.py

@@ -164,11 +164,11 @@ def save_complete_user_metadata(state_machine_data: Tuple[str, dict, User]):
     user_metadata = format_user_metadata(metadata=metadata, user=user)
 
     blockchain_address = user.blockchain_address
-    s_create_person_metadata = celery.signature(
-        'cic_ussd.tasks.metadata.create_person_metadata',
+    s_create_user_metadata = celery.signature(
+        'cic_ussd.tasks.metadata.create_user_metadata',
         [blockchain_address, user_metadata]
     )
-    s_create_person_metadata.apply_async(queue='cic-ussd')
+    s_create_user_metadata.apply_async(queue='cic-ussd')
 
 
 def edit_user_metadata_attribute(state_machine_data: Tuple[str, dict, User]):
@@ -211,18 +211,18 @@ def edit_user_metadata_attribute(state_machine_data: Tuple[str, dict, User]):
 
     edited_metadata = deserialized_person.serialize()
 
-    s_edit_person_metadata = celery.signature(
-        'cic_ussd.tasks.metadata.edit_person_metadata',
-        [blockchain_address, edited_metadata]
+    s_edit_user_metadata = celery.signature(
+        'cic_ussd.tasks.metadata.edit_user_metadata',
+        [blockchain_address, edited_metadata, 'pgp']
     )
-    s_edit_person_metadata.apply_async(queue='cic-ussd')
+    s_edit_user_metadata.apply_async(queue='cic-ussd')
 
 
 def get_user_metadata(state_machine_data: Tuple[str, dict, User]):
     user_input, ussd_session, user = state_machine_data
     blockchain_address = user.blockchain_address
     s_get_user_metadata = celery.signature(
-        'cic_ussd.tasks.metadata.query_person_metadata',
+        'cic_ussd.tasks.metadata.query_user_metadata',
         [blockchain_address]
     )
     s_get_user_metadata.apply_async(queue='cic-ussd')

apps/cic-ussd/cic_ussd/tasks/callback_handler.py

@@ -57,9 +57,14 @@ def process_account_creation_callback(self, result: str, url: str, status_code:
             queue = self.request.delivery_info.get('routing_key')
             s = celery.signature(
                     'cic_ussd.tasks.metadata.add_phone_pointer',
-                    [result, phone_number]
+                    [
+                        result,
+                        phone_number,
+                        'pgp',
+                    ],
+                    queue=queue,
                     )
-            s.apply_async(queue=queue)
+            s.apply_async()
 
             # expire cache
             cache.expire(task_id, timedelta(seconds=180))

apps/cic-ussd/cic_ussd/tasks/metadata.py

@@ -1,13 +1,14 @@
 # standard imports
+import json
 import logging
 
-# third-party imports
+# external imports
 import celery
 from hexathon import strip_0x
 
 # local imports
 from cic_ussd.metadata import blockchain_address_to_metadata_pointer
-from cic_ussd.metadata.person import PersonMetadata
+from cic_ussd.metadata.user import UserMetadata
 from cic_ussd.metadata.phone import PhonePointerMetadata
 from cic_ussd.tasks.base import CriticalMetadataTask
 
@@ -16,7 +17,7 @@ logg = logging.getLogger().getChild(__name__)
 
 
 @celery_app.task
-def query_person_metadata(blockchain_address: str):
+def query_user_metadata(blockchain_address: str):
     """
     :param blockchain_address:
     :type blockchain_address:
@@ -24,12 +25,12 @@ def query_person_metadata(blockchain_address: str):
     :rtype:
     """
     identifier = blockchain_address_to_metadata_pointer(blockchain_address=blockchain_address)
-    person_metadata_client = PersonMetadata(identifier=identifier)
-    person_metadata_client.query()
+    user_metadata_client = UserMetadata(identifier=identifier)
+    user_metadata_client.query()
 
 
 @celery_app.task
-def create_person_metadata(blockchain_address: str, data: dict):
+def create_user_metadata(blockchain_address: str, data: dict):
     """
     :param blockchain_address:
     :type blockchain_address:
@@ -39,20 +40,19 @@ def create_person_metadata(blockchain_address: str, data: dict):
     :rtype:
     """
     identifier = blockchain_address_to_metadata_pointer(blockchain_address=blockchain_address)
-    person_metadata_client = PersonMetadata(identifier=identifier)
-    person_metadata_client.create(data=data)
+    user_metadata_client = UserMetadata(identifier=identifier)
+    user_metadata_client.create(data=data)
 
 
 @celery_app.task
-def edit_person_metadata(blockchain_address: str, data: bytes):
+def edit_user_metadata(blockchain_address: str, data: bytes, engine: str):
     identifier = blockchain_address_to_metadata_pointer(blockchain_address=blockchain_address)
-    person_metadata_client = PersonMetadata(identifier=identifier)
-    person_metadata_client.edit(data=data)
+    user_metadata_client = UserMetadata(identifier=identifier)
+    user_metadata_client.edit(data=data, engine=engine)
 
 
 @celery_app.task(bind=True, base=CriticalMetadataTask)
-def add_phone_pointer(self, blockchain_address: str, phone_number: str):
-    identifier = phone_number.encode('utf-8')
+def add_phone_pointer(self, blockchain_address: str, phone: str, engine: str):
     stripped_address = strip_0x(blockchain_address)
-    phone_metadata_client = PhonePointerMetadata(identifier=identifier)
+    phone_metadata_client = PhonePointerMetadata(identifier=phone.encode('utf-8'), engine=engine)
     phone_metadata_client.create(data=stripped_address)

apps/cic-ussd/requirements.txt

@@ -1,4 +1,4 @@
-cic_base[full_graph]~=0.1.2a68
+cic_base[full_graph]~=0.1.2a67
 cic-eth~=0.11.0b3
 cic-notify~=0.4.0a3
 cic-types~=0.1.0a10

apps/cic-ussd/tests/cic_ussd/metadata/test_user_metadata.py

@@ -9,26 +9,26 @@ from cic_types.models.person import generate_metadata_pointer
 # local imports
 from cic_ussd.metadata import blockchain_address_to_metadata_pointer
 from cic_ussd.metadata.signer import Signer
-from cic_ussd.metadata.person import PersonMetadata
+from cic_ussd.metadata.user import UserMetadata
 from cic_ussd.redis import get_cached_data
 
 
 def test_user_metadata(create_activated_user, define_metadata_pointer_url, load_config):
-    PersonMetadata.base_url = load_config.get('CIC_META_URL')
+    UserMetadata.base_url = load_config.get('CIC_META_URL')
     identifier = blockchain_address_to_metadata_pointer(blockchain_address=create_activated_user.blockchain_address)
-    person_metadata_client = PersonMetadata(identifier=identifier)
+    user_metadata_client = UserMetadata(identifier=identifier)
 
-    assert person_metadata_client.url == define_metadata_pointer_url
+    assert user_metadata_client.url == define_metadata_pointer_url
 
 
-def test_create_person_metadata(caplog,
-                                create_activated_user,
-                                define_metadata_pointer_url,
-                                load_config,
-                                mock_meta_post_response,
-                                person_metadata):
+def test_create_user_metadata(caplog,
+                              create_activated_user,
+                              define_metadata_pointer_url,
+                              load_config,
+                              mock_meta_post_response,
+                              person_metadata):
     identifier = blockchain_address_to_metadata_pointer(blockchain_address=create_activated_user.blockchain_address)
-    person_metadata_client = PersonMetadata(identifier=identifier)
+    user_metadata_client = UserMetadata(identifier=identifier)
 
     with requests_mock.Mocker(real_http=False) as request_mocker:
         request_mocker.register_uri(
@@ -38,7 +38,7 @@ def test_create_person_metadata(caplog,
             reason='CREATED',
             content=json.dumps(mock_meta_post_response).encode('utf-8')
         )
-        person_metadata_client.create(data=person_metadata)
+        user_metadata_client.create(data=person_metadata)
         assert 'Get signed material response status: 201' in caplog.text
 
     with pytest.raises(RuntimeError) as error:
@@ -49,19 +49,19 @@ def test_create_person_metadata(caplog,
                 status_code=400,
                 reason='BAD REQUEST'
             )
-            person_metadata_client.create(data=person_metadata)
+            user_metadata_client.create(data=person_metadata)
         assert str(error.value) == f'400 Client Error: BAD REQUEST for url: {define_metadata_pointer_url}'
 
 
-def test_edit_person_metadata(caplog,
-                              create_activated_user,
-                              define_metadata_pointer_url,
-                              load_config,
-                              person_metadata,
-                              setup_metadata_signer):
+def test_edit_user_metadata(caplog,
+                            create_activated_user,
+                            define_metadata_pointer_url,
+                            load_config,
+                            person_metadata,
+                            setup_metadata_signer):
     Signer.gpg_passphrase = load_config.get('KEYS_PASSPHRASE')
     identifier = blockchain_address_to_metadata_pointer(blockchain_address=create_activated_user.blockchain_address)
-    person_metadata_client = PersonMetadata(identifier=identifier)
+    user_metadata_client = UserMetadata(identifier=identifier)
     with requests_mock.Mocker(real_http=False) as request_mocker:
         request_mocker.register_uri(
             'PUT',
@@ -69,7 +69,7 @@ def test_edit_person_metadata(caplog,
             status_code=200,
             reason='OK'
         )
-        person_metadata_client.edit(data=person_metadata)
+        user_metadata_client.edit(data=person_metadata, engine='pgp')
         assert 'Signed content submission status: 200' in caplog.text
 
     with pytest.raises(RuntimeError) as error:
@@ -80,7 +80,7 @@ def test_edit_person_metadata(caplog,
                 status_code=400,
                 reason='BAD REQUEST'
             )
-            person_metadata_client.edit(data=person_metadata)
+            user_metadata_client.edit(data=person_metadata, engine='pgp')
         assert str(error.value) == f'400 Client Error: BAD REQUEST for url: {define_metadata_pointer_url}'
 
 
@@ -92,7 +92,7 @@ def test_get_user_metadata(caplog,
                            person_metadata,
                            setup_metadata_signer):
     identifier = blockchain_address_to_metadata_pointer(blockchain_address=create_activated_user.blockchain_address)
-    person_metadata_client = PersonMetadata(identifier=identifier)
+    user_metadata_client = UserMetadata(identifier=identifier)
     with requests_mock.Mocker(real_http=False) as request_mocker:
         request_mocker.register_uri(
             'GET',
@@ -101,7 +101,7 @@ def test_get_user_metadata(caplog,
             content=json.dumps(person_metadata).encode('utf-8'),
             reason='OK'
         )
-        person_metadata_client.query()
+        user_metadata_client.query()
         assert 'Get latest data status: 200' in caplog.text
     key = generate_metadata_pointer(
         identifier=identifier,
@@ -118,6 +118,6 @@ def test_get_user_metadata(caplog,
                 status_code=404,
                 reason='NOT FOUND'
             )
-            person_metadata_client.query()
+            user_metadata_client.query()
             assert 'The data is not available and might need to be added.' in caplog.text
         assert str(error.value) == f'400 Client Error: NOT FOUND for url: {define_metadata_pointer_url}'

apps/cic-ussd/tests/cic_ussd/state_machine/logic/test_user_logic.py

@@ -15,7 +15,7 @@ from cic_ussd.state_machine.logic.user import (
     get_user_metadata,
     save_complete_user_metadata,
     process_gender_user_input,
-    save_metadata_attribute_to_session_data,
+    save_profile_attribute_to_session_data,
     update_account_status_to_active)
 
 
@@ -41,14 +41,14 @@ def test_update_account_status_to_active(create_pending_user, create_in_db_ussd_
     ("enter_location", "location", "Kangemi", "Kangemi"),
     ("enter_products", "products", "Mandazi", "Mandazi"),
 ])
-def test_save_metadata_attribute_to_session_data(current_state,
-                                                 expected_key,
-                                                 expected_result,
-                                                 user_input,
-                                                 celery_session_worker,
-                                                 create_activated_user,
-                                                 create_in_db_ussd_session,
-                                                 create_in_redis_ussd_session):
+def test_save_save_profile_attribute_to_session_data(current_state,
+                                                     expected_key,
+                                                     expected_result,
+                                                     user_input,
+                                                     celery_session_worker,
+                                                     create_activated_user,
+                                                     create_in_db_ussd_session,
+                                                     create_in_redis_ussd_session):
     create_in_db_ussd_session.state = current_state
     serialized_in_db_ussd_session = create_in_db_ussd_session.to_json()
     state_machine_data = (user_input, serialized_in_db_ussd_session, create_activated_user)
@@ -56,7 +56,7 @@ def test_save_metadata_attribute_to_session_data(current_state,
     in_memory_ussd_session = json.loads(in_memory_ussd_session)
     assert in_memory_ussd_session.get('session_data') == {}
     serialized_in_db_ussd_session['state'] = current_state
-    save_metadata_attribute_to_session_data(state_machine_data=state_machine_data)
+    save_profile_attribute_to_session_data(state_machine_data=state_machine_data)
 
     in_memory_ussd_session = InMemoryStore.cache.get('AT974186')
     in_memory_ussd_session = json.loads(in_memory_ussd_session)
@@ -87,18 +87,18 @@ def test_format_user_metadata(create_activated_user,
 
 
 def test_save_complete_user_metadata(celery_session_worker,
-                                     complete_user_metadata,
-                                     create_activated_user,
-                                     create_in_redis_ussd_session,
-                                     mocker,
-                                     setup_chain_spec,
-                                     ussd_session_data):
+                                        complete_user_metadata,
+                                        create_activated_user,
+                                        create_in_redis_ussd_session,
+                                        mocker,
+                                        setup_chain_spec,
+                                        ussd_session_data):
     ussd_session = create_in_redis_ussd_session.get(ussd_session_data.get('external_session_id'))
     ussd_session = json.loads(ussd_session)
     ussd_session['session_data'] = complete_user_metadata
     user_metadata = format_user_metadata(metadata=ussd_session.get('session_data'), user=create_activated_user)
     state_machine_data = ('', ussd_session, create_activated_user)
-    mocked_create_metadata_task = mocker.patch('cic_ussd.tasks.metadata.create_person_metadata.apply_async')
+    mocked_create_metadata_task = mocker.patch('cic_ussd.tasks.metadata.create_user_metadata.apply_async')
     save_complete_user_metadata(state_machine_data=state_machine_data)
     mocked_create_metadata_task.assert_called_with(
         (user_metadata, create_activated_user.blockchain_address),
@@ -127,7 +127,7 @@ def test_edit_user_metadata_attribute(celery_session_worker,
     }
     state_machine_data = ('', ussd_session, create_activated_user)
 
-    mocked_edit_metadata = mocker.patch('cic_ussd.tasks.metadata.edit_person_metadata.apply_async')
+    mocked_edit_metadata = mocker.patch('cic_ussd.tasks.metadata.edit_user_metadata.apply_async')
     edit_user_metadata_attribute(state_machine_data=state_machine_data)
     person_metadata['location']['area_name'] = 'nairobi'
     mocked_edit_metadata.assert_called_with(
@@ -146,7 +146,7 @@ def test_get_user_metadata_attribute(celery_session_worker,
     ussd_session = json.loads(ussd_session)
     state_machine_data = ('', ussd_session, create_activated_user)
 
-    mocked_get_metadata = mocker.patch('cic_ussd.tasks.metadata.query_person_metadata.apply_async')
+    mocked_get_metadata = mocker.patch('cic_ussd.tasks.metadata.query_user_metadata.apply_async')
     get_user_metadata(state_machine_data=state_machine_data)
     mocked_get_metadata.assert_called_with(
         (create_activated_user.blockchain_address,),

apps/cic-ussd/tests/fixtures/config.py

@@ -18,7 +18,7 @@ from cic_ussd.files.local_files import create_local_file_data_stores, json_file_
 from cic_ussd.menu.ussd_menu import UssdMenu
 from cic_ussd.metadata import blockchain_address_to_metadata_pointer
 from cic_ussd.metadata.signer import Signer
-from cic_ussd.metadata.person import PersonMetadata
+from cic_ussd.metadata.user import UserMetadata
 from cic_ussd.state_machine import UssdStateMachine
 
 
@@ -121,9 +121,9 @@ def setup_metadata_signer(load_config):
 @pytest.fixture(scope='function')
 def define_metadata_pointer_url(load_config, create_activated_user):
     identifier = blockchain_address_to_metadata_pointer(blockchain_address=create_activated_user.blockchain_address)
-    PersonMetadata.base_url = load_config.get('CIC_META_URL')
-    person_metadata_client = PersonMetadata(identifier=identifier)
-    return person_metadata_client.url
+    UserMetadata.base_url = load_config.get('CIC_META_URL')
+    user_metadata_client = UserMetadata(identifier=identifier)
+    return user_metadata_client.url
 
 
 @pytest.fixture(scope='function')

apps/contract-migration/docker/Dockerfile

@@ -57,9 +57,9 @@ WORKDIR /home/grassroots
 USER grassroots
 
 ARG pip_extra_index_url=https://pip.grassrootseconomics.net:8433
-ARG cic_base_version=0.1.2a67
-ARG cic_eth_version=0.11.0b1
-ARG sarafu_faucet_version=0.0.2a19
+ARG cic_base_version=0.1.2a68
+ARG cic_eth_version=0.11.0b3
+ARG sarafu_faucet_version=0.0.2a20
 ARG cic_contracts_version=0.0.2a2
 RUN pip install --user --extra-index-url $pip_extra_index_url cic-base[full_graph]==$cic_base_version \
 	cic-eth==$cic_eth_version \

apps/contract-migration/reset.sh

@@ -7,12 +7,17 @@ DEV_ETH_ACCOUNT_RESERVE_MINTER=${DEV_ETH_ACCOUNT_RESERVE_MINTER:-$DEV_ETH_ACCOUN
 DEV_ETH_ACCOUNT_ACCOUNTS_INDEX_WRITER=${DEV_ETH_ACCOUNT_RESERVE_MINTER:-$DEV_ETH_ACCOUNT_CONTRACT_DEPLOYER}
 DEV_RESERVE_AMOUNT=${DEV_ETH_RESERVE_AMOUNT:-""10000000000000000000000000000000000}
 faucet_amount=${DEV_FAUCET_AMOUNT:-0}
-keystore_file=$(realpath ./keystore/UTC--2021-01-08T17-18-44.521011372Z--eb3907ecad74a0013c259d5874ae7f22dcbcc95c)
+keystore_file=$()
+DEV_ETH_KEYSTORE_FILE=${DEV_KEYSTORE_FILE:-`realpath ./keystore/UTC--2021-01-08T17-18-44.521011372Z--eb3907ecad74a0013c259d5874ae7f22dcbcc95c`}
+DEV_ETH_ACCOUNT_CONTRACT_DEPLOYER=`eth-checksum 0x$(cat $DEV_ETH_KEYSTORE_FILE | jq -r .address)`
+
 
 echo "environment:"
 printenv
 echo \n
 
+echo "using wallet address $DEV_ETH_ACCOUNT_CONTRACT_DEPLOYER"
+exit 0
 # This is a grassroots team convention for building the Bancor contracts using the bancor protocol repository truffle setup
 # Running this in docker-internal dev container (built from Docker folder in this repo) will write a
 # source-able env file to CIC_DATA_DIR. Services dependent on these contracts can mount this file OR 

docker-compose.yml

@@ -145,7 +145,7 @@ services:
       - -c
       - |
         if [[ -f /tmp/cic/config/.env ]]; then source /tmp/cic/config/.env; fi 
-        ./start_tracker.sh -c /usr/local/etc/cic-cache -vv
+        /usr/local/bin/cic-cache-trackerd -vv -c /usr/local/etc/cic-cache
     volumes:
       - contract-config:/tmp/cic/config/:ro
 
@@ -191,13 +191,13 @@ services:
         context: apps
         dockerfile: cic-cache/docker/Dockerfile
     environment:
-      DATABASE_USER: ${DATABASE_USER:-grassroots}
-      DATABASE_HOST: ${DATABASE_HOST:-postgres}
-      DATABASE_PORT: ${DATABASE_PORT:-5432}
-        #DATABASE_PASSWORD: ${DATABASE_PASSWORD:-
-      DATABASE_NAME: ${DATABASE_NAME_CIC_CACHE:-cic_cache}
+      DATABASE_USER: $DATABASE_USER
+      DATABASE_HOST: $DATABASE_HOST
+      DATABASE_PORT: $DATABASE_PORT
+      DATABASE_PASSWORD: $DATABASE_PASSWORD
+      DATABASE_NAME: $DATABASE_NAME_CIC_CACHE
       DATABASE_DEBUG: 1
-        #PGPASSWORD: $DATABASE_PASSWORD
+      PGPASSWORD: $DATABASE_PASSWORD
       SERVER_PORT: 8000
     ports:
       - ${HTTP_PORT_CIC_CACHE:-63313}:8000
@@ -212,10 +212,9 @@ services:
       - |
         if [[ -f /tmp/cic/config/.env ]]; then source /tmp/cic/config/.env; fi 
         "/usr/local/bin/uwsgi" \
-        --wsgi-file /usr/src/cic-cache/cic_cache/runnable/daemons/server.py \
+        --wsgi-file /usr/src/cic-cache/cic_cache/runnable/serverd.py \
         --http :8000 \
-        --pyargv "-vv"
-
+        --pyargv -vv
 
   cic-eth-tasker:
     # image: grassrootseconomics:cic-eth-service