Rehabilitate tests after merge

.gitignore

@@ -14,4 +14,3 @@ build/
 **/.venv
 .idea
 **/.vim
-**/*secret.yaml

.gitlab-ci.yml

@@ -1,43 +1,14 @@
 include:
-  #- local: 'ci_templates/.cic-template.yml' #kaniko build templates
+  - local: 'ci_templates/.cic-template.yml'
-  # these includes are app specific unit tests
+  - local: 'apps/contract-migration/.gitlab-ci.yml'
   - local: 'apps/cic-eth/.gitlab-ci.yml'
   - local: 'apps/cic-ussd/.gitlab-ci.yml'
   - local: 'apps/cic-notify/.gitlab-ci.yml'
   - local: 'apps/cic-meta/.gitlab-ci.yml'
   - local: 'apps/cic-cache/.gitlab-ci.yml'
-    #- local: 'apps/contract-migration/.gitlab-ci.yml'
+  - local: 'apps/data-seeding/.gitlab-ci.yml'
-    #- local: 'apps/data-seeding/.gitlab-ci.yml'
 
 stages:
   - build
   - test
-  - deploy
+  - release
-
-image: registry.gitlab.com/grassrootseconomics/cic-internal-integration/docker-with-compose:latest
-
-variables:
-  DOCKER_BUILDKIT: "1"
-  COMPOSE_DOCKER_CLI_BUILD: "1"
-  CI_DEBUG_TRACE: "true"
-
-before_script:
-    - docker login -u gitlab-ci-token -p $CI_JOB_TOKEN $CI_REGISTRY
-
-# runs on protected branches and pushes to repo
-build-push:
-  stage: build
-  tags:
-    - integration
-  #script:
-  #  - TAG=$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA sh ./scripts/build-push.sh
-  script:
-    - TAG=latest sh ./scripts/build-push.sh
-  rules:
-  - if: $CI_COMMIT_REF_PROTECTED == "true"
-    when: always
-
-deploy-dev:
-  stage: deploy
-  trigger: grassrootseconomics/devops
-  when: manual

README.md

@@ -2,21 +2,25 @@
 
 ## Getting started 
 
-This repo uses docker-compose and docker buildkit. Set the following environment variables to get started:
+## Make some keys
 
 ```
-export COMPOSE_DOCKER_CLI_BUILD=1
+docker build -t bloxie . && docker run -v "$(pwd)/keys:/root/keys" --rm -it -t bloxie account new --chain /root/bloxberg.json --keys-path /root/keys
-export DOCKER_BUILDKIT=1
 ```
 
-start services, database, redis and local ethereum node
-```
-docker-compose up -d
-```
 
-Run app/contract-migration to deploy contracts
+### Prepare the repo
+
+This is stuff we need to put in  makefile but for now...
+
+File mounts and permisssions need to be set
 ```
-RUN_MASK=3 docker-compose up contract-migration
+chmod -R 755 scripts/initdb apps/cic-meta/scripts/initdb
+````
+
+start cluster
+```
+docker-compose up
 ```
 
 stop cluster
@@ -24,9 +28,9 @@ stop cluster
 docker-compose down
 ```
 
-stop cluster and delete data
+delete data
 ```
-docker-compose down -v --remove-orphans
+docker-compose down -v
 ```
 
 rebuild an images
@@ -34,7 +38,5 @@ rebuild an images
 docker-compose up --build <service_name>
 ```
 
-to delete the buildkit cache
+Deployment variables are writtend to service-configs/.env after everthing is up.
-```
+
-docker builder prune --filter type=exec.cachemount
-```

apps/cic-base-os/Dockerfile

@@ -0,0 +1,34 @@
+# The solc image messes up the alpine environment, so we have to go all over again
+FROM python:3.8.6-slim-buster
+
+LABEL authors="Louis Holbrook <dev@holbrook.no> 0826EDA1702D1E87C6E2875121D2E7BB88C2A746"
+LABEL spdx-license-identifier="GPL-3.0-or-later"
+LABEL description="Base layer for buiding development images for the cic component suite"
+
+RUN apt-get update && \
+	apt-get install -y git gcc g++ libpq-dev && \
+	apt-get install -y vim gawk jq telnet openssl iputils-ping curl wget gnupg socat bash procps make python2 postgresql-client
+
+
+RUN echo installing nodejs tooling
+
+COPY ./dev/nvm.sh /root/
+
+# Install nvm with node and npm
+# https://stackoverflow.com/questions/25899912/how-to-install-nvm-in-docker
+ENV NVM_DIR /root/.nvm
+ENV NODE_VERSION 15.3.0
+ENV BANCOR_NODE_VERSION 10.16.0
+
+RUN wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.37.2/install.sh | bash \
+	&& . $NVM_DIR/nvm.sh \
+	&& nvm install $NODE_VERSION \
+	&& nvm alias default $NODE_VERSION \
+	&& nvm use $NODE_VERSION \
+# So many ridiculously stupid issues with node in docker that take oceans of absolutely wasted time to resolve
+# owner of these files is "1001" by default - wtf
+	&& chown -R root:root "$NVM_DIR/versions/node/v$NODE_VERSION"
+
+ENV NODE_PATH $NVM_DIR/versions/node//v$NODE_VERSION/lib/node_modules
+ENV PATH      $NVM_DIR/versions/node//v$NODE_VERSION/bin:$PATH
+

apps/cic-base-os/README.md

@@ -0,0 +1 @@
+## this is an example base image if we wanted one for all the other apps. Its just OS level things

apps/cic-cache/.gitlab-ci.yml

@@ -1,17 +1,52 @@
-build-test-cic-cache:
+.cic_cache_variables:
-  stage: test 
+    variables:
-  tags:
+        APP_NAME: cic-cache
-    - integration
+        DOCKERFILE_PATH: docker/Dockerfile_ci
-  variables:
+        CONTEXT: apps/$APP_NAME
-    APP_NAME: cic-cache
+
-    MR_IMAGE_TAG: mr-$APP_NAME-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA
+build-mr-cic-cache:
-  script:
+    extends:
-    - cd apps/cic-cache
+        - .py_build_merge_request
-    - docker build -t $MR_IMAGE_TAG -f docker/Dockerfile . 
+        - .cic_cache_variables
-    - docker run $MR_IMAGE_TAG sh docker/run_tests.sh
+    rules:
-  allow_failure: true
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-  rules:
+      changes:
-  - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+          - apps/cic-cache/**/*
-    changes:
+      when: always
-        - apps/$APP_NAME/**/*
+
-    when: always
+test-mr-cic-cache:
+    stage: test
+    extends:
+        - .cic_cache_variables
+    cache:
+        key:
+            files:
+                - test_requirements.txt
+        paths:
+        - /root/.cache/pip
+    image: $MR_IMAGE_TAG
+    script:
+        - cd apps/$APP_NAME/
+        - >
+          pip install --extra-index-url https://pip.grassrootseconomics.net:8433
+          --extra-index-url https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple
+          -r test_requirements.txt 
+        - export PYTHONPATH=. && pytest -x --cov=cic_cache --cov-fail-under=90 --cov-report term-missing tests
+    needs: ["build-mr-cic-cache"]
+    rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      changes:
+          - apps/$APP_NAME/**/*
+      when: always
+
+build-push-cic-cache:
+    extends:
+        - .py_build_push
+        - .cic_cache_variables
+    rules:
+    - if:  $CI_COMMIT_BRANCH == "master"
+      changes:
+          - apps/cic-cache/**/*
+      when: always
+        
+

apps/cic-cache/README.md

@@ -1 +0,0 @@
-# CIC-CACHE

apps/cic-cache/cic_cache/cli/rpc.py

@@ -27,11 +27,11 @@ class RPC:
     @staticmethod
     def from_config(config):
         chain_spec = ChainSpec.from_chain_str(config.get('CHAIN_SPEC'))
-        RPCConnection.register_location(config.get('RPC_PROVIDER'), chain_spec, 'default')
+        RPCConnection.register_location(config.get('RPC_HTTP_PROVIDER'), chain_spec, 'default')
         if config.get('SIGNER_PROVIDER'):
             RPCConnection.register_constructor(ConnType.UNIX, EthUnixSignerConnection, tag='signer')
             RPCConnection.register_location(config.get('SIGNER_PROVIDER'), chain_spec, 'signer')
-        rpc = RPC(chain_spec, config.get('RPC_PROVIDER'), signer_provider=config.get('SIGNER_PROVIDER'))
+        rpc = RPC(chain_spec, config.get('RPC_HTTP_PROVIDER'), signer_provider=config.get('SIGNER_PROVIDER'))
         logg.info('set up rpc: {}'.format(rpc))
         return rpc
 

apps/cic-cache/cic_cache/version.py

@@ -5,7 +5,7 @@ version = (
         0,
         2,
         1,
-        'alpha.2',
+        'alpha.1',
         )
 
 version_object = semver.VersionInfo(

apps/cic-cache/docker/Dockerfile

@@ -10,10 +10,9 @@ COPY requirements.txt .
 
 ARG EXTRA_INDEX_URL="https://pip.grassrootseconomics.net:8433"
 ARG GITLAB_PYTHON_REGISTRY="https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple"
-ARG EXTRA_PIP_ARGS=""
 RUN --mount=type=cache,mode=0755,target=/root/.cache/pip \
     pip install --index-url https://pypi.org/simple  \
-	  --extra-index-url $GITLAB_PYTHON_REGISTRY --extra-index-url $EXTRA_INDEX_URL $EXTRA_PIP_ARGS \
+	  --extra-index-url $GITLAB_PYTHON_REGISTRY --extra-index-url $EXTRA_INDEX_URL \
     -r requirements.txt
 
 COPY . . 

apps/cic-cache/docker/Dockerfile_ci

@@ -0,0 +1,37 @@
+# syntax = docker/dockerfile:1.2
+FROM registry.gitlab.com/grassrootseconomics/cic-base-images:python-3.8.6-dev-55da5f4e as dev
+ 
+# RUN pip install $pip_extra_index_url_flag cic-base[full_graph]==0.1.2b9
+
+COPY requirements.txt .
+#RUN pip install $pip_extra_index_url_flag -r test_requirements.txt
+#RUN pip install $pip_extra_index_url_flag .
+#RUN pip install .[server]
+
+ARG EXTRA_INDEX_URL="https://pip.grassrootseconomics.net:8433"
+ARG GITLAB_PYTHON_REGISTRY="https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple"
+RUN pip install --index-url https://pypi.org/simple  \
+	  --extra-index-url $GITLAB_PYTHON_REGISTRY --extra-index-url $EXTRA_INDEX_URL \
+    -r requirements.txt
+
+COPY . . 
+
+RUN python setup.py install
+
+# ini files in config directory defines the configurable parameters for the application
+# they can all be overridden by environment variables
+# to generate a list of environment variables from configuration, use: confini-dump -z <dir> (executable provided by confini package)
+COPY config/ /usr/local/etc/cic-cache/
+
+# for db migrations
+RUN git clone https://github.com/vishnubob/wait-for-it.git /usr/local/bin/wait-for-it/
+COPY cic_cache/db/migrations/ /usr/local/share/cic-cache/alembic/
+
+COPY /docker/start_tracker.sh ./start_tracker.sh
+COPY /docker/db.sh ./db.sh
+RUN chmod 755 ./*.sh
+# Tracker
+# ENTRYPOINT ["/usr/local/bin/cic-cache-tracker", "-vv"]
+# Server
+# ENTRYPOINT [ "/usr/local/bin/uwsgi", "--wsgi-file", "/usr/local/lib/python3.8/site-packages/cic_cache/runnable/server.py", "--http", ":80", "--pyargv", "-vv" ]
+ENTRYPOINT []

apps/cic-cache/docker/run_tests.sh

@@ -1,10 +0,0 @@
-#! /bin/bash
-
-set -e
-
-pip install --extra-index-url https://pip.grassrootseconomics.net:8433 \
---extra-index-url https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple \
--r test_requirements.txt 
-
-export PYTHONPATH=. && pytest -x --cov=cic_cache --cov-fail-under=90 --cov-report term-missing tests
-

apps/cic-cache/requirements.txt

@@ -2,13 +2,14 @@ alembic==1.4.2
 confini>=0.3.6rc4,<0.5.0
 uwsgi==2.0.19.1
 moolb~=0.1.1b2
-cic-eth-registry~=0.6.1a1
+cic-eth-registry~=0.5.8a1
 SQLAlchemy==1.3.20
 semver==2.13.0
 psycopg2==2.8.6
 celery==4.4.7
 redis==3.5.3
-chainsyncer[sql]>=0.0.6a3,<0.1.0
+chainsyncer[sql]>=0.0.6a1,<0.1.0
-erc20-faucet>=0.3.2a2, <0.4.0
+erc20-faucet>=0.2.4a2, <0.3.0
-chainlib-eth>=0.0.9a14,<0.1.0
+chainlib-eth>=0.0.7a3,<0.1.0
-eth-address-index>=0.2.3a4,<0.3.0
+chainlib>=0.0.7a3,<0.1.0
+eth-address-index>=0.1.4a1,<0.2.0

apps/cic-cache/test_requirements.txt

@@ -6,5 +6,5 @@ sqlparse==0.4.1
 pytest-celery==0.0.0a1
 eth_tester==0.5.0b3
 py-evm==0.3.0a20
-sarafu-faucet~=0.0.7a1
+sarafu-faucet~=0.0.5a2
-erc20-transfer-authorization>=0.3.5a1,<0.4.0
+erc20-transfer-authorization>=0.3.4a1,<0.4.0

apps/cic-eth-aux/erc20-demurrage-token/requirements.txt

@@ -1,4 +1,5 @@
 celery==4.4.7
 erc20-demurrage-token~=0.0.3a1
-cic-eth-registry>=0.6.1a2,<0.7.0
+cic-eth-registry~=0.5.8a1
-cic-eth[services]~=0.12.4a8
+chainlib~=0.0.7a1
+cic_eth~=0.12.2a4

apps/cic-eth/.gitlab-ci.yml

@@ -1,16 +1,52 @@
-build-test-cic-eth:
+.cic_eth_variables:
-  stage: test
+    variables:
-  tags:
+        APP_NAME: cic-eth
-    - integration
+        DOCKERFILE_PATH: docker/Dockerfile_ci
-  variables:
+        CONTEXT: apps/$APP_NAME
-    APP_NAME: cic-eth
+
-    MR_IMAGE_TAG: mr-$APP_NAME-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA
+build-mr-cic-eth:
-  script:
+    extends:
-    - cd apps/cic-eth
+        - .cic_eth_variables
-    - docker build -t $MR_IMAGE_TAG -f docker/Dockerfile . 
+        - .py_build_target_dev
-    - docker run $MR_IMAGE_TAG sh docker/run_tests.sh
+    rules:
-  rules:
     - if: $CI_PIPELINE_SOURCE == "merge_request_event"
       changes:
-          - apps/$APP_NAME/**/*
+          - apps/cic-eth/**/*
+      when: always
+
+test-mr-cic-eth:
+    stage: test
+    extends:
+        - .cic_eth_variables
+    cache:
+        key:
+            files:
+                - test_requirements.txt
+        paths:
+        - /root/.cache/pip
+    image: $MR_IMAGE_TAG
+    script:
+        - cd apps/$APP_NAME/
+        - >
+          pip install --extra-index-url https://pip.grassrootseconomics.net:8433
+          --extra-index-url https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple
+          -r admin_requirements.txt
+          -r services_requirements.txt
+          -r test_requirements.txt 
+        - export PYTHONPATH=. && pytest -x --cov=cic_eth --cov-fail-under=90 --cov-report term-missing tests
+    needs: ["build-mr-cic-eth"]
+    rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      changes:
+          - apps/cic-eth/**/*
+      when: always
+
+build-push-cic-eth:
+    extends:
+        - .py_build_push
+        - .cic_eth_variables
+    rules:
+    - if:  $CI_COMMIT_BRANCH == "master"
+      changes:
+          - apps/cic-eth/**/*
       when: always

apps/cic-eth/admin_requirements.txt

@@ -1,5 +1,5 @@
 SQLAlchemy==1.3.20
-cic-eth-registry>=0.6.1a3,<0.7.0
+cic-eth-registry>=0.5.6a2,<0.6.0
-hexathon~=0.0.1a8
+hexathon~=0.0.1a7
-chainqueue>=0.0.4a6,<0.1.0
+chainqueue>=0.0.3a1,<0.1.0
-eth-erc20>=0.1.2a2,<0.2.0
+eth-erc20>=0.0.10a3,<0.1.0

apps/cic-eth/cic_eth/admin/ctrl.py

@@ -4,6 +4,7 @@ import logging
 
 # external imports
 import celery
+from chainlib.eth.constant import ZERO_ADDRESS
 from chainlib.chain import ChainSpec
 from hexathon import (
         add_0x,
@@ -19,17 +20,18 @@ from cic_eth.task import (
         CriticalSQLAlchemyTask,
         )
 from cic_eth.error import LockedError
-from cic_eth.encode import (
-        tx_normalize,
-        ZERO_ADDRESS_NORMAL,
-        )
 
 celery_app = celery.current_app
 logg = logging.getLogger()
 
 
+def normalize_address(a):
+    if a == None:
+        return None
+    return add_0x(hex_uniform(strip_0x(a)))
+
 @celery_app.task(base=CriticalSQLAlchemyTask)
-def lock(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, flags=LockEnum.ALL, tx_hash=None):
+def lock(chained_input, chain_spec_dict, address=ZERO_ADDRESS, flags=LockEnum.ALL, tx_hash=None):
     """Task wrapper to set arbitrary locks
 
     :param chain_str: Chain spec string representation
@@ -41,7 +43,7 @@ def lock(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, flags=Lock
     :returns: New lock state for address
     :rtype: number
     """
-    address = tx_normalize.wallet_address(address)
+    address = normalize_address(address)
     chain_str = '::'
     if chain_spec_dict != None:
         chain_str = str(ChainSpec.from_dict(chain_spec_dict))
@@ -51,7 +53,7 @@ def lock(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, flags=Lock
 
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
-def unlock(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, flags=LockEnum.ALL):
+def unlock(chained_input, chain_spec_dict, address=ZERO_ADDRESS, flags=LockEnum.ALL):
     """Task wrapper to reset arbitrary locks
 
     :param chain_str: Chain spec string representation
@@ -63,7 +65,7 @@ def unlock(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, flags=Lo
     :returns: New lock state for address
     :rtype: number
     """
-    address = tx_normalize.wallet_address(address)
+    address = normalize_address(address)
     chain_str = '::'
     if chain_spec_dict != None:
         chain_str = str(ChainSpec.from_dict(chain_spec_dict))
@@ -73,7 +75,7 @@ def unlock(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, flags=Lo
 
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
-def lock_send(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, tx_hash=None):
+def lock_send(chained_input, chain_spec_dict, address=ZERO_ADDRESS, tx_hash=None):
     """Task wrapper to set send lock
 
     :param chain_str: Chain spec string representation
@@ -83,7 +85,7 @@ def lock_send(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, tx_ha
     :returns: New lock state for address
     :rtype: number
     """
-    address = tx_normalize.wallet_address(address)
+    address = normalize_address(address)
     chain_str = str(ChainSpec.from_dict(chain_spec_dict))
     r = Lock.set(chain_str, LockEnum.SEND, address=address, tx_hash=tx_hash)
     logg.debug('Send locked for {}, flag now {}'.format(address, r))
@@ -91,7 +93,7 @@ def lock_send(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, tx_ha
 
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
-def unlock_send(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL):
+def unlock_send(chained_input, chain_spec_dict, address=ZERO_ADDRESS):
     """Task wrapper to reset send lock
 
     :param chain_str: Chain spec string representation
@@ -101,7 +103,7 @@ def unlock_send(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL):
     :returns: New lock state for address
     :rtype: number
     """
-    address = tx_normalize.wallet_address(address)
+    address = normalize_address(address)
     chain_str = str(ChainSpec.from_dict(chain_spec_dict))
     r = Lock.reset(chain_str, LockEnum.SEND, address=address)
     logg.debug('Send unlocked for {}, flag now {}'.format(address, r))
@@ -109,7 +111,7 @@ def unlock_send(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL):
 
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
-def lock_queue(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, tx_hash=None):
+def lock_queue(chained_input, chain_spec_dict, address=ZERO_ADDRESS, tx_hash=None):
     """Task wrapper to set queue direct lock
 
     :param chain_str: Chain spec string representation
@@ -119,7 +121,7 @@ def lock_queue(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, tx_h
     :returns: New lock state for address
     :rtype: number
     """
-    address = tx_normalize.wallet_address(address)
+    address = normalize_address(address)
     chain_str = str(ChainSpec.from_dict(chain_spec_dict))
     r = Lock.set(chain_str, LockEnum.QUEUE, address=address, tx_hash=tx_hash)
     logg.debug('Queue direct locked for {}, flag now {}'.format(address, r))
@@ -127,7 +129,7 @@ def lock_queue(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL, tx_h
 
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
-def unlock_queue(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL):
+def unlock_queue(chained_input, chain_spec_dict, address=ZERO_ADDRESS):
     """Task wrapper to reset queue direct lock
 
     :param chain_str: Chain spec string representation
@@ -137,7 +139,7 @@ def unlock_queue(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL):
     :returns: New lock state for address
     :rtype: number
     """
-    address = tx_normalize.wallet_address(address)
+    address = normalize_address(address)
     chain_str = str(ChainSpec.from_dict(chain_spec_dict))
     r = Lock.reset(chain_str, LockEnum.QUEUE, address=address)
     logg.debug('Queue direct unlocked for {}, flag now {}'.format(address, r))
@@ -146,13 +148,12 @@ def unlock_queue(chained_input, chain_spec_dict, address=ZERO_ADDRESS_NORMAL):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def check_lock(chained_input, chain_spec_dict, lock_flags, address=None):
-    if address != None:
+    address = normalize_address(address)
-        address = tx_normalize.wallet_address(address)
     chain_str = '::'
     if chain_spec_dict != None:
         chain_str = str(ChainSpec.from_dict(chain_spec_dict))
     session = SessionBase.create_session()
-    r = Lock.check(chain_str, lock_flags, address=ZERO_ADDRESS_NORMAL, session=session)
+    r = Lock.check(chain_str, lock_flags, address=ZERO_ADDRESS, session=session)
     if address != None:
         r |= Lock.check(chain_str, lock_flags, address=address, session=session)
     if r > 0:

apps/cic-eth/cic_eth/admin/nonce.py

@@ -33,7 +33,6 @@ from cic_eth.admin.ctrl import (
 from cic_eth.queue.tx import queue_create
 from cic_eth.eth.gas import create_check_gas_task
 from cic_eth.task import BaseTask
-from cic_eth.encode import tx_normalize
 
 celery_app = celery.current_app
 logg = logging.getLogger()
@@ -74,7 +73,7 @@ def shift_nonce(self, chainspec_dict, tx_hash_orig_hex, delta=1):
 
     set_cancel(chain_spec, strip_0x(tx['hash']), manual=True, session=session)
 
-    query_address = tx_normalize.wallet_address(address)
+    query_address = add_0x(hex_uniform(strip_0x(address))) # aaaaargh
     q = session.query(Otx)
     q = q.join(TxCache)
     q = q.filter(TxCache.sender==query_address)

apps/cic-eth/cic_eth/api/admin.py

@@ -32,6 +32,7 @@ from chainqueue.db.enum import (
         status_str,
     )
 from chainqueue.error import TxStateChangeError
+from chainqueue.sql.query import get_tx
 from eth_erc20 import ERC20
 
 # local imports
@@ -39,7 +40,6 @@ from cic_eth.db.models.base import SessionBase
 from cic_eth.db.models.role import AccountRole
 from cic_eth.db.models.nonce import Nonce
 from cic_eth.error import InitializationError
-from cic_eth.queue.query import get_tx_local
 
 app = celery.current_app
 
@@ -284,7 +284,7 @@ class AdminApi:
         tx_hash_hex = None
         session = SessionBase.create_session()
         for k in txs.keys():
-            tx_dict = get_tx_local(chain_spec, k, session=session)
+            tx_dict = get_tx(chain_spec, k, session=session)
             if tx_dict['nonce'] == nonce:
                 tx_hash_hex = k
         session.close()

apps/cic-eth/cic_eth/api/api_task.py

@@ -9,7 +9,6 @@ import logging
 # external imports 
 import celery
 from chainlib.chain import ChainSpec
-from hexathon import strip_0x
 
 # local imports
 from cic_eth.api.base import ApiBase
@@ -255,8 +254,6 @@ class Api(ApiBase):
         :returns: uuid of root task
         :rtype: celery.Task
         """
-        #from_address = strip_0x(from_address)
-        #to_address = strip_0x(to_address)
         s_check = celery.signature(
                 'cic_eth.admin.ctrl.check_lock',
                 [

apps/cic-eth/cic_eth/cli/rpc.py

@@ -35,14 +35,14 @@ class RPC:
     def from_config(config, use_signer=False, default_label='default', signer_label='signer'):
         chain_spec = ChainSpec.from_chain_str(config.get('CHAIN_SPEC'))
 
-        RPCConnection.register_location(config.get('RPC_PROVIDER'), chain_spec, default_label)
+        RPCConnection.register_location(config.get('RPC_HTTP_PROVIDER'), chain_spec, default_label)
         if use_signer:
 
             RPCConnection.register_constructor(ConnType.UNIX, EthUnixSignerConnection, signer_label)
             RPCConnection.register_constructor(ConnType.HTTP, EthHTTPSignerConnection, signer_label)
             RPCConnection.register_constructor(ConnType.HTTP_SSL, EthHTTPSignerConnection, signer_label)
             RPCConnection.register_location(config.get('SIGNER_PROVIDER'), chain_spec, signer_label) 
-        rpc = RPC(chain_spec, config.get('RPC_PROVIDER'), signer_provider=config.get('SIGNER_PROVIDER'))
+        rpc = RPC(chain_spec, config.get('RPC_HTTP_PROVIDER'), signer_provider=config.get('SIGNER_PROVIDER'))
         logg.info('set up rpc: {}'.format(rpc))
         return rpc
 

apps/cic-eth/cic_eth/db/migrations/default/versions/75d4767b3031_lock.py

@@ -8,8 +8,8 @@ Create Date: 2021-04-02 18:41:20.864265
 import datetime
 from alembic import op
 import sqlalchemy as sa
+from chainlib.eth.constant import ZERO_ADDRESS
 from cic_eth.db.enum import LockEnum
-from cic_eth.encode import ZERO_ADDRESS_NORMAL
 
 
 # revision identifiers, used by Alembic.
@@ -30,7 +30,7 @@ def upgrade():
             sa.Column("otx_id", sa.Integer, sa.ForeignKey('otx.id'), nullable=True),
             )
     op.create_index('idx_chain_address', 'lock', ['blockchain', 'address'], unique=True)
-    op.execute("INSERT INTO lock (address, date_created, blockchain, flags) VALUES('{}', '{}', '::', {})".format(ZERO_ADDRESS_NORMAL, datetime.datetime.utcnow(), LockEnum.INIT | LockEnum.SEND | LockEnum.QUEUE))
+    op.execute("INSERT INTO lock (address, date_created, blockchain, flags) VALUES('{}', '{}', '::', {})".format(ZERO_ADDRESS, datetime.datetime.utcnow(), LockEnum.INIT | LockEnum.SEND | LockEnum.QUEUE))
 
 
 def downgrade():

apps/cic-eth/cic_eth/db/models/lock.py

@@ -4,12 +4,12 @@ import logging
 
 # third-party imports
 from sqlalchemy import Column, String, Integer, DateTime, ForeignKey
+from chainlib.eth.constant import ZERO_ADDRESS
 from chainqueue.db.models.tx import TxCache
 from chainqueue.db.models.otx import Otx
 
 # local imports
 from cic_eth.db.models.base import SessionBase
-from cic_eth.encode  import ZERO_ADDRESS_NORMAL
 
 logg = logging.getLogger()
 
@@ -37,7 +37,7 @@ class Lock(SessionBase):
 
 
     @staticmethod
-    def set(chain_str, flags, address=ZERO_ADDRESS_NORMAL, session=None, tx_hash=None):
+    def set(chain_str, flags, address=ZERO_ADDRESS, session=None, tx_hash=None):
         """Sets flags associated with the given address and chain.
 
         If a flags entry does not exist it is created.
@@ -90,7 +90,7 @@ class Lock(SessionBase):
 
 
     @staticmethod
-    def reset(chain_str, flags, address=ZERO_ADDRESS_NORMAL, session=None):
+    def reset(chain_str, flags, address=ZERO_ADDRESS, session=None):
         """Resets flags associated with the given address and chain.
 
         If the resulting flags entry value is 0, the entry will be deleted.
@@ -134,7 +134,7 @@ class Lock(SessionBase):
 
 
     @staticmethod
-    def check(chain_str, flags, address=ZERO_ADDRESS_NORMAL, session=None):
+    def check(chain_str, flags, address=ZERO_ADDRESS, session=None):
         """Checks whether all given flags are set for given address and chain. 
 
         Does not validate the address against any other tables or components.

apps/cic-eth/cic_eth/encode.py

@@ -1,16 +0,0 @@
-# external imports
-from chainlib.eth.constant import ZERO_ADDRESS
-from chainqueue.encode import TxHexNormalizer
-from chainlib.eth.tx import unpack
-
-tx_normalize = TxHexNormalizer()
-
-ZERO_ADDRESS_NORMAL = tx_normalize.wallet_address(ZERO_ADDRESS)
-
-
-def unpack_normal(signed_tx_bytes, chain_spec):
-    tx = unpack(signed_tx_bytes, chain_spec)
-    tx['hash'] = tx_normalize.tx_hash(tx['hash'])
-    tx['from'] = tx_normalize.wallet_address(tx['from'])
-    tx['to'] = tx_normalize.wallet_address(tx['to'])
-    return tx

apps/cic-eth/cic_eth/eth/account.py

@@ -13,8 +13,11 @@ from chainlib.eth.sign import (
         new_account,
         sign_message,
         )
-from chainlib.eth.address import to_checksum_address, is_address
+from chainlib.eth.address import to_checksum_address
-from chainlib.eth.tx import TxFormat
+from chainlib.eth.tx import (
+        TxFormat,
+        unpack,
+        )
 from chainlib.chain import ChainSpec
 from chainlib.error import JSONRPCException
 from eth_accounts_index.registry import AccountRegistry
@@ -31,7 +34,6 @@ from cic_eth.eth.gas import (
 from cic_eth.db.models.nonce import Nonce
 from cic_eth.db.models.base import SessionBase
 from cic_eth.db.models.role import AccountRole
-from cic_eth.encode import tx_normalize
 from cic_eth.error import (
         RoleMissingError,
         SignerError,
@@ -47,11 +49,6 @@ from cic_eth.eth.nonce import (
 from cic_eth.queue.tx import (
         register_tx,
         )
-from cic_eth.encode import (
-        unpack_normal,
-        ZERO_ADDRESS_NORMAL,
-        tx_normalize,
-        )
 
 logg = logging.getLogger()
 celery_app = celery.current_app 
@@ -86,7 +83,7 @@ def create(self, password, chain_spec_dict):
     # TODO: It seems infeasible that a can be None in any case, verify
     if a == None:
         raise SignerError('create account')
-    a = tx_normalize.wallet_address(a)
+        
     logg.debug('created account {}'.format(a))
 
     # Initialize nonce provider record for account
@@ -177,9 +174,6 @@ def gift(self, account_address, chain_spec_dict):
     """
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
 
-    if is_address(account_address):
-        account_address = tx_normalize.wallet_address(account_address)
-
     logg.debug('gift account address {} to index'.format(account_address))
     queue = self.request.delivery_info.get('routing_key')
 
@@ -253,9 +247,8 @@ def have(self, account, chain_spec_dict):
 
 @celery_app.task(bind=True, base=CriticalSQLAlchemyTask)
 def set_role(self, tag, address, chain_spec_dict):
-    if not is_address(address):
+    if not to_checksum_address(address):
-        raise ValueError('invalid address {}'.format(address))
+        raise ValueError('invalid checksum address {}'.format(address))
-    address = tx_normalize.wallet_address(address)
     session = SessionBase.create_session()
     role = AccountRole.set(tag, address, session=session) 
     session.add(role)
@@ -302,19 +295,17 @@ def cache_gift_data(
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
 
     tx_signed_raw_bytes = bytes.fromhex(strip_0x(tx_signed_raw_hex))
-    tx = unpack_normal(tx_signed_raw_bytes, chain_spec)
+    tx = unpack(tx_signed_raw_bytes, chain_spec)
     tx_data = Faucet.parse_give_to_request(tx['data'])
-    sender_address = tx_normalize.wallet_address(tx['from'])
-    recipient_address = tx_normalize.wallet_address(tx['to'])
 
     session = self.create_session()
 
     tx_dict = {
-            'hash': tx['hash'],
+            'hash': tx_hash_hex,
-            'from': sender_address,
+            'from': tx['from'],
-            'to': recipient_address,
+            'to': tx['to'],
-            'source_token': ZERO_ADDRESS_NORMAL,
+            'source_token': ZERO_ADDRESS,
-            'destination_token': ZERO_ADDRESS_NORMAL,
+            'destination_token': ZERO_ADDRESS,
             'from_value': 0,
             'to_value': 0,
             }
@@ -343,19 +334,17 @@ def cache_account_data(
     :rtype: tuple
     """
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
-    tx_signed_raw_bytes = bytes.fromhex(strip_0x(tx_signed_raw_hex))
+    tx_signed_raw_bytes = bytes.fromhex(tx_signed_raw_hex[2:])
-    tx = unpack_normal(tx_signed_raw_bytes, chain_spec)
+    tx = unpack(tx_signed_raw_bytes, chain_spec)
     tx_data = AccountsIndex.parse_add_request(tx['data'])
-    sender_address = tx_normalize.wallet_address(tx['from'])
-    recipient_address = tx_normalize.wallet_address(tx['to'])
 
     session = SessionBase.create_session()
     tx_dict = {
-            'hash': tx['hash'],
+            'hash': tx_hash_hex,
-            'from': sender_address,
+            'from': tx['from'],
-            'to': recipient_address,
+            'to': tx['to'],
-            'source_token': ZERO_ADDRESS_NORMAL,
+            'source_token': ZERO_ADDRESS,
-            'destination_token': ZERO_ADDRESS_NORMAL,
+            'destination_token': ZERO_ADDRESS,
             'from_value': 0,
             'to_value': 0,
             }

apps/cic-eth/cic_eth/eth/erc20.py

@@ -12,10 +12,7 @@ from chainlib.eth.tx import (
         )
 from cic_eth_registry import CICRegistry
 from cic_eth_registry.erc20 import ERC20Token
-from hexathon import (
+from hexathon import strip_0x
-        strip_0x,
-        add_0x,
-        )
 from chainqueue.error import NotLocalTxError
 from eth_erc20 import ERC20
 from chainqueue.sql.tx import cache_tx_dict
@@ -41,7 +38,6 @@ from cic_eth.task import (
         CriticalSQLAlchemyAndSignerTask,
     )
 from cic_eth.eth.nonce import CustodialTaskNonceOracle
-from cic_eth.encode import tx_normalize
 
 celery_app = celery.current_app
 logg = logging.getLogger()
@@ -66,8 +62,7 @@ def balance(tokens, holder_address, chain_spec_dict):
 
     for t in tokens:
         address = t['address']
-        logg.debug('address {} {}'.format(address, holder_address))
+        token = ERC20Token(chain_spec, rpc, address)
-        token = ERC20Token(chain_spec, rpc, add_0x(address))
         c = ERC20(chain_spec)
         o = c.balance_of(address, holder_address, sender_address=caller_address)
         r = rpc.do(o)
@@ -376,15 +371,13 @@ def cache_transfer_data(
     tx = unpack(tx_signed_raw_bytes, chain_spec)
 
     tx_data = ERC20.parse_transfer_request(tx['data'])
-    sender_address = tx_normalize.wallet_address(tx['from'])
+    recipient_address = tx_data[0]
-    recipient_address = tx_normalize.wallet_address(tx_data[0])
     token_value = tx_data[1]
 
-
     session = SessionBase.create_session()
     tx_dict = {
             'hash': tx_hash_hex,
-            'from': sender_address,
+            'from': tx['from'],
             'to': recipient_address,
             'source_token': tx['to'],
             'destination_token': tx['to'],
@@ -455,14 +448,13 @@ def cache_approve_data(
     tx = unpack(tx_signed_raw_bytes, chain_spec)
 
     tx_data = ERC20.parse_approve_request(tx['data'])
-    sender_address = tx_normalize.wallet_address(tx['from'])
+    recipient_address = tx_data[0]
-    recipient_address = tx_normalize.wallet_address(tx_data[0])
     token_value = tx_data[1]
 
     session = SessionBase.create_session()
     tx_dict = {
             'hash': tx_hash_hex,
-            'from': sender_address,
+            'from': tx['from'],
             'to': recipient_address,
             'source_token': tx['to'],
             'destination_token': tx['to'],

apps/cic-eth/cic_eth/eth/gas.py

@@ -3,17 +3,10 @@ import logging
 
 # external imports
 import celery
-from hexathon import (
+from hexathon import strip_0x
-        strip_0x,
+from chainlib.eth.constant import ZERO_ADDRESS
-        add_0x,
-        )
-#from chainlib.eth.constant import ZERO_ADDRESS
 from chainlib.chain import ChainSpec
-from chainlib.eth.address import (
+from chainlib.eth.address import is_checksum_address
-        is_checksum_address,
-        to_checksum_address,
-        is_address
-        )
 from chainlib.connection import RPCConnection
 from chainqueue.db.enum import StatusBits
 from chainqueue.sql.tx import cache_tx_dict
@@ -28,6 +21,7 @@ from chainlib.eth.error import (
 from chainlib.eth.tx import (
         TxFactory,
         TxFormat,
+        unpack,
         )
 from chainlib.eth.contract import (
         abi_decode_single,
@@ -51,7 +45,6 @@ from cic_eth.eth.nonce import CustodialTaskNonceOracle
 from cic_eth.queue.tx import (
         queue_create,
         register_tx,
-        unpack,
         )
 from cic_eth.queue.query import get_tx
 from cic_eth.task import (
@@ -60,11 +53,6 @@ from cic_eth.task import (
         CriticalSQLAlchemyAndSignerTask,
         CriticalWeb3AndSignerTask,
         )
-from cic_eth.encode import (
-        tx_normalize,
-        ZERO_ADDRESS_NORMAL,
-        unpack_normal,
-        )
 
 celery_app = celery.current_app
 logg = logging.getLogger()
@@ -142,16 +130,16 @@ def cache_gas_data(
     """
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     tx_signed_raw_bytes = bytes.fromhex(strip_0x(tx_signed_raw_hex))
-    tx = unpack_normal(tx_signed_raw_bytes, chain_spec)
+    tx = unpack(tx_signed_raw_bytes, chain_spec)
 
     session = SessionBase.create_session()
 
     tx_dict = {
-            'hash': tx['hash'],
+            'hash': tx_hash_hex,
             'from': tx['from'],
             'to': tx['to'],
-            'source_token': ZERO_ADDRESS_NORMAL,
+            'source_token': ZERO_ADDRESS,
-            'destination_token': ZERO_ADDRESS_NORMAL,
+            'destination_token': ZERO_ADDRESS,
             'from_value': tx['value'],
             'to_value': tx['value'],
             }
@@ -162,7 +150,7 @@ def cache_gas_data(
 
 
 @celery_app.task(bind=True, throws=(OutOfGasError), base=CriticalSQLAlchemyAndWeb3Task)
-def check_gas(self, tx_hashes_hex, chain_spec_dict, txs_hex=[], address=None, gas_required=MAXIMUM_FEE_UNITS):
+def check_gas(self, tx_hashes, chain_spec_dict, txs=[], address=None, gas_required=MAXIMUM_FEE_UNITS):
     """Check the gas level of the sender address of a transaction.
 
     If the account balance is not sufficient for the required gas, gas refill is requested and OutOfGasError raiser.
@@ -182,23 +170,8 @@ def check_gas(self, tx_hashes_hex, chain_spec_dict, txs_hex=[], address=None, ga
     :return: Signed raw transaction data list
     :rtype: param txs, unchanged
     """
-    rpc_format_address = None
-    if address != None:
-        if not is_address(address):
-            raise ValueError('invalid address {}'.format(address))
-        address = tx_normalize.wallet_address(address)
-        address = add_0x(address)
-
-    tx_hashes = []
-    txs = []
-    for tx_hash in tx_hashes_hex:
-        tx_hash = tx_normalize.tx_hash(tx_hash)
-        tx_hashes.append(tx_hash)
-    for tx in txs_hex:
-        tx = tx_normalize.tx_wire(tx)
-        txs.append(tx)
-
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
+    logg.debug('txs {} tx_hashes {}'.format(txs, tx_hashes))
 
     addresspass = None
     if len(txs) == 0:
@@ -214,7 +187,8 @@ def check_gas(self, tx_hashes_hex, chain_spec_dict, txs_hex=[], address=None, ga
                 raise ValueError('txs passed to check gas must all have same sender; had {} got {}'.format(address, tx['from']))
             addresspass.append(address)
 
-    rpc_format_address = add_0x(to_checksum_address(address))
+    if not is_checksum_address(address):
+        raise ValueError('invalid address {}'.format(address))
 
     queue = self.request.delivery_info.get('routing_key')
 
@@ -222,7 +196,7 @@ def check_gas(self, tx_hashes_hex, chain_spec_dict, txs_hex=[], address=None, ga
 
     gas_balance = 0
     try:
-        o = balance(rpc_format_address)
+        o = balance(address)
         r = conn.do(o)
         conn.disconnect()
         gas_balance = abi_decode_single(ABIContractType.UINT256, r)
@@ -330,7 +304,6 @@ def refill_gas(self, recipient_address, chain_spec_dict):
     # Determine value of gas tokens to send
     # if an uncompleted gas refill for the same recipient already exists, we still need to spend the nonce
     # however, we will perform a 0-value transaction instead
-    recipient_address = tx_normalize.wallet_address(recipient_address)
     zero_amount = False
     session = SessionBase.create_session()
     status_filter = StatusBits.FINAL | StatusBits.NODE_ERROR | StatusBits.NETWORK_ERROR | StatusBits.UNKNOWN_ERROR
@@ -405,7 +378,6 @@ def resend_with_higher_gas(self, txold_hash_hex, chain_spec_dict, gas=None, defa
     :returns: Transaction hash
     :rtype: str, 0x-hex
     """
-    txold_hash_hex = tx_normalize.tx_hash(txold_hash_hex)
     session = SessionBase.create_session()
 
     otx = Otx.load(txold_hash_hex, session)

apps/cic-eth/cic_eth/eth/meta.py

@@ -2,9 +2,8 @@
 from chainlib.eth.constant import ZERO_ADDRESS
 from chainlib.status import Status as TxStatus
 from cic_eth_registry.erc20 import ERC20Token
-from hexathon import add_0x
 
-# local impor:ts
+# local imports
 from cic_eth.ext.address import translate_address
 
 
@@ -45,8 +44,8 @@ class ExtendedTx:
             destination = source
         if destination_value == None:
             destination_value = source_value
-        st = ERC20Token(self.chain_spec, self.rpc, add_0x(source))
+        st = ERC20Token(self.chain_spec, self.rpc, source)
-        dt = ERC20Token(self.chain_spec, self.rpc, add_0x(destination))
+        dt = ERC20Token(self.chain_spec, self.rpc, destination)
         self.source_token = source
         self.source_token_symbol = st.symbol
         self.source_token_name = st.name

apps/cic-eth/cic_eth/eth/nonce.py

@@ -3,12 +3,11 @@ import logging
 
 # external imports
 import celery
-from chainlib.eth.address import is_checksum_address, is_address, strip_0x
+from chainlib.eth.address import is_checksum_address
 
 # local imports
 from cic_eth.db.models.role import AccountRole
 from cic_eth.db.models.base import SessionBase
-from cic_eth.encode import tx_normalize
 from cic_eth.task import CriticalSQLAlchemyTask
 from cic_eth.db.models.nonce import (
         Nonce,
@@ -43,8 +42,7 @@ class CustodialTaskNonceOracle():
         :returns: Nonce
         :rtype: number
         """
-        address = tx_normalize.wallet_address(self.address)
+        r = NonceReservation.release(self.address, self.uuid, session=self.session)
-        r = NonceReservation.release(address, self.uuid, session=self.session)
         return r[1]
 
 
@@ -60,18 +58,17 @@ def reserve_nonce(self, chained_input, chain_spec_dict, signer_address=None):
         address = chained_input
         logg.debug('non-explicit address for reserve nonce, using arg head {}'.format(chained_input))
     else:
-        if is_address(signer_address):
+        if is_checksum_address(signer_address):
             address = signer_address
             logg.debug('explicit address for reserve nonce {}'.format(signer_address))
         else:
             address = AccountRole.get_address(signer_address, session=session)
             logg.debug('role for reserve nonce {} -> {}'.format(signer_address, address))
 
-    if not is_address(address):
+    if not is_checksum_address(address):
         raise ValueError('invalid result when resolving address for nonce {}'.format(address))
 
     root_id = self.request.root_id
-    address = tx_normalize.wallet_address(address)
     r = NonceReservation.next(address, root_id, session=session)
     logg.debug('nonce {} reserved for address {} task {}'.format(r[1], address, r[0]))
 

apps/cic-eth/cic_eth/ext/tx.py

@@ -32,7 +32,6 @@ from potaahto.symbols import snake_and_camel
 from cic_eth.queue.time import tx_times
 from cic_eth.task import BaseTask
 from cic_eth.db.models.base import SessionBase
-from cic_eth.encode import tx_normalize
 
 celery_app = celery.current_app
 logg = logging.getLogger()
@@ -135,7 +134,7 @@ def list_tx_by_bloom(self, bloomspec, address, chain_spec_dict):
                     tx_address = transfer_data[0]
                     tx_token_value = transfer_data[1]
                     
-                    if tx_normalize.wallet_address(address) == tx_normalize.wallet_address(tx_address):
+                    if address == tx_address:
                         status = StatusEnum.SENT
                         try:
                             o = receipt(tx['hash'])
@@ -153,8 +152,8 @@ def list_tx_by_bloom(self, bloomspec, address, chain_spec_dict):
                         times = tx_times(tx['hash'], chain_spec)
                         tx_r = {
                             'hash': tx['hash'],
-                            'sender': tx_normalize.wallet_address(tx['from']),
+                            'sender': tx['from'],
-                            'recipient': tx_normalize.wallet_address(tx_address),
+                            'recipient': tx_address,
                             'source_value': tx_token_value,
                             'destination_value': tx_token_value,
                             'source_token': tx['to'],
@@ -165,12 +164,12 @@ def list_tx_by_bloom(self, bloomspec, address, chain_spec_dict):
                             tx_r['date_created'] = times['queue']
                         else:
                             tx_r['date_created'] = times['network']
-                        txs[strip_0x(tx['hash'])] = tx_r
+                        txs[tx['hash']] = tx_r
                         break
-
     return txs
 
 
+
 # TODO: Surely it must be possible to optimize this
 # TODO: DRY this with callback filter in cic_eth/runnable/manager
 # TODO: Remove redundant fields from end representation (timestamp, tx_hash)
@@ -231,8 +230,6 @@ def tx_collate(self, tx_batches, chain_spec_dict, offset, limit, newest_first=Tr
             except UnknownContractError:
                 logg.error('verify failed on tx {}, skipping'.format(tx['hash']))
                 continue
-        tx['recipient'] = tx_normalize.wallet_address(tx['recipient'])
-        tx['sender'] = tx_normalize.wallet_address(tx['sender'])
         txs.append(tx)
 
     return txs

apps/cic-eth/cic_eth/queue/balance.py

@@ -15,7 +15,6 @@ from chainqueue.db.enum import (
 # local imports
 from cic_eth.db import SessionBase
 from cic_eth.task import CriticalSQLAlchemyTask
-from cic_eth.encode import tx_normalize
 
 celery_app = celery.current_app
 
@@ -23,9 +22,6 @@ logg = logging.getLogger()
 
 
 def __balance_outgoing_compatible(token_address, holder_address):
-    token_address = tx_normalize.executable_address(token_address)
-    holder_address = tx_normalize.wallet_address(holder_address)
-
     session = SessionBase.create_session()
     q = session.query(TxCache.from_value)
     q = q.join(Otx)
@@ -62,9 +58,6 @@ def balance_outgoing(tokens, holder_address, chain_spec_dict):
 
 
 def __balance_incoming_compatible(token_address, receiver_address):
-    token_address = tx_normalize.executable_address(token_address)
-    receiver_address = tx_normalize.wallet_address(receiver_address)
-
     session = SessionBase.create_session()
     q = session.query(TxCache.to_value)
     q = q.join(Otx)
@@ -117,7 +110,7 @@ def assemble_balances(balances_collection):
     logg.debug('received collection {}'.format(balances_collection))
     for c in balances_collection:
         for b in c:
-            address = tx_normalize.executable_address(b['address'])
+            address = b['address']
             if tokens.get(address) == None:
                 tokens[address] = {
                     'address': address,

apps/cic-eth/cic_eth/queue/lock.py

@@ -6,7 +6,6 @@ import celery
 from cic_eth.task import CriticalSQLAlchemyTask
 from cic_eth.db import SessionBase
 from cic_eth.db.models.lock import Lock
-from cic_eth.encode import tx_normalize
 
 celery_app = celery.current_app
 
@@ -22,9 +21,6 @@ def get_lock(address=None):
     :returns: List of locks
     :rtype: list of dicts
     """
-    if address != None:
-        address = tx_normalize.wallet_address(address)
-
     session = SessionBase.create_session()
     q = session.query(
             Lock.date_created,

apps/cic-eth/cic_eth/queue/query.py

@@ -4,8 +4,8 @@ import datetime
 # external imports
 import celery
 from chainlib.chain import ChainSpec
-import chainqueue.sql.query
 from chainlib.eth.tx import unpack
+import chainqueue.sql.query
 from chainqueue.db.enum import (
         StatusEnum,
         is_alive,
@@ -20,10 +20,6 @@ from cic_eth.db.enum import LockEnum
 from cic_eth.task import CriticalSQLAlchemyTask
 from cic_eth.db.models.lock import Lock
 from cic_eth.db.models.base import SessionBase
-from cic_eth.encode import (
-        tx_normalize,
-        unpack_normal,
-        )
 
 celery_app = celery.current_app
 
@@ -31,77 +27,49 @@ celery_app = celery.current_app
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def get_tx_cache(chain_spec_dict, tx_hash):
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
-    return get_tx_cache_local(chain_spec, tx_hash)
+    session = SessionBase.create_session()
-
-
-def get_tx_cache_local(chain_spec, tx_hash, session=None):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
-    session = SessionBase.bind_session(session)
     r = chainqueue.sql.query.get_tx_cache(chain_spec, tx_hash, session=session)
-    SessionBase.release_session(session)
+    session.close()
     return r
 
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def get_tx(chain_spec_dict, tx_hash):
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
-    return get_tx_local(chain_spec, tx_hash)
+    session = SessionBase.create_session()
-
-
-def get_tx_local(chain_spec, tx_hash, session=None):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
-    session = SessionBase.bind_session(session)
     r =  chainqueue.sql.query.get_tx(chain_spec, tx_hash, session=session)
-    SessionBase.release_session(session)
+    session.close()
     return r
 
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def get_account_tx(chain_spec_dict, address, as_sender=True, as_recipient=True, counterpart=None):
-    address = tx_normalize.wallet_address(address)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
-    return get_account_tx_local(chain_spec, address, as_sender=as_sender, as_recipient=as_recipient, counterpart=counterpart)
+    session = SessionBase.create_session()
-
-
-def get_account_tx_local(chain_spec, address, as_sender=True, as_recipient=True, counterpart=None, session=None):
-    address = tx_normalize.wallet_address(address)
-    session = SessionBase.bind_session(session)
     r = chainqueue.sql.query.get_account_tx(chain_spec, address, as_sender=True, as_recipient=True, counterpart=None, session=session)
-    SessionBase.release_session(session)
+    session.close()
     return r
 
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
-def get_upcoming_tx_nolock(chain_spec_dict, status=StatusEnum.READYSEND, not_status=None, recipient=None, before=None, limit=0):
+def get_upcoming_tx_nolock(chain_spec_dict, status=StatusEnum.READYSEND, not_status=None, recipient=None, before=None, limit=0, session=None):
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
-    return get_upcoming_tx_nolock_local(chain_spec, status=status, not_status=not_status, recipient=recipient, before=before, limit=limit)
-
-
-def get_upcoming_tx_nolock_local(chain_spec, status=StatusEnum.READYSEND, not_status=None, recipient=None, before=None, limit=0, session=None):
-    recipient = tx_normalize.wallet_address(recipient)
     session = SessionBase.create_session()
-    r = chainqueue.sql.query.get_upcoming_tx(chain_spec, status, not_status=not_status, recipient=recipient, before=before, limit=limit, session=session, decoder=unpack_normal)
+    r = chainqueue.sql.query.get_upcoming_tx(chain_spec, status, not_status=not_status, recipient=recipient, before=before, limit=limit, session=session, decoder=unpack)
     session.close()
     return r
 
 
 def get_status_tx(chain_spec, status, not_status=None, before=None, exact=False, limit=0, session=None):
-    return chainqueue.sql.query.get_status_tx_cache(chain_spec, status, not_status=not_status, before=before, exact=exact, limit=limit, session=session, decoder=unpack_normal)
+    return chainqueue.sql.query.get_status_tx_cache(chain_spec, status, not_status=not_status, before=before, exact=exact, limit=limit, session=session, decoder=unpack)
 
 
 def get_paused_tx(chain_spec, status=None, sender=None, session=None, decoder=None):
-    sender = tx_normalize.wallet_address(sender)
+    return chainqueue.sql.query.get_paused_tx_cache(chain_spec, status=status, sender=sender, session=session, decoder=unpack)
-    return chainqueue.sql.query.get_paused_tx_cache(chain_spec, status=status, sender=sender, session=session, decoder=unpack_normal)
 
 
 def get_nonce_tx(chain_spec, nonce, sender):
-    sender = tx_normalize.wallet_address(sender)
+    return get_nonce_tx_cache(chain_spec, nonce, sender, decoder=unpack)
-    return get_nonce_tx_local(chain_spec, nonce, sender)
-
-
-def get_nonce_tx_local(chain_spec, nonce, sender, session=None):
-    sender = tx_normalize.wallet_address(sender)
-    return chainqueue.sql.query.get_nonce_tx_cache(chain_spec, nonce, sender, decoder=unpack_normal, session=session)
 
 
 def get_upcoming_tx(chain_spec, status=StatusEnum.READYSEND, not_status=None, recipient=None, before=None, limit=0, session=None):
@@ -123,8 +91,6 @@ def get_upcoming_tx(chain_spec, status=StatusEnum.READYSEND, not_status=None, re
     :returns: Transactions
     :rtype: dict, with transaction hash as key, signed raw transaction as value
     """
-    if recipient != None:
-        recipient = tx_normalize.wallet_address(recipient)
     session = SessionBase.bind_session(session)
     q_outer = session.query(
             TxCache.sender,

apps/cic-eth/cic_eth/queue/state.py

@@ -6,14 +6,12 @@ import chainqueue.sql.state
 import celery
 from cic_eth.task import CriticalSQLAlchemyTask
 from cic_eth.db.models.base import SessionBase
-from cic_eth.encode import tx_normalize
 
 celery_app = celery.current_app
 
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def set_sent(chain_spec_dict, tx_hash, fail=False):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.set_sent(chain_spec, tx_hash, fail, session=session)
@@ -23,7 +21,6 @@ def set_sent(chain_spec_dict, tx_hash, fail=False):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def set_final(chain_spec_dict, tx_hash, block=None, tx_index=None, fail=False):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.set_final(chain_spec, tx_hash, block=block, tx_index=tx_index, fail=fail, session=session)
@@ -33,7 +30,6 @@ def set_final(chain_spec_dict, tx_hash, block=None, tx_index=None, fail=False):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def set_cancel(chain_spec_dict, tx_hash, manual=False):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.set_cancel(chain_spec, tx_hash, manual, session=session)
@@ -43,7 +39,6 @@ def set_cancel(chain_spec_dict, tx_hash, manual=False):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def set_rejected(chain_spec_dict, tx_hash):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.set_rejected(chain_spec, tx_hash, session=session)
@@ -53,7 +48,6 @@ def set_rejected(chain_spec_dict, tx_hash):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def set_fubar(chain_spec_dict, tx_hash):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.set_fubar(chain_spec, tx_hash, session=session)
@@ -63,7 +57,6 @@ def set_fubar(chain_spec_dict, tx_hash):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def set_manual(chain_spec_dict, tx_hash):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.set_manual(chain_spec, tx_hash, session=session)
@@ -73,7 +66,6 @@ def set_manual(chain_spec_dict, tx_hash):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def set_ready(chain_spec_dict, tx_hash):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.set_ready(chain_spec, tx_hash, session=session)
@@ -83,7 +75,6 @@ def set_ready(chain_spec_dict, tx_hash):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def set_reserved(chain_spec_dict, tx_hash):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.set_reserved(chain_spec, tx_hash, session=session)
@@ -93,7 +84,6 @@ def set_reserved(chain_spec_dict, tx_hash):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def set_waitforgas(chain_spec_dict, tx_hash):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.set_waitforgas(chain_spec, tx_hash, session=session)
@@ -103,7 +93,6 @@ def set_waitforgas(chain_spec_dict, tx_hash):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def get_state_log(chain_spec_dict, tx_hash):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.get_state_log(chain_spec, tx_hash, session=session)
@@ -113,7 +102,6 @@ def get_state_log(chain_spec_dict, tx_hash):
 
 @celery_app.task(base=CriticalSQLAlchemyTask)
 def obsolete(chain_spec_dict, tx_hash, final):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
     chain_spec = ChainSpec.from_dict(chain_spec_dict)
     session = SessionBase.create_session()
     r = chainqueue.sql.state.obsolete_by_cache(chain_spec, tx_hash, final, session=session)

apps/cic-eth/cic_eth/queue/time.py

@@ -13,7 +13,6 @@ from chainqueue.error import NotLocalTxError
 # local imports
 from cic_eth.task import CriticalSQLAlchemyAndWeb3Task
 from cic_eth.db.models.base import SessionBase
-from cic_eth.encode import tx_normalize
 
 celery_app = celery.current_app
 
@@ -21,7 +20,6 @@ logg = logging.getLogger()
 
 
 def tx_times(tx_hash, chain_spec, session=None):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
 
     session = SessionBase.bind_session(session)
 

apps/cic-eth/cic_eth/queue/tx.py

@@ -32,16 +32,12 @@ from cic_eth.db import SessionBase
 from cic_eth.db.enum import LockEnum
 from cic_eth.task import CriticalSQLAlchemyTask
 from cic_eth.error import LockedError
-from cic_eth.encode import tx_normalize
 
 celery_app = celery.current_app
 logg = logging.getLogger()
 
 
 def queue_create(chain_spec, nonce, holder_address, tx_hash, signed_tx, session=None):
-    tx_hash = tx_normalize.tx_hash(tx_hash)
-    signed_tx = tx_normalize.tx_hash(signed_tx)
-    holder_address = tx_normalize.wallet_address(holder_address)
     session = SessionBase.bind_session(session)
 
     lock = Lock.check_aggregate(str(chain_spec), LockEnum.QUEUE, holder_address, session=session) 
@@ -71,8 +67,6 @@ def register_tx(tx_hash_hex, tx_signed_raw_hex, chain_spec, queue, cache_task=No
     :returns: Tuple; Transaction hash, signed raw transaction data
     :rtype: tuple
     """
-    tx_hash_hex = tx_normalize.tx_hash(tx_hash_hex)
-    tx_signed_raw_hex = tx_normalize.tx_hash(tx_signed_raw_hex)
     logg.debug('adding queue tx {}:{} -> {}'.format(chain_spec, tx_hash_hex, tx_signed_raw_hex))
     tx_signed_raw = bytes.fromhex(strip_0x(tx_signed_raw_hex))
     tx = unpack(tx_signed_raw, chain_spec)

apps/cic-eth/cic_eth/runnable/daemons/dispatcher.py

@@ -101,14 +101,14 @@ class DispatchSyncer:
                     LockEnum.QUEUE,
                     tx['from'],
                     ],
-                queue=config.get('CELERY_QUEUE'),
+                queue=queue,
                 )
             s_send = celery.signature(
                     'cic_eth.eth.tx.send',
                     [
                         self.chain_spec.asdict(),
                         ], 
-                    queue=config.get('CELERY_QUEUE'),
+                    queue=queue,
                     )
             s_check.link(s_send)
             t = s_check.apply_async()

apps/cic-eth/cic_eth/runnable/daemons/filters/callback.py

@@ -21,7 +21,6 @@ from erc20_faucet import Faucet
 # local imports
 from .base import SyncFilter
 from cic_eth.eth.meta import ExtendedTx
-from cic_eth.encode import tx_normalize
 
 logg = logging.getLogger().getChild(__name__)
 
@@ -43,9 +42,9 @@ class CallbackFilter(SyncFilter):
             return (None, None)
         r = ERC20.parse_transfer_request(tx.payload)
         transfer_data = {}
-        transfer_data['to'] = tx_normalize.wallet_address(r[0])
+        transfer_data['to'] = r[0]
         transfer_data['value'] = r[1]
-        transfer_data['from'] = tx_normalize.wallet_address(tx.outputs[0])
+        transfer_data['from'] = tx.outputs[0]
         transfer_data['token_address'] = tx.inputs[0]
         return ('transfer', transfer_data)
 
@@ -55,8 +54,8 @@ class CallbackFilter(SyncFilter):
             return (None, None)
         r = ERC20.parse_transfer_from_request(tx.payload)
         transfer_data = {}
-        transfer_data['from'] = tx_normalize.wallet_address(r[0])
+        transfer_data['from'] = r[0]
-        transfer_data['to'] = tx_normalize.wallet_address(r[1])
+        transfer_data['to'] = r[1]
         transfer_data['value'] = r[2]
         transfer_data['token_address'] = tx.inputs[0]
         return ('transferfrom', transfer_data)
@@ -67,9 +66,9 @@ class CallbackFilter(SyncFilter):
             return (None, None)
         r = Faucet.parse_give_to_request(tx.payload)
         transfer_data = {}
-        transfer_data['to'] = tx_normalize.wallet_address(r[0])
+        transfer_data['to'] = r[0]
         transfer_data['value'] = tx.value
-        transfer_data['from'] = tx_normalize.wallet_address(tx.outputs[0])
+        transfer_data['from'] = tx.outputs[0]
         #transfer_data['token_address'] = tx.inputs[0]
         faucet_contract = tx.inputs[0]
 

apps/cic-eth/cic_eth/runnable/daemons/filters/gas.py

@@ -10,14 +10,15 @@ from chainlib.eth.tx import unpack
 from chainqueue.db.enum import StatusBits
 from chainqueue.db.models.tx import TxCache
 from chainqueue.db.models.otx import Otx
+from chainqueue.sql.query import get_paused_tx_cache as get_paused_tx
 from chainlib.eth.address import to_checksum_address
 
 # local imports
 from cic_eth.db.models.base import SessionBase
 from cic_eth.eth.gas import create_check_gas_task
-from cic_eth.queue.query import get_paused_tx
 from .base import SyncFilter
 
+#logg = logging.getLogger().getChild(__name__)
 logg = logging.getLogger()
 
 

apps/cic-eth/cic_eth/runnable/daemons/filters/register.py

@@ -12,8 +12,7 @@ from hexathon import (
 # local imports
 from .base import SyncFilter
 
-#logg = logging.getLogger(__name__)
+logg = logging.getLogger(__name__)
-logg = logging.getLogger()
 
 account_registry_add_log_hash = '0x9cc987676e7d63379f176ea50df0ae8d2d9d1141d1231d4ce15b5965f73c9430'
 

apps/cic-eth/cic_eth/runnable/daemons/filters/transferauth.py

@@ -17,7 +17,6 @@ from cic_eth_registry import CICRegistry
 from erc20_transfer_authorization import TransferAuthorization
 
 # local imports
-from cic_eth.encode import tx_normalize
 from .base import SyncFilter
 
 
@@ -53,9 +52,9 @@ class TransferAuthFilter(SyncFilter):
 
         r = TransferAuthorization.parse_create_request_request(tx.payload) 
           
-        sender = tx_normalize.wallet_address(r[0])
+        sender = r[0]
-        recipient = tx_normalize.wallet_address(r[1])
+        recipient = r[1]
-        token = tx_normalize.executable_address(r[2])
+        token = r[2]
         value = r[3]
 
         token_data = {

apps/cic-eth/cic_eth/runnable/daemons/tasker.py

@@ -69,6 +69,7 @@ from cic_eth.registry import (
         )
 from cic_eth.task import BaseTask
 
+
 logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
 
@@ -206,7 +207,7 @@ def main():
 
     BaseTask.default_token_symbol = config.get('CIC_DEFAULT_TOKEN_SYMBOL')
     BaseTask.default_token_address = registry.by_name(BaseTask.default_token_symbol)
-    default_token = ERC20Token(chain_spec, conn, add_0x(BaseTask.default_token_address))
+    default_token = ERC20Token(chain_spec, conn, BaseTask.default_token_address)
     default_token.load(conn)
     BaseTask.default_token_decimals = default_token.decimals
     BaseTask.default_token_name = default_token.name

apps/cic-eth/cic_eth/runnable/tag.py

@@ -18,7 +18,7 @@ from cic_eth.db.models.base import SessionBase
 logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
 
-arg_flags = cic_eth.cli.argflag_std_base | cic_eth.cli.Flag.UNSAFE | cic_eth.cli.Flag.CHAIN_SPEC
+arg_flags = cic_eth.cli.argflag_std_base
 local_arg_flags = cic_eth.cli.argflag_local_taskcallback
 argparser = cic_eth.cli.ArgumentParser(arg_flags)
 argparser.add_positional('tag', type=str, help='address tag')

apps/cic-eth/cic_eth/task.py

@@ -13,6 +13,7 @@ from chainlib.eth.nonce import RPCNonceOracle
 from chainlib.eth.gas import RPCGasOracle
 from cic_eth_registry import CICRegistry
 from cic_eth_registry.error import UnknownContractError
+import liveness.linux
 
 # local imports
 from cic_eth.error import SeppukuError
@@ -47,7 +48,6 @@ class BaseTask(celery.Task):
 
     def on_failure(self, exc, task_id, args, kwargs, einfo):
         if isinstance(exc, SeppukuError):
-            import liveness.linux
             liveness.linux.reset(rundir=self.run_dir)
             logg.critical(einfo)
             msg = 'received critical exception {}, calling shutdown'.format(str(exc))

apps/cic-eth/cic_eth/version.py

@@ -9,8 +9,8 @@ import semver
 version = (
         0,
         12,
-        4,
+        2,
-        'alpha.8',
+        'alpha.4',
         )
 
 version_object = semver.VersionInfo(

apps/cic-eth/doc/texinfo/configuration.texi

@@ -1,6 +1,8 @@
 @node cic-eth configuration
 @section Configuration
 
+(refer to @code{cic-base} for a general overview of the config pipeline)
+
 Configuration parameters are grouped by configuration filename.
 
 
@@ -38,26 +40,7 @@ Boolean value. If set, the amount of available context for a task in the result
 
 @subsection database
 
-@table @var
+See ref cic-base when ready
-@item host
-Database host
-@item port
-Database port
-@item name
-Database name
-@item user
-Database user
-@item password
-Database password
-@item engine
-The engine part of the dsn connection string (@code{postgresql} in @code{postgresql+psycopg2})
-@item driver
-The driver part of the dsn connection string (@code{psycopg2} in @code{postgresql+psycopg2})
-@item pool_size
-Connection pool size for database drivers that provide connection pooling
-@item debug
-Output actual sql queries to logs. Potentially very verbose
-@end table
 
 
 @subsection eth

apps/cic-eth/docker/Dockerfile

@@ -8,44 +8,30 @@ FROM registry.gitlab.com/grassrootseconomics/cic-base-images:python-3.8.6-dev-55
 
 ARG EXTRA_INDEX_URL="https://pip.grassrootseconomics.net:8433"
 ARG GITLAB_PYTHON_REGISTRY="https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple"
-ARG EXTRA_PIP_ARGS=""
 #RUN --mount=type=cache,mode=0755,target=/root/.cache/pip \
 #    pip install --index-url https://pypi.org/simple \
 #    --force-reinstall \
 #	--extra-index-url $GITLAB_PYTHON_REGISTRY --extra-index-url $EXTRA_INDEX_URL \
-#    -r requirements.txt
+#    -r requirements.txt 
-
-RUN --mount=type=cache,mode=0755,target=/root/.cache/pip \
-    pip install --index-url https://pypi.org/simple  \
-	  --extra-index-url $GITLAB_PYTHON_REGISTRY \
-    --extra-index-url $EXTRA_INDEX_URL \
-    $EXTRA_PIP_ARGS \
-    cic-eth-aux-erc20-demurrage-token~=0.0.2a6
-
-
 COPY *requirements.txt ./
 RUN --mount=type=cache,mode=0755,target=/root/.cache/pip \
     pip install --index-url https://pypi.org/simple  \
 	  --extra-index-url $GITLAB_PYTHON_REGISTRY \
     --extra-index-url $EXTRA_INDEX_URL \
-    $EXTRA_PIP_ARGS \
     -r requirements.txt \
     -r services_requirements.txt \
-    -r admin_requirements.txt 
+    -r admin_requirements.txt
-   
+    
-# always install the latest signer 
-RUN --mount=type=cache,mode=0755,target=/root/.cache/pip \
-    pip install --index-url https://pypi.org/simple  \
-	  --extra-index-url $GITLAB_PYTHON_REGISTRY \
-    --extra-index-url $EXTRA_INDEX_URL \
-    $EXTRA_PIP_ARGS \
-    crypto-dev-signer
-
 COPY . .
 RUN python setup.py install
 
 ENV PYTHONPATH .
 
+RUN --mount=type=cache,mode=0755,target=/root/.cache/pip \
+    pip install --index-url https://pypi.org/simple  \
+	  --extra-index-url $GITLAB_PYTHON_REGISTRY \
+    --extra-index-url $EXTRA_INDEX_URL \
+    cic-eth-aux-erc20-demurrage-token~=0.0.2a6
 
 COPY docker/entrypoints/* ./ 
 RUN chmod 755 *.sh

apps/cic-eth/docker/Dockerfile_ci

@@ -0,0 +1,69 @@
+FROM registry.gitlab.com/grassrootseconomics/cic-base-images:python-3.8.6-dev-55da5f4e as dev
+
+WORKDIR /usr/src/cic-eth
+
+# Copy just the requirements and install....this _might_ give docker a hint on caching but we 
+# do load these all into setup.py later
+# TODO can we take all the requirements out of setup.py and just do a pip install -r requirements.txt && python setup.py
+#COPY cic-eth/requirements.txt .
+
+ARG EXTRA_INDEX_URL="https://pip.grassrootseconomics.net:8433"
+ARG GITLAB_PYTHON_REGISTRY="https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple"
+#RUN --mount=type=cache,mode=0755,target=/root/.cache/pip \
+#    pip install --index-url https://pypi.org/simple \
+#    --force-reinstall \
+#	--extra-index-url $GITLAB_PYTHON_REGISTRY --extra-index-url $EXTRA_INDEX_URL \
+#    -r requirements.txt 
+COPY *requirements.txt . 
+RUN pip install --index-url https://pypi.org/simple  \
+	  --extra-index-url $GITLAB_PYTHON_REGISTRY \
+    --extra-index-url $EXTRA_INDEX_URL \
+    -r requirements.txt \
+    -r services_requirements.txt \
+    -r admin_requirements.txt
+    
+COPY . .
+RUN python setup.py install
+
+COPY docker/entrypoints/* ./ 
+RUN chmod 755 *.sh
+
+# # ini files in config directory defines the configurable parameters for the application
+# # they can all be overridden by environment variables
+# # to generate a list of environment variables from configuration, use: confini-dump -z <dir> (executable provided by confini package)
+COPY config/ /usr/local/etc/cic-eth/
+COPY cic_eth/db/migrations/ /usr/local/share/cic-eth/alembic/
+COPY crypto_dev_signer_config/ /usr/local/etc/crypto-dev-signer/
+
+# TODO this kind of code sharing across projects should be discouraged...can we make util a library?
+#COPY util/liveness/health.sh /usr/local/bin/health.sh
+ENTRYPOINT []
+
+# ------------------ PRODUCTION CONTAINER ----------------------
+#FROM python:3.8.6-slim-buster as prod 
+#
+#RUN apt-get update && \
+#	apt install -y gnupg libpq-dev procps
+#
+#WORKDIR /root
+#
+#COPY --from=dev /usr/local/bin/ /usr/local/bin/
+#COPY --from=dev /usr/local/lib/python3.8/site-packages/ \
+#                          /usr/local/lib/python3.8/site-packages/
+#
+#COPY docker/entrypoints/* ./ 
+#RUN chmod 755 *.sh
+#
+## # ini files in config directory defines the configurable parameters for the application
+## # they can all be overridden by environment variables
+## # to generate a list of environment variables from configuration, use: confini-dump -z <dir> (executable provided by confini package)
+#COPY config/ /usr/local/etc/cic-eth/
+#COPY cic_eth/db/migrations/ /usr/local/share/cic-eth/alembic/
+#COPY crypto_dev_signer_config/ /usr/local/etc/crypto-dev-signer/
+#COPY scripts/ scripts/ 
+#
+## TODO this kind of code sharing across projects should be discouraged...can we make util a library?
+##COPY util/liveness/health.sh /usr/local/bin/health.sh
+#
+#ENTRYPOINT []
+#

apps/cic-eth/docker/entrypoints/start_tasker.sh

@@ -5,27 +5,27 @@ set -e
 
 # set CONFINI_ENV_PREFIX to override the env prefix to override env vars
 
-#echo "!!! starting signer"
+echo "!!! starting signer"
-#python /usr/local/bin/crypto-dev-daemon -c /usr/local/etc/crypto-dev-signer -vv 2> /tmp/signer.log &
+python /usr/local/bin/crypto-dev-daemon -c /usr/local/etc/crypto-dev-signer -vv 2> /tmp/signer.log &
 
 echo "!!! starting taskerd"
 /usr/local/bin/cic-eth-taskerd $@
 
 # thanks! https://docs.docker.com/config/containers/multi-service_container/
-#sleep 1;
+sleep 1;
-#echo "!!! entering monitor loop"
+echo "!!! entering monitor loop"
-#while true; do
+while true; do
-#  ps aux | grep crypto-dev-daemon | grep -q -v grep
+  ps aux | grep crypto-dev-daemon | grep -q -v grep
-#  PROCESS_1_STATUS=$?
+  PROCESS_1_STATUS=$?
-#  ps aux | grep cic-eth-tasker |grep -q -v grep
+  ps aux | grep cic-eth-tasker |grep -q -v grep
-#  PROCESS_2_STATUS=$?
+  PROCESS_2_STATUS=$?
-#  # If the greps above find anything, they exit with 0 status
+  # If the greps above find anything, they exit with 0 status
-#  # If they are not both 0, then something is wrong
+  # If they are not both 0, then something is wrong
-#  if [ $PROCESS_1_STATUS -ne 0 -o $PROCESS_2_STATUS -ne 0 ]; then
+  if [ $PROCESS_1_STATUS -ne 0 -o $PROCESS_2_STATUS -ne 0 ]; then
-#    echo "One of the processes has already exited."
+    echo "One of the processes has already exited."
-#    exit 1
+    exit 1
-#  fi
+  fi
-#  sleep 15;
+  sleep 15;
-#done
+done
-#
+
 set +e

apps/cic-eth/docker/run_tests.sh

@@ -1,11 +0,0 @@
-#! /bin/bash
-
-set -e
-
-pip install --extra-index-url https://pip.grassrootseconomics.net:8433 --extra-index-url https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple \
--r admin_requirements.txt \
--r services_requirements.txt \
--r test_requirements.txt  
-
-export PYTHONPATH=. && pytest -x --cov=cic_eth --cov-fail-under=90 --cov-report term-missing tests
-

apps/cic-eth/requirements.txt

@@ -1,4 +1,3 @@
 celery==4.4.7
-chainlib-eth>=0.0.9rc2,<0.1.0
+chainlib-eth>=0.0.7a5,<0.1.0
 semver==2.13.0
-crypto-dev-signer>=0.4.15rc2,<0.5.0

apps/cic-eth/scripts/migrate.py

@@ -10,7 +10,6 @@ from alembic.config import Config as AlembicConfig
 import confini
 
 from cic_eth.db import dsn_from_config
-import cic_eth.cli
 
 logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
@@ -20,20 +19,25 @@ rootdir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
 dbdir = os.path.join(rootdir, 'cic_eth', 'db')
 migrationsdir = os.path.join(dbdir, 'migrations')
 
-arg_flags = cic_eth.cli.argflag_std_base
+config_dir = os.path.join('/usr/local/etc/cic-eth')
 
-argparser = cic_eth.cli.ArgumentParser(arg_flags)
+argparser = argparse.ArgumentParser()
+argparser.add_argument('-c', type=str, default=config_dir, help='config file')
+argparser.add_argument('--env-prefix', default=os.environ.get('CONFINI_ENV_PREFIX'), dest='env_prefix', type=str, help='environment prefix for variables to overwrite configuration')
 argparser.add_argument('--migrations-dir', dest='migrations_dir', default=migrationsdir, type=str, help='path to alembic migrations directory')
 argparser.add_argument('--reset', action='store_true', help='downgrade before upgrading')
 argparser.add_argument('-f', action='store_true', help='force action')
+argparser.add_argument('-v', action='store_true', help='be verbose')
+argparser.add_argument('-vv', action='store_true', help='be more verbose')
 args = argparser.parse_args()
 
-extra_args = {
+if args.vv:
-    'migrations_dir': None,
+    logging.getLogger().setLevel(logging.DEBUG)
-    'reset': None,
+elif args.v:
-    'f': '_FORCE_ACTION',
+    logging.getLogger().setLevel(logging.INFO)
-        }
+
-config = cic_eth.cli.Config.from_args(args, arg_flags, 0, extra_args=extra_args)
+config = confini.Config(args.c, args.env_prefix)
+config.process()
 config.censor('PASSWORD', 'DATABASE')
 config.censor('PASSWORD', 'SSL')
 logg.debug('config:\n{}'.format(config))

apps/cic-eth/services_requirements.txt

@@ -1,15 +1,15 @@
-chainqueue>=0.0.5a1,<0.1.0
+chainqueue>=0.0.3a2,<0.1.0
-chainsyncer[sql]>=0.0.6a3,<0.1.0
+chainsyncer[sql]>=0.0.6a1,<0.1.0
 alembic==1.4.2
 confini>=0.3.6rc4,<0.5.0
 redis==3.5.3
-hexathon~=0.0.1a8
+hexathon~=0.0.1a7
 pycryptodome==3.10.1
 liveness~=0.0.1a7
-eth-address-index>=0.2.3a4,<0.3.0
+eth-address-index>=0.1.4a1,<0.2.0
-eth-accounts-index>=0.1.2a3,<0.2.0
+eth-accounts-index>=0.0.14a1,<0.1.0
-cic-eth-registry>=0.6.1a3,<0.7.0
+cic-eth-registry>=0.5.8a1,<0.6.0
-erc20-faucet>=0.3.2a2,<0.4.0
+erc20-faucet>=0.2.4a2,<0.3.0
-erc20-transfer-authorization>=0.3.5a2,<0.4.0
+erc20-transfer-authorization>=0.3.4a1,<0.4.0
-sarafu-faucet>=0.0.7a2,<0.1.0
+sarafu-faucet>=0.0.5a2,<0.1.0
 moolb~=0.1.1b2

apps/cic-eth/test_requirements.txt

@@ -6,4 +6,4 @@ pytest-redis==2.0.0
 redis==3.5.3
 eth-tester==0.5.0b3
 py-evm==0.3.0a20
-eth-erc20~=0.1.2a2
+eth-erc20~=0.0.12a1

apps/cic-eth/tests/filters/test_callback_filter.py

@@ -18,10 +18,7 @@ from eth_erc20 import ERC20
 from sarafu_faucet import MinterFaucet
 from eth_accounts_index.registry import AccountRegistry
 from potaahto.symbols import snake_and_camel
-from hexathon import (
+from hexathon import add_0x
-        add_0x,
-        strip_0x,
-        )
 
 # local imports
 from cic_eth.runnable.daemons.filters.callback import CallbackFilter
@@ -163,7 +160,7 @@ def test_faucet_gift_to_tx(
     assert transfer_data['token_address'] == foo_token
 
 
-def test_callback_filter_filter(
+def test_callback_filter(
         default_chain_spec,
         init_database,
         eth_rpc,
@@ -203,7 +200,6 @@ def test_callback_filter_filter(
     assert r['status'] == 1
 
     rcpt = snake_and_camel(r)
-    tx.block.hash = rcpt['block_hash']
     tx.apply_receipt(rcpt)
 
     fltr = CallbackFilter(default_chain_spec, None, None, caller_address=contract_roles['CONTRACT_DEPLOYER'])
@@ -216,7 +212,6 @@ def test_callback_filter_filter(
 
         def call_back(self, transfer_type, result):
             self.results[transfer_type] = result
-            logg.debug('result {}'.format(result))
             return self
 
     mock = CallbackMock()
@@ -225,4 +220,4 @@ def test_callback_filter_filter(
     fltr.filter(eth_rpc, mockblock, tx, init_database)
 
     assert mock.results.get('transfer') != None
-    assert mock.results['transfer']['destination_token'] == strip_0x(foo_token)
+    assert mock.results['transfer']['destination_token'] == foo_token

apps/cic-eth/tests/filters/test_gas_filter.py

@@ -1,6 +1,7 @@
 # external imports
 from chainlib.connection import RPCConnection
 from chainlib.eth.nonce import OverrideNonceOracle
+from chainqueue.sql.tx import create as queue_create
 from chainlib.eth.tx import (
         TxFormat,
         unpack,
@@ -25,8 +26,6 @@ from chainqueue.db.enum import StatusBits
 # local imports
 from cic_eth.runnable.daemons.filters.gas import GasFilter
 from cic_eth.eth.gas import cache_gas_data
-from cic_eth.encode import tx_normalize
-from cic_eth.queue.tx import queue_create
 
 
 def test_filter_gas(

apps/cic-eth/tests/filters/test_register_filter.py

@@ -17,18 +17,15 @@ from chainlib.eth.block import (
         block_by_number,
         Block,
         )
-from chainlib.eth.address import (
-        to_checksum_address,
-        )
 from erc20_faucet import Faucet
 from hexathon import (
         strip_0x,
         add_0x,
         )
+from chainqueue.sql.query import get_account_tx
 
 # local imports
 from cic_eth.runnable.daemons.filters.register import RegistrationFilter
-from cic_eth.queue.query import get_account_tx_local
 
 logg = logging.getLogger()
 
@@ -72,18 +69,17 @@ def test_register_filter(
     tx = Tx(tx_src, block=block, rcpt=rcpt)
     tx.apply_receipt(rcpt)
 
-    fltr = RegistrationFilter(default_chain_spec, to_checksum_address(os.urandom(20).hex()), queue=None)
+    fltr = RegistrationFilter(default_chain_spec, add_0x(os.urandom(20).hex()), queue=None)
     t = fltr.filter(eth_rpc, block, tx, db_session=init_database)
     assert t == None
 
-    fltr = RegistrationFilter(default_chain_spec, to_checksum_address(account_registry), queue=None)
+    fltr = RegistrationFilter(default_chain_spec, account_registry, queue=None)
     t = fltr.filter(eth_rpc, block, tx, db_session=init_database)
-    logg.debug('t {}'.format(t))
 
     t.get_leaf()
     assert t.successful()
 
-    gift_txs = get_account_tx_local(default_chain_spec, agent_roles['ALICE'], as_sender=True, session=init_database)
+    gift_txs = get_account_tx(default_chain_spec.asdict(), agent_roles['ALICE'], as_sender=True, session=init_database)
     ks = list(gift_txs.keys())
     assert len(ks) == 1
 
@@ -92,4 +88,4 @@ def test_register_filter(
     gift_tx = unpack(tx_raw_signed_bytes, default_chain_spec)
 
     gift = Faucet.parse_give_to_request(gift_tx['data'])
-    assert add_0x(gift[0]) == agent_roles['ALICE']
+    assert gift[0] == agent_roles['ALICE']

apps/cic-eth/tests/filters/test_transferauth_filter.py

@@ -19,7 +19,6 @@ from chainqueue.sql.query import get_account_tx
 
 # local imports
 from cic_eth.runnable.daemons.filters.transferauth import TransferAuthFilter
-from cic_eth.encode import tx_normalize
 
 
 def test_filter_transferauth(
@@ -67,8 +66,7 @@ def test_filter_transferauth(
     t.get_leaf()
     assert t.successful()
 
-    #approve_txs = get_account_tx(default_chain_spec.asdict(), agent_roles['ALICE'], as_sender=True, session=init_database)
+    approve_txs = get_account_tx(default_chain_spec.asdict(), agent_roles['ALICE'], as_sender=True, session=init_database)
-    approve_txs = get_account_tx(default_chain_spec.asdict(), tx_normalize.wallet_address(agent_roles['ALICE']), as_sender=True, session=init_database)
     ks = list(approve_txs.keys())
     assert len(ks) == 1
 
@@ -78,4 +76,4 @@ def test_filter_transferauth(
 
     c = ERC20(default_chain_spec)
     approve = c.parse_approve_request(approve_tx['data']) 
-    assert approve[0] == strip_0x(agent_roles['BOB'])
+    assert approve[0] == agent_roles['BOB']

apps/cic-eth/tests/run_tests.sh

@@ -1,10 +0,0 @@
-#! /bin/bash
-
-set -e
-
-pip install --extra-index-url https://pip.grassrootseconomics.net:8433 --extra-index-url https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple
--r admin_requirements.txt
--r services_requirements.txt
--r test_requirements.txt 
-
-export PYTHONPATH=. && pytest -x --cov=cic_eth --cov-fail-under=90 --cov-report term-missing tests

apps/cic-eth/tests/task/api/test_admin.py

@@ -34,6 +34,10 @@ from chainqueue.sql.state import (
         set_ready,
         set_reserved,
         )
+from chainqueue.sql.query import (
+        get_tx,
+        get_nonce_tx_cache,
+        )
 
 # local imports
 from cic_eth.api.admin import AdminApi
@@ -42,11 +46,6 @@ from cic_eth.db.enum import LockEnum
 from cic_eth.error import InitializationError
 from cic_eth.eth.gas import cache_gas_data
 from cic_eth.queue.tx import queue_create
-from cic_eth.queue.query import (
-        get_tx,
-        get_nonce_tx_local,
-        )
-from cic_eth.encode import tx_normalize
 
 logg = logging.getLogger()
 
@@ -110,8 +109,8 @@ def test_tag_account(
     t = api.tag_account('bar', agent_roles['CAROL'], default_chain_spec)
     t.get()
 
-    assert AccountRole.get_address('foo', init_database) == tx_normalize.wallet_address(agent_roles['ALICE'])
+    assert AccountRole.get_address('foo', init_database) == agent_roles['ALICE']
-    assert AccountRole.get_address('bar', init_database) == tx_normalize.wallet_address(agent_roles['CAROL'])
+    assert AccountRole.get_address('bar', init_database) == agent_roles['CAROL']
 
 
 def test_tx(
@@ -287,15 +286,13 @@ def test_fix_nonce(
     assert t.successful()
 
     init_database.commit()
-   
+    
-    logg.debug('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
+    txs = get_nonce_tx_cache(default_chain_spec, 3, agent_roles['ALICE'], session=init_database)
-    txs = get_nonce_tx_local(default_chain_spec, 3, agent_roles['ALICE'], session=init_database)
     ks = txs.keys()
     assert len(ks) == 2
 
     for k in ks:
-        #hsh = add_0x(k)
+        hsh = add_0x(k)
-        hsh = tx_normalize.tx_hash(k)
         otx = Otx.load(hsh, session=init_database)
         init_database.refresh(otx)
         logg.debug('checking nonce {} tx {} status {}'.format(3, otx.tx_hash, otx.status))

apps/cic-eth/tests/task/api/test_admin_noncritical.py

@@ -30,6 +30,7 @@ from chainqueue.sql.state import (
         )
 from chainqueue.db.models.otx import Otx
 from chainqueue.db.enum import StatusBits
+from chainqueue.sql.query import get_nonce_tx_cache
 from eth_erc20 import ERC20
 from cic_eth_registry import CICRegistry
 
@@ -37,7 +38,6 @@ from cic_eth_registry import CICRegistry
 from cic_eth.api.admin import AdminApi
 from cic_eth.eth.gas import cache_gas_data
 from cic_eth.eth.erc20 import cache_transfer_data
-from cic_eth.queue.query import get_nonce_tx_local
 
 logg = logging.getLogger()
 
@@ -312,7 +312,7 @@ def test_resend_inplace(
     otx = Otx.load(tx_hash_hex, session=init_database)
     assert otx.status & StatusBits.OBSOLETE == StatusBits.OBSOLETE
 
-    txs = get_nonce_tx_local(default_chain_spec, otx.nonce, agent_roles['ALICE'], session=init_database)
+    txs = get_nonce_tx_cache(default_chain_spec, otx.nonce, agent_roles['ALICE'], session=init_database)
     assert len(txs) == 2
 
 
@@ -363,10 +363,10 @@ def test_resend_clone(
     assert otx.status & StatusBits.IN_NETWORK == StatusBits.IN_NETWORK
     assert otx.status & StatusBits.OBSOLETE == StatusBits.OBSOLETE
 
-    txs = get_nonce_tx_local(default_chain_spec, otx.nonce, agent_roles['ALICE'], session=init_database)
+    txs = get_nonce_tx_cache(default_chain_spec, otx.nonce, agent_roles['ALICE'], session=init_database)
     assert len(txs) == 1
 
-    txs = get_nonce_tx_local(default_chain_spec, otx.nonce + 1, agent_roles['ALICE'], session=init_database)
+    txs = get_nonce_tx_cache(default_chain_spec, otx.nonce + 1, agent_roles['ALICE'], session=init_database)
     assert len(txs) == 1
 
     otx = Otx.load(txs[0], session=init_database)

apps/cic-eth/tests/task/api/test_app.py

@@ -10,7 +10,6 @@ from cic_eth_registry.erc20 import ERC20Token
 from chainlib.chain import ChainSpec
 from eth_accounts_index import AccountsIndex
 from chainlib.eth.tx import (
-        receipt,
         transaction,
         )
 from chainqueue.sql.state import (
@@ -30,7 +29,6 @@ def test_account_api(
         init_database,
         init_eth_rpc,
         account_registry,
-        cic_registry,
         custodial_roles,
         celery_session_worker,
         ):
@@ -51,7 +49,6 @@ def test_account_api_register(
         eth_rpc,
         celery_session_worker,
         ):
-
     api = Api(str(default_chain_spec), callback_param='accounts', callback_task='cic_eth.callbacks.noop.noop', queue=None)
     t = api.create_account('')
     register_tx_hash = t.get_leaf()
@@ -72,18 +69,12 @@ def test_account_api_register(
     r = t.get_leaf()
     assert t.successful()
 
-    o = receipt(register_tx_hash)
-    r = eth_rpc.do(o)
-    assert r['status'] == 1
-
     o = transaction(register_tx_hash)
     tx_src = eth_rpc.do(o)
 
     c = AccountsIndex(default_chain_spec)
     address = c.parse_add_request(tx_src['data'])
-    logg.debug('address {} '.format(address))
     o = c.have(account_registry, address[0], sender_address=custodial_roles['CONTRACT_DEPLOYER'])
-    logg.debug('o {}'.format(o))
     r = eth_rpc.do(o)
     assert c.parse_have(r)
 

apps/cic-eth/tests/task/api/test_balance.py

@@ -3,22 +3,18 @@ import os
 import logging
 
 # external imports
-import pytest
 from chainlib.eth.address import to_checksum_address
-from hexathon import add_0x
 
 # local imports
 from cic_eth.api.api_task import Api
 
 logg = logging.getLogger()
 
-
 def test_balance_simple_api(
         default_chain_spec,
         init_database,
         cic_registry,
         foo_token,
-        register_lookups,
         register_tokens,
         api,
         celery_session_worker,
@@ -26,7 +22,7 @@ def test_balance_simple_api(
 
     chain_str = str(default_chain_spec)
 
-    a = add_0x(to_checksum_address(os.urandom(20).hex()))
+    a = to_checksum_address('0x' + os.urandom(20).hex())
     t = api.balance(a, 'FOO', include_pending=False)
     r = t.get_leaf()
     assert t.successful()
@@ -40,7 +36,6 @@ def test_balance_complex_api(
         init_database,
         cic_registry,
         foo_token,
-        register_lookups,
         register_tokens,
         api,
         celery_session_worker,
@@ -48,7 +43,7 @@ def test_balance_complex_api(
 
     chain_str = str(default_chain_spec)
 
-    a = add_0x(to_checksum_address(os.urandom(20).hex()))
+    a = to_checksum_address('0x' + os.urandom(20).hex())
     t = api.balance(a, 'FOO', include_pending=True)
     r = t.get_leaf()
     assert t.successful()

apps/cic-eth/tests/task/api/test_list.py

@@ -6,7 +6,6 @@ import pytest
 from chainlib.eth.nonce import RPCNonceOracle
 from eth_erc20 import ERC20
 from chainlib.eth.tx import receipt
-from hexathon import strip_0x
 
 # local imports
 from cic_eth.api.api_task import Api
@@ -24,6 +23,7 @@ from cic_eth.pytest.mock.filter import (
 logg = logging.getLogger()
 
 
+@pytest.mark.xfail()
 def test_list_tx(
         default_chain_spec,
         init_database,
@@ -34,10 +34,8 @@ def test_list_tx(
         agent_roles,
         foo_token,
         register_tokens,
-        register_lookups,
         init_eth_tester,
         celery_session_worker,
-        init_celery_tasks,
         ):
 
     tx_hashes = []
@@ -65,16 +63,13 @@ def test_list_tx(
     o = receipt(tx_hash_hex)
     r = eth_rpc.do(o)
     assert r['status'] == 1
-
     a = r['block_number']
-    ab = a.to_bytes(4, 'big')
+    block_filter.add(a.to_bytes(4, 'big'))
-    block_filter.add(ab)
 
-    bb = r['transaction_index'].to_bytes(4, 'big')
+    a = r['block_number'] + r['transaction_index']
-    cb = ab + bb
+    tx_filter.add(a.to_bytes(4, 'big'))
-    tx_filter.add(cb)
 
-    tx_hashes.append(strip_0x(tx_hash_hex))
+    tx_hashes.append(tx_hash_hex)
 
     # external tx two
     Nonce.next(agent_roles['ALICE'], 'foo', session=init_database)
@@ -88,29 +83,26 @@ def test_list_tx(
     o = receipt(tx_hash_hex)
     r = eth_rpc.do(o)
     assert r['status'] == 1
-
     a = r['block_number']
-    ab = a.to_bytes(4, 'big')
+    block_filter.add(a.to_bytes(4, 'big'))
-    block_filter.add(ab)
 
-    bb = r['transaction_index'].to_bytes(4, 'big')
+    a = r['block_number'] + r['transaction_index']
-    cb = ab + bb
+    tx_filter.add(a.to_bytes(4, 'big'))
-    tx_filter.add(cb)
 
-    tx_hashes.append(strip_0x(tx_hash_hex))
+    tx_hashes.append(tx_hash_hex)
 
     init_eth_tester.mine_blocks(28)
 
     # custodial tx 1
     api = Api(str(default_chain_spec), queue=None)
-    t = api.transfer(agent_roles['ALICE'], agent_roles['CAROL'], 64, 'FOO')
+    t = api.transfer(agent_roles['ALICE'], agent_roles['CAROL'], 64, 'FOO') #, 'blinky')
     r = t.get_leaf()
     assert t.successful()
     tx_hashes.append(r)
 
     # custodial tx 2
     api = Api(str(default_chain_spec), queue=None)
-    t = api.transfer(agent_roles['ALICE'], agent_roles['DAVE'], 16, 'FOO')
+    t = api.transfer(agent_roles['ALICE'], agent_roles['DAVE'], 16, 'FOO') #, 'blinky')
     r = t.get_leaf()
     assert t.successful()
     tx_hashes.append(r)
@@ -125,8 +117,7 @@ def test_list_tx(
     assert len(r) == 3
     logg.debug('rrrr {}'.format(r))
 
-    logg.debug('testing against hashes {}'.format(tx_hashes))
     for tx in r:
         logg.debug('have tx {}'.format(tx))
-        tx_hashes.remove(strip_0x(tx['hash']))
+        tx_hashes.remove(tx['hash'])
     assert len(tx_hashes) == 1

apps/cic-eth/tests/task/test_ext_tx.py

@@ -10,7 +10,6 @@ from chainlib.eth.tx import (
         )
 from eth_erc20 import ERC20
 from chainlib.eth.nonce import RPCNonceOracle
-from hexathon import add_0x 
 
 # local imports
 from cic_eth.db.models.nonce import (
@@ -92,5 +91,5 @@ def test_filter_process(
 
     assert len(r) == 2
     for tx_hash in r.keys():
-        tx_hashes.remove(add_0x(tx_hash))
+        tx_hashes.remove(tx_hash)
     assert len(tx_hashes) == 0

apps/cic-eth/tests/task/test_task_gas.py

@@ -21,6 +21,7 @@ from chainlib.eth.constant import (
         MINIMUM_FEE_UNITS,
         MINIMUM_FEE_PRICE,
         )
+from chainqueue.sql.tx import create as queue_create
 from chainqueue.sql.query import get_tx
 from chainqueue.db.enum import StatusBits
 from chainqueue.sql.state import (
@@ -34,7 +35,6 @@ from hexathon import strip_0x
 # local imports
 from cic_eth.eth.gas import cache_gas_data
 from cic_eth.error import OutOfGasError
-from cic_eth.queue.tx import queue_create
 
 logg = logging.getLogger()
 
@@ -75,7 +75,7 @@ def test_task_check_gas_ok(
             'cic_eth.eth.gas.check_gas',
             [
                 [
-                    strip_0x(tx_hash_hex),
+                    tx_hash_hex,
                     ],
                 default_chain_spec.asdict(),
                 [],
@@ -283,3 +283,4 @@ def test_task_resend_explicit(
     tx_after = unpack(bytes.fromhex(strip_0x(otx.signed_tx)), default_chain_spec)
     logg.debug('gasprices before {} after {}'.format(tx_before['gasPrice'], tx_after['gasPrice']))
     assert tx_after['gasPrice'] > tx_before['gasPrice']
+

apps/cic-eth/tests/task/test_task_list.py

@@ -51,7 +51,6 @@ def test_ext_tx_collate(
         tx_hash_hex,
         tx_signed_raw_hex,
         )
-    otx.block = 666
     init_database.add(otx)
     init_database.commit()
 

apps/cic-eth/tests/unit/db/test_tx.py

@@ -46,7 +46,6 @@ def test_set(
         tx_hash_hex,
         tx_signed_raw_hex,
         )
-    otx.block = 666
     init_database.add(otx)
     init_database.commit()
 
@@ -75,6 +74,7 @@ def test_set(
     assert (tx_stored.destination_token_address == ZERO_ADDRESS)
     assert (tx_stored.from_value == tx['value'])
     assert (tx_stored.to_value == to_value)
+    assert (tx_stored.block_number == 666)
     assert (tx_stored.tx_index == 13)
 
 

apps/cic-eth/tests/unit/queue/test_balances.py

@@ -13,7 +13,6 @@ from cic_eth.queue.balance import (
         balance_incoming,
         assemble_balances,
         )
-from cic_eth.encode import tx_normalize
 
 logg = logging.getLogger()
 
@@ -52,8 +51,8 @@ def test_assemble():
     r = assemble_balances(b)
     logg.debug('r {}'.format(r))
 
-    assert r[0]['address'] == tx_normalize.executable_address(token_foo)
+    assert r[0]['address'] == token_foo
-    assert r[1]['address'] == tx_normalize.executable_address(token_bar)
+    assert r[1]['address'] == token_bar
     assert r[0].get('balance_foo') != None
     assert r[0].get('balance_bar') != None
     assert r[1].get('balance_baz') != None
@@ -75,11 +74,11 @@ def test_outgoing_balance(
     token_address = '0x' + os.urandom(20).hex()
     sender = '0x' + os.urandom(20).hex()
     txc = TxCache(
-            tx_normalize.tx_hash(tx_hash),
+            tx_hash,
-            tx_normalize.wallet_address(sender),
+            sender,
-            tx_normalize.wallet_address(recipient),
+            recipient,
-            tx_normalize.executable_address(token_address),
+            token_address,
-            tx_normalize.executable_address(token_address),
+            token_address,
             1000,
             1000,
             session=init_database,
@@ -126,11 +125,11 @@ def test_incoming_balance(
     token_address = '0x' + os.urandom(20).hex()
     sender = '0x' + os.urandom(20).hex()
     txc = TxCache(
-            tx_normalize.tx_hash(tx_hash),
+            tx_hash,
-            tx_normalize.wallet_address(sender),
+            sender,
-            tx_normalize.wallet_address(recipient),
+            recipient,
-            tx_normalize.executable_address(token_address),
+            token_address,
-            tx_normalize.executable_address(token_address),
+            token_address,
             1000,
             1000,
             session=init_database,

apps/cic-eth/tests/unit/queue/test_query.py

@@ -21,7 +21,6 @@ from cic_eth.db.models.lock import Lock
 from cic_eth.queue.query import get_upcoming_tx
 from cic_eth.queue.tx import register_tx
 from cic_eth.eth.gas import cache_gas_data
-from cic_eth.encode import tx_normalize
 
 # test imports
 from tests.util.nonce import StaticNonceOracle
@@ -40,8 +39,8 @@ def test_upcoming_with_lock(
     gas_oracle = RPCGasOracle(eth_rpc)
     c = Gas(default_chain_spec, signer=eth_signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle)
 
-    alice_normal = tx_normalize.wallet_address(agent_roles['ALICE'])
+    alice_normal = add_0x(hex_uniform(strip_0x(agent_roles['ALICE'])))
-    bob_normal = tx_normalize.wallet_address(agent_roles['BOB'])
+    bob_normal = add_0x(hex_uniform(strip_0x(agent_roles['BOB'])))
 
     (tx_hash_hex, tx_rpc) = c.create(alice_normal, bob_normal, 100 * (10 ** 6))
     tx_signed_raw_hex = tx_rpc['params'][0]

apps/cic-eth/tests/unit/queue/test_queue_lock.py

@@ -9,7 +9,7 @@ from cic_eth.db.models.lock import Lock
 from cic_eth.db.enum import LockEnum
 from cic_eth.error import LockedError
 from cic_eth.queue.tx import queue_create
-from cic_eth.encode import tx_normalize
+
 
 def test_queue_lock(
     init_database,
@@ -21,8 +21,6 @@ def test_queue_lock(
     address = '0x' + os.urandom(20).hex()
     tx_hash = '0x' + os.urandom(32).hex()
     tx_raw = '0x' + os.urandom(128).hex()
-    address_normal = tx_normalize.wallet_address(address)
-    tx_hash_normal = tx_normalize.tx_hash(tx_hash)
 
     Lock.set(chain_str, LockEnum.QUEUE)
     with pytest.raises(LockedError):
@@ -34,7 +32,7 @@ def test_queue_lock(
                 tx_raw,
                 )
 
-    Lock.set(chain_str, LockEnum.QUEUE, address=address_normal)
+    Lock.set(chain_str, LockEnum.QUEUE, address=address)
     with pytest.raises(LockedError):
         queue_create(
                 default_chain_spec,
@@ -54,7 +52,7 @@ def test_queue_lock(
                 tx_raw,
                 )
 
-    Lock.set(chain_str, LockEnum.QUEUE, address=address_normal, tx_hash=tx_hash_normal)
+    Lock.set(chain_str, LockEnum.QUEUE, address=address, tx_hash=tx_hash)
     with pytest.raises(LockedError):
         queue_create(
                 default_chain_spec,
@@ -63,3 +61,5 @@ def test_queue_lock(
                 tx_hash,
                 tx_raw,
                 )
+
+

apps/cic-eth/tools_requirements.txt

@@ -1,7 +1,8 @@
-crypto-dev-signer>=0.4.15a7,<=0.4.15
+crypto-dev-signer>=0.4.14b7,<=0.4.14
-chainqueue>=0.0.5a1,<0.1.0
+chainqueue>=0.0.3a1,<0.1.0
-cic-eth-registry>=0.6.1a3,<0.7.0
+confini>=0.3.6rc4,<0.5.0
+cic-eth-registry>=0.5.8a1,<0.6.0
 redis==3.5.3
-hexathon~=0.0.1a8
+hexathon~=0.0.1a7
 pycryptodome==3.10.1
 pyxdg==0.27

apps/cic-meta/.gitlab-ci.yml

@@ -1,16 +1,43 @@
-build-test-cic-meta:
+
-  stage: test
+.cic_meta_variables:
-  tags:
+    variables:
-   - integration
+        APP_NAME: cic-meta
-  variables:
+        DOCKERFILE_PATH: docker/Dockerfile_ci
-    APP_NAME: cic-meta
+        CONTEXT: apps/$APP_NAME
-    MR_IMAGE_TAG: mr-$APP_NAME-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA
+
-  script:
+build-mr-cic-meta:
-    - cd apps/cic-meta
+    extends:
-    - docker build -t $MR_IMAGE_TAG -f docker/Dockerfile . 
+        - .py_build_merge_request
-    - docker run --entrypoint=sh $MR_IMAGE_TAG docker/run_tests.sh
+        - .cic_meta_variables
-  rules:
+    rules:
     - if: $CI_PIPELINE_SOURCE == "merge_request_event"
       changes:
-          - apps/$APP_NAME/**/*
+          - apps/cic-meta/**/*
+      when: always
+
+test-mr-cic-meta:
+    extends:
+        - .cic_meta_variables
+    stage: test
+    image: $MR_IMAGE_TAG 
+    script:
+        - cd /root
+        - npm install --dev 
+        - npm run test
+        - npm run test:coverage
+    needs: ["build-mr-cic-meta"]
+    rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      changes:
+          - apps/cic-meta/**/*
+      when: always
+
+build-push-cic-meta:
+    extends:
+        - .py_build_push
+        - .cic_meta_variables
+    rules:
+    - if:  $CI_COMMIT_BRANCH == "master"
+      changes:
+          - apps/cic-meta/**/*
       when: always

apps/cic-meta/README.md

@@ -1 +0,0 @@
-# CIC-Meta

apps/cic-meta/docker/Dockerfile

@@ -15,10 +15,11 @@ RUN --mount=type=cache,mode=0755,target=/root/.npm \
 COPY webpack.config.js .
 COPY tsconfig.json . 
 ## required to build the cic-client-meta module
-COPY . .
+COPY src/ src/
+COPY scripts/ scripts/
+COPY tests/ tests/
 COPY tests/*.asc /root/pgp/
 
-
 ## copy runtime configs
 COPY .config/ /usr/local/etc/cic-meta/
 #

apps/cic-meta/docker/Dockerfile_ci

@@ -0,0 +1,32 @@
+# syntax = docker/dockerfile:1.2
+#FROM node:15.3.0-alpine3.10
+FROM node:lts-alpine3.14
+
+WORKDIR /root
+
+RUN apk add --no-cache postgresql bash
+
+# copy the dependencies
+COPY package.json package-lock.json .
+RUN npm set cache /root/.npm && \
+    npm ci
+
+COPY webpack.config.js .
+COPY tsconfig.json . 
+## required to build the cic-client-meta module
+COPY src/ src/
+COPY scripts/ scripts/
+COPY tests/ tests/
+COPY tests/*.asc /root/pgp/
+
+## copy runtime configs
+COPY .config/ /usr/local/etc/cic-meta/
+#
+## db migrations
+COPY docker/db.sh ./db.sh
+RUN chmod 755 ./db.sh
+#
+RUN alias tsc=node_modules/typescript/bin/tsc 
+COPY docker/start_server.sh ./start_server.sh
+RUN chmod 755 ./start_server.sh
+ENTRYPOINT ["sh", "./start_server.sh"]

apps/cic-meta/docker/run_tests.sh

@@ -1,7 +0,0 @@
-#! /bin/bash
-
-set -e
-
-npm install --dev 
-npm run test
-npm run test:coverage

apps/cic-notify/.gitlab-ci.yml

@@ -1,17 +1,52 @@
-build-test-cic-notify:
+.cic_notify_variables:
-  stage: test
+    variables:
-  tags:
+        APP_NAME: cic-notify
-    - integration
+        DOCKERFILE_PATH: docker/Dockerfile_ci
-  variables:
+        CONTEXT: apps/$APP_NAME
-    APP_NAME: cic-notify
+
-    MR_IMAGE_TAG: mr-$APP_NAME-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA
+build-mr-cic-notify:
-  script:
+    extends:
-    - cd apps/cic-notify
+        - .py_build_merge_request
-    - docker build -t $MR_IMAGE_TAG -f docker/Dockerfile . 
+        - .cic_notify_variables
-    - docker run $MR_IMAGE_TAG sh docker/run_tests.sh
+    rules:
-  allow_failure: true
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-  rules:
+      changes:
-  - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+          - apps/cic-notify/**/*
-    changes:
+      when: always
-        - apps/$APP_NAME/**/*
+
-    when: always
+test-mr-cic-notify:
+    stage: test
+    extends:
+        - .cic_notify_variables
+    cache:
+        key:
+            files:
+                - test_requirements.txt
+        paths:
+        - /root/.cache/pip
+    image: $MR_IMAGE_TAG
+    script:
+        - cd apps/$APP_NAME/
+        - >
+          pip install --extra-index-url https://pip.grassrootseconomics.net:8433
+          --extra-index-url https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple
+          -r test_requirements.txt 
+        - export PYTHONPATH=. && pytest -x --cov=cic_notify --cov-fail-under=90 --cov-report term-missing tests
+    needs: ["build-mr-cic-notify"]
+    rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      changes:
+          - apps/$APP_NAME/**/*
+      when: always
+
+build-push-cic-notify:
+    extends:
+        - .py_build_push
+        - .cic_notify_variables
+    rules:
+    - if:  $CI_COMMIT_BRANCH == "master"
+      changes:
+          - apps/cic-notify/**/*
+      when: always
+        
+

apps/cic-notify/cic_notify/tasks/sms/db.py

@@ -11,12 +11,12 @@ celery_app = celery.current_app
 
 
 @celery_app.task
-def persist_notification(message, recipient):
+def persist_notification(recipient, message):
     """
-    :param message:
-    :type message:
     :param recipient:
     :type recipient:
+    :param message:
+    :type message:
     :return:
     :rtype:
     """

apps/cic-notify/cic_notify/tasks/sms/log.py

@@ -11,13 +11,12 @@ local_logg = logging.getLogger(__name__)
 
 
 @celery_app.task
-def log(message, recipient):
+def log(recipient, message):
     """
-
-    :param message:
-    :type message:
     :param recipient:
     :type recipient:
+    :param message:
+    :type message:
     :return:
     :rtype:
     """

apps/cic-notify/docker/Dockerfile_ci

@@ -0,0 +1,27 @@
+# syntax = docker/dockerfile:1.2
+FROM registry.gitlab.com/grassrootseconomics/cic-base-images:python-3.8.6-dev-55da5f4e as dev
+
+#RUN pip install $pip_extra_index_url_flag cic-base[full_graph]==0.1.2a62
+
+ARG EXTRA_INDEX_URL="https://pip.grassrootseconomics.net:8433"
+ARG GITLAB_PYTHON_REGISTRY="https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple"
+COPY requirements.txt .
+
+RUN pip install --index-url https://pypi.org/simple  \
+	  --extra-index-url $GITLAB_PYTHON_REGISTRY --extra-index-url $EXTRA_INDEX_URL \
+    -r requirements.txt
+
+COPY . .
+
+RUN python setup.py install
+
+COPY docker/*.sh .
+RUN chmod +x *.sh 
+
+# ini files in config directory defines the configurable parameters for the application
+# they can all be overridden by environment variables
+# to generate a list of environment variables from configuration, use: confini-dump -z <dir> (executable provided by confini package)
+COPY .config/ /usr/local/etc/cic-notify/
+COPY cic_notify/db/migrations/ /usr/local/share/cic-notify/alembic/
+
+ENTRYPOINT []

apps/cic-notify/docker/run_tests.sh

@@ -1,9 +0,0 @@
-#! /bin/bash
-
-set -e
-
-pip install --extra-index-url https://pip.grassrootseconomics.net:8433 \
---extra-index-url https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple \
--r test_requirements.txt 
-
-export PYTHONPATH=. && pytest -x --cov=cic_notify --cov-fail-under=90 --cov-report term-missing tests

apps/cic-ussd/.gitlab-ci.yml

@@ -1,16 +1,52 @@
-build-test-cic-ussd:
+.cic_ussd_variables:
-  stage: test
+    variables:
-  tags:
+        APP_NAME: cic-ussd
-  - integration
+        DOCKERFILE_PATH: docker/Dockerfile_ci
-  variables:
+        CONTEXT: apps/$APP_NAME
-    APP_NAME: cic-ussd
+
-    MR_IMAGE_TAG: mr-$APP_NAME-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA
+build-mr-cic-ussd:
-  script:
+    extends:
-    - cd apps/cic-ussd
+        - .py_build_merge_request
-    - docker build -t $MR_IMAGE_TAG -f docker/Dockerfile . 
+        - .cic_ussd_variables
-    - docker run $MR_IMAGE_TAG sh docker/run_tests.sh
+    rules:
-  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-  - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      changes:
-    changes:
+          - apps/cic-ussd/**/*
-        - apps/$APP_NAME/**/*
+      when: always
-    when: always
+
+test-mr-cic-ussd:
+    stage: test
+    extends:
+        - .cic_ussd_variables
+    cache:
+        key:
+            files:
+                - test_requirements.txt
+        paths:
+        - /root/.cache/pip
+    image: $MR_IMAGE_TAG
+    script:
+        - cd apps/$APP_NAME/
+        - >
+          pip install --extra-index-url https://pip.grassrootseconomics.net:8433
+          --extra-index-url https://gitlab.com/api/v4/projects/27624814/packages/pypi/simple
+          -r test_requirements.txt 
+        - export PYTHONPATH=. && pytest -x --cov=cic_ussd --cov-fail-under=90 --cov-report term-missing tests/cic_ussd
+    needs: ["build-mr-cic-ussd"]
+    rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      changes:
+          - apps/$APP_NAME/**/*
+      when: always
+
+build-push-cic-ussd:
+    extends:
+        - .py_build_push
+        - .cic_ussd_variables
+    rules:
+    - if:  $CI_COMMIT_BRANCH == "master"
+      changes:
+          - apps/cic-ussd/**/*
+      when: always
+
+

apps/cic-ussd/cic_ussd/account/balance.py

@@ -1,12 +1,10 @@
 # standard imports
-
 import json
 import logging
 from typing import Optional
 
 # third-party imports
 from cic_eth.api import Api
-from cic_eth_aux.erc20_demurrage_token.api import Api as DemurrageApi
 
 # local imports
 from cic_ussd.account.transaction import from_wei
@@ -22,7 +20,7 @@ def get_balances(address: str,
                  asynchronous: bool = False,
                  callback_param: any = None,
                  callback_queue='cic-ussd',
-                 callback_task='cic_ussd.tasks.callback_handler.balances_callback') -> Optional[list]:
+                 callback_task='cic_ussd.tasks.callback_handler.process_balances_callback') -> Optional[list]:
     """This function queries cic-eth for an account's balances, It provides a means to receive the balance either
     asynchronously or synchronously.. It returns a dictionary containing the network, outgoing and incoming balances.
     :param address: Ethereum address of an account.
@@ -75,24 +73,6 @@ def calculate_available_balance(balances: dict) -> float:
     return from_wei(value=available_balance)
 
 
-def get_adjusted_balance(balance: int, chain_str: str, timestamp: int, token_symbol: str):
-    """
-    :param balance:
-    :type balance:
-    :param chain_str:
-    :type chain_str:
-    :param timestamp:
-    :type timestamp:
-    :param token_symbol:
-    :type token_symbol:
-    :return:
-    :rtype:
-    """
-    logg.debug(f'retrieving adjusted balance on chain: {chain_str}')
-    demurrage_api = DemurrageApi(chain_str=chain_str)
-    return demurrage_api.get_adjusted_balance(token_symbol, balance, timestamp).result
-
-
 def get_cached_available_balance(blockchain_address: str) -> float:
     """This function attempts to retrieve balance data from the redis cache.
     :param blockchain_address: Ethereum address of an account.
@@ -101,21 +81,10 @@ def get_cached_available_balance(blockchain_address: str) -> float:
     :return: Operational balance of an account.
     :rtype: float
     """
-    identifier = bytes.fromhex(blockchain_address)
+    identifier = bytes.fromhex(blockchain_address[2:])
     key = cache_data_key(identifier, salt=':cic.balances')
     cached_balances = get_cached_data(key=key)
     if cached_balances:
         return calculate_available_balance(json.loads(cached_balances))
     else:
         raise CachedDataNotFoundError(f'No cached available balance for address: {blockchain_address}')
-
-
-def get_cached_adjusted_balance(identifier: bytes):
-    """
-    :param identifier:
-    :type identifier:
-    :return:
-    :rtype:
-    """
-    key = cache_data_key(identifier, ':cic.adjusted_balance')
-    return get_cached_data(key)

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

@@ -4,6 +4,7 @@ import logging
 from typing import Optional
 
 # external imports
+from chainlib.hash import strip_0x
 from cic_types.models.person import Person
 
 # local imports
@@ -19,7 +20,7 @@ def get_cached_preferred_language(blockchain_address: str) -> Optional[str]:
     :return: Account's set preferred language | Fallback preferred language.
     :rtype: str
     """
-    identifier = bytes.fromhex(blockchain_address)
+    identifier = bytes.fromhex(strip_0x(blockchain_address))
     preferences_metadata_handler = PreferencesMetadata(identifier)
     cached_preferences_metadata = preferences_metadata_handler.get_cached_metadata()
     if cached_preferences_metadata:

apps/cic-ussd/cic_ussd/account/statement.py

@@ -86,7 +86,7 @@ def query_statement(blockchain_address: str, limit: int = 9):
     :param limit: Number of transactions to be returned.
     :type limit: int
     """
-    logg.debug(f'retrieving statement for address: {blockchain_address}')
+    logg.debug(f'retrieving balance for address: {blockchain_address}')
     chain_str = Chain.spec.__str__()
     cic_eth_api = Api(
         chain_str=chain_str,

apps/cic-ussd/cic_ussd/account/transaction.py

@@ -1,6 +1,5 @@
 # standard import
 import decimal
-import json
 import logging
 from typing import Dict, Tuple
 
@@ -9,8 +8,6 @@ from cic_eth.api import Api
 from sqlalchemy.orm.session import Session
 
 # local import
-from cic_ussd.account.chain import Chain
-from cic_ussd.account.tokens import get_cached_default_token
 from cic_ussd.db.models.account import Account
 from cic_ussd.db.models.base import SessionBase
 from cic_ussd.error import UnknownUssdRecipient
@@ -62,9 +59,7 @@ def from_wei(value: int) -> float:
     :return: SRF equivalent of value in Wei
     :rtype: float
     """
-    cached_token_data = json.loads(get_cached_default_token(Chain.spec.__str__()))
+    value = float(value) / 1e+6
-    token_decimals: int = cached_token_data.get('decimals')
-    value = float(value) / (10**token_decimals)
     return truncate(value=value, decimals=2)
 
 
@@ -75,9 +70,7 @@ def to_wei(value: int) -> int:
     :return: Wei equivalent of value in SRF
     :rtype: int
     """
-    cached_token_data = json.loads(get_cached_default_token(Chain.spec.__str__()))
+    return int(value * 1e+6)
-    token_decimals: int = cached_token_data.get('decimals')
-    return int(value * (10**token_decimals))
 
 
 def truncate(value: float, decimals: int):
@@ -124,18 +117,18 @@ def transaction_actors(transaction: dict) -> Tuple[Dict, Dict]:
     return recipient_transaction_data, sender_transaction_data
 
 
-def validate_transaction_account(blockchain_address: str, role: str, session: Session) -> Account:
+def validate_transaction_account(session: Session, transaction: dict) -> Account:
     """This function checks whether the blockchain address specified in a parsed transaction object resolves to an
     account object in the ussd system.
-    :param blockchain_address:
+    :param session: Database session object.
-    :type blockchain_address:
+    :type session: Session
-    :param role:
+    :param transaction: Parsed transaction data object.
-    :type role:
+    :type transaction: dict
-    :param session:
-    :type session:
     :return:
     :rtype:
     """
+    blockchain_address = transaction.get('blockchain_address')
+    role = transaction.get('role')
     session = SessionBase.bind_session(session)
     account = session.query(Account).filter_by(blockchain_address=blockchain_address).first()
     if not account:

apps/cic-ussd/cic_ussd/db/models/account.py

@@ -2,6 +2,7 @@
 import json
 
 # external imports
+from chainlib.hash import strip_0x
 from cic_eth.api import Api
 
 # local imports
@@ -100,7 +101,7 @@ class Account(SessionBase):
         session.add(self)
         session.flush()
         SessionBase.release_session(session=session)
-        return 'Pin reset successful.'
+        return f'Pin reset successful.'
 
     def standard_metadata_id(self) -> str:
         """This function creates an account's standard metadata identification information that contains an account owner's
@@ -108,7 +109,7 @@ class Account(SessionBase):
         :return: Standard metadata identification information | e164 formatted phone number.
         :rtype: str
         """
-        identifier = bytes.fromhex(self.blockchain_address)
+        identifier = bytes.fromhex(strip_0x(self.blockchain_address))
         key = cache_data_key(identifier, ':cic.person')
         account_metadata = get_cached_data(key)
         if not account_metadata:

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

@@ -44,7 +44,7 @@ class MetadataRequestsHandler(Metadata):
 
     def create(self, data: Union[Dict, str]):
         """"""
-        data = json.dumps(data).encode('utf-8')
+        data = json.dumps(data)
         result = make_request(method='POST', url=self.url, data=data, headers=self.headers)
 
         error_handler(result=result)

apps/cic-ussd/cic_ussd/processor/menu.py

@@ -1,17 +1,13 @@
 # standard imports
 import json
 import logging
-from datetime import datetime, timedelta
 
 # external imports
 import i18n.config
+from sqlalchemy.orm.session import Session
 
 # local imports
-from cic_ussd.account.balance import (calculate_available_balance,
+from cic_ussd.account.balance import calculate_available_balance, get_balances, get_cached_available_balance
-                                      get_adjusted_balance,
-                                      get_balances,
-                                      get_cached_adjusted_balance,
-                                      get_cached_available_balance)
 from cic_ussd.account.chain import Chain
 from cic_ussd.account.metadata import get_cached_preferred_language
 from cic_ussd.account.statement import (
@@ -20,15 +16,14 @@ from cic_ussd.account.statement import (
     query_statement,
     statement_transaction_set
 )
-from cic_ussd.account.tokens import get_default_token_symbol
 from cic_ussd.account.transaction import from_wei, to_wei
+from cic_ussd.account.tokens import get_default_token_symbol
 from cic_ussd.cache import cache_data_key, cache_data
 from cic_ussd.db.models.account import Account
 from cic_ussd.metadata import PersonMetadata
 from cic_ussd.phone_number import Support
-from cic_ussd.processor.util import parse_person_metadata
+from cic_ussd.processor.util import latest_input, parse_person_metadata
 from cic_ussd.translation import translation_for
-from sqlalchemy.orm.session import Session
 
 logg = logging.getLogger(__name__)
 
@@ -37,7 +32,7 @@ class MenuProcessor:
     def __init__(self, account: Account, display_key: str, menu_name: str, session: Session, ussd_session: dict):
         self.account = account
         self.display_key = display_key
-        self.identifier = bytes.fromhex(self.account.blockchain_address)
+        self.identifier = bytes.fromhex(self.account.blockchain_address[2:])
         self.menu_name = menu_name
         self.session = session
         self.ussd_session = ussd_session
@@ -48,26 +43,21 @@ class MenuProcessor:
         :rtype:
         """
         available_balance = get_cached_available_balance(self.account.blockchain_address)
-        adjusted_balance = get_cached_adjusted_balance(self.identifier)
+        logg.debug('Requires call to retrieve tax and bonus amounts')
+        tax = ''
+        bonus = ''
         token_symbol = get_default_token_symbol()
         preferred_language = get_cached_preferred_language(self.account.blockchain_address)
         if not preferred_language:
             preferred_language = i18n.config.get('fallback')
-        with_available_balance = f'{self.display_key}.available_balance'
+        return translation_for(
-        with_fees = f'{self.display_key}.with_fees'
+            key=self.display_key,
-        if not adjusted_balance:
+            preferred_language=preferred_language,
-            return translation_for(key=with_available_balance,
+            available_balance=available_balance,
-                                   preferred_language=preferred_language,
+            tax=tax,
-                                   available_balance=available_balance,
+            bonus=bonus,
-                                   token_symbol=token_symbol)
+            token_symbol=token_symbol
-        adjusted_balance = json.loads(adjusted_balance)
+        )
-        tax_wei = to_wei(int(available_balance)) - int(adjusted_balance)
-        tax = from_wei(int(tax_wei))
-        return translation_for(key=with_fees,
-                               preferred_language=preferred_language,
-                               available_balance=available_balance,
-                               tax=tax,
-                               token_symbol=token_symbol)
 
     def account_statement(self) -> str:
         """
@@ -77,7 +67,7 @@ class MenuProcessor:
         cached_statement = get_cached_statement(self.account.blockchain_address)
         statement = json.loads(cached_statement)
         statement_transactions = parse_statement_transactions(statement)
-        transaction_sets = [statement_transactions[tx:tx + 3] for tx in range(0, len(statement_transactions), 3)]
+        transaction_sets = [statement_transactions[tx:tx+3] for tx in range(0, len(statement_transactions), 3)]
         preferred_language = get_cached_preferred_language(self.account.blockchain_address)
         if not preferred_language:
             preferred_language = i18n.config.get('fallback')
@@ -159,22 +149,12 @@ class MenuProcessor:
         :return:
         :rtype:
         """
-        chain_str = Chain.spec.__str__()
         token_symbol = get_default_token_symbol()
         blockchain_address = self.account.blockchain_address
-        balances = get_balances(blockchain_address, chain_str, token_symbol, False)[0]
+        balances = get_balances(blockchain_address, Chain.spec.__str__(), token_symbol, False)[0]
         key = cache_data_key(self.identifier, ':cic.balances')
         cache_data(key, json.dumps(balances))
         available_balance = calculate_available_balance(balances)
-        now = datetime.now()
-        if (now - self.account.created).days >= 30:
-            if available_balance <= 0:
-                logg.info(f'Not retrieving adjusted balance, available balance: {available_balance} is insufficient.')
-            else:
-                timestamp = int((now - timedelta(30)).timestamp())
-                adjusted_balance = get_adjusted_balance(to_wei(int(available_balance)), chain_str, timestamp, token_symbol)
-                key = cache_data_key(self.identifier, ':cic.adjusted_balance')
-                cache_data(key, json.dumps(adjusted_balance))
 
         query_statement(blockchain_address)
 

apps/cic-ussd/cic_ussd/processor/util.py

@@ -67,7 +67,6 @@ def resume_last_ussd_session(last_state: str) -> Document:
         'exit',
         'exit_invalid_pin',
         'exit_invalid_new_pin',
-        'exit_invalid_recipient',
         'exit_invalid_request',
         'exit_pin_blocked',
         'exit_pin_mismatch',

apps/cic-ussd/cic_ussd/runnable/client.py

@@ -63,7 +63,7 @@ elif ssl == 0:
 else:
     ssl = True
 
-valid_service_codes = config.get('USSD_SERVICE_CODE').split(",")
+
 def main():
 
     # TODO: improve url building 
@@ -79,9 +79,9 @@ def main():
     session = uuid.uuid4().hex
     data = {
             'sessionId': session,
-            'serviceCode': valid_service_codes[0],
+            'serviceCode': config.get('APP_SERVICE_CODE'),
             'phoneNumber': args.phone,
-            'text': "",
+            'text': config.get('APP_SERVICE_CODE'),
         }
 
     state = "_BEGIN"

apps/cic-ussd/cic_ussd/session/ussd_session.py

@@ -146,7 +146,7 @@ def create_ussd_session(
                        )
 
 
-def update_ussd_session(ussd_session: DbUssdSession,
+def update_ussd_session(ussd_session: UssdSession,
                         user_input: str,
                         state: str,
                         data: Optional[dict] = None) -> UssdSession:

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

@@ -154,14 +154,15 @@ def parse_person_metadata(account: Account, metadata: dict):
     phone_number = account.phone_number
     date_registered = int(account.created.replace().timestamp())
     blockchain_address = account.blockchain_address
-    chain_str = Chain.spec.__str__()
+    chain_spec = f'{Chain.spec.common_name()}:{Chain.spec.engine()}: {Chain.spec.chain_id()}'
 
     if isinstance(metadata.get('identities'), dict):
         identities = metadata.get('identities')
     else:
         identities = manage_identity_data(
             blockchain_address=blockchain_address,
-            chain_str=chain_str
+            blockchain_type=Chain.spec.engine(),
+            chain_spec=chain_spec
         )
 
     return {

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

@@ -4,7 +4,6 @@ from typing import Tuple
 
 # third party imports
 import celery
-from phonenumbers.phonenumberutil import NumberParseException
 
 # local imports
 from cic_ussd.account.balance import get_cached_available_balance
@@ -22,21 +21,23 @@ logg = logging.getLogger(__file__)
 
 
 def is_valid_recipient(state_machine_data: Tuple[str, dict, Account, Session]) -> bool:
-    """This function checks that a phone number provided as the recipient of a transaction does not match the sending
+    """This function checks that a user exists, is not the initiator of the transaction, has an active account status
-    party's own phone number.
+    and is authorized to perform  standard transactions.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
-    :return: A recipient account's validity for a transaction
+    :return: A user's validity
     :rtype: bool
     """
     user_input, ussd_session, account, session = state_machine_data
-    try:
+    phone_number = process_phone_number(user_input, E164Format.region)
-        phone_number = process_phone_number(user_input, E164Format.region)
+    session = SessionBase.bind_session(session=session)
-    except NumberParseException:
+    recipient = Account.get_by_phone_number(phone_number=phone_number, session=session)
-        phone_number = None
+    SessionBase.release_session(session=session)
     is_not_initiator = phone_number != account.phone_number
-    is_present = Account.get_by_phone_number(phone_number, session) is not None
+    has_active_account_status = False
-    return phone_number is not None and phone_number.startswith('+') and is_present and is_not_initiator
+    if recipient:
+        has_active_account_status = recipient.get_status(session) == AccountStatus.ACTIVE.name
+    return is_not_initiator and has_active_account_status and recipient is not None
 
 
 def is_valid_transaction_amount(state_machine_data: Tuple[str, dict, Account, Session]) -> bool:

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

@@ -5,6 +5,7 @@ from datetime import timedelta
 
 # third-party imports
 import celery
+from chainlib.hash import strip_0x
 
 # local imports
 from cic_ussd.account.balance import get_balances, calculate_available_balance
@@ -54,7 +55,6 @@ def account_creation_callback(self, result: str, url: str, status_code: int):
     session.add(account)
     session.commit()
     session.close()
-    logg.debug(f'recorded account with identifier: {result}')
 
     queue = self.request.delivery_info.get('routing_key')
     s_phone_pointer = celery.signature(
@@ -86,7 +86,7 @@ def balances_callback(result: list, param: str, status_code: int):
         raise ValueError(f'Unexpected status code: {status_code}.')
 
     balances = result[0]
-    identifier = bytes.fromhex(param)
+    identifier = bytes.fromhex(strip_0x(param))
     key = cache_data_key(identifier, ':cic.balances')
     cache_data(key, json.dumps(balances))
 
@@ -113,10 +113,8 @@ def statement_callback(self, result, param: str, status_code: int):
     for transaction in statement_transactions:
         recipient_transaction, sender_transaction = transaction_actors(transaction)
         if recipient_transaction.get('blockchain_address') == param:
-            recipient_transaction['alt_blockchain_address'] = sender_transaction.get('blockchain_address')
             generate(param, queue, recipient_transaction)
         if sender_transaction.get('blockchain_address') == param:
-            sender_transaction['alt_blockchain_address'] = recipient_transaction.get('blockchain_address')
             generate(param, queue, sender_transaction)
 
 
@@ -140,14 +138,26 @@ def transaction_balances_callback(self, result: list, param: dict, status_code:
     balances_data = result[0]
     available_balance = calculate_available_balance(balances_data)
     transaction = param
+    blockchain_address = param.get('blockchain_address')
     transaction['available_balance'] = available_balance
     queue = self.request.delivery_info.get('routing_key')
 
+    s_preferences_metadata = celery.signature(
+        'cic_ussd.tasks.metadata.query_preferences_metadata', [blockchain_address], queue=queue
+    )
     s_process_account_metadata = celery.signature(
         'cic_ussd.tasks.processor.parse_transaction', [transaction], queue=queue
     )
     s_notify_account = celery.signature('cic_ussd.tasks.notifications.transaction', queue=queue)
-    celery.chain(s_process_account_metadata, s_notify_account).apply_async()
+
+    if param.get('transaction_type') == 'transfer':
+        celery.chain(s_preferences_metadata, s_process_account_metadata, s_notify_account).apply_async()
+
+    if param.get('transaction_type') == 'tokengift':
+        s_process_account_metadata = celery.signature(
+            'cic_ussd.tasks.processor.parse_transaction', [{}, transaction], queue=queue
+        )
+        celery.chain(s_process_account_metadata, s_notify_account).apply_async()
 
 
 @celery_app.task
@@ -174,11 +184,10 @@ def transaction_callback(result: dict, param: str, status_code: int):
     source_token_value = result.get('source_token_value')
 
     recipient_metadata = {
-        "alt_blockchain_address": sender_blockchain_address,
-        "blockchain_address": recipient_blockchain_address,
-        "role": "recipient",
         "token_symbol": destination_token_symbol,
         "token_value": destination_token_value,
+        "blockchain_address": recipient_blockchain_address,
+        "role": "recipient",
         "transaction_type": param
     }
 
@@ -192,11 +201,10 @@ def transaction_callback(result: dict, param: str, status_code: int):
 
     if param == 'transfer':
         sender_metadata = {
-            "alt_blockchain_address": recipient_blockchain_address,
             "blockchain_address": sender_blockchain_address,
-            "role": "sender",
             "token_symbol": source_token_symbol,
             "token_value": source_token_value,
+            "role": "sender",
             "transaction_type": param
         }
 

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

@@ -3,6 +3,7 @@ import logging
 
 # third-party imports
 import celery
+from hexathon import strip_0x
 
 # local imports
 from cic_ussd.metadata import CustomMetadata, PersonMetadata, PhonePointerMetadata, PreferencesMetadata
@@ -20,7 +21,7 @@ def query_person_metadata(blockchain_address: str):
     :return:
     :rtype:
     """
-    identifier = bytes.fromhex(blockchain_address)
+    identifier = bytes.fromhex(strip_0x(blockchain_address))
     person_metadata_client = PersonMetadata(identifier=identifier)
     person_metadata_client.query()
 
@@ -35,14 +36,14 @@ def create_person_metadata(blockchain_address: str, data: dict):
     :return:
     :rtype:
     """
-    identifier = bytes.fromhex(blockchain_address)
+    identifier = bytes.fromhex(strip_0x(blockchain_address))
     person_metadata_client = PersonMetadata(identifier=identifier)
     person_metadata_client.create(data=data)
 
 
 @celery_app.task
 def edit_person_metadata(blockchain_address: str, data: dict):
-    identifier = bytes.fromhex(blockchain_address)
+    identifier = bytes.fromhex(strip_0x(blockchain_address))
     person_metadata_client = PersonMetadata(identifier=identifier)
     person_metadata_client.edit(data=data)
 
@@ -50,21 +51,21 @@ def edit_person_metadata(blockchain_address: str, data: dict):
 @celery_app.task(bind=True, base=CriticalMetadataTask)
 def add_phone_pointer(self, blockchain_address: str, phone_number: str):
     identifier = phone_number.encode('utf-8')
-    stripped_address = blockchain_address
+    stripped_address = strip_0x(blockchain_address)
     phone_metadata_client = PhonePointerMetadata(identifier=identifier)
     phone_metadata_client.create(data=stripped_address)
 
 
 @celery_app.task()
 def add_custom_metadata(blockchain_address: str, data: dict):
-    identifier = bytes.fromhex(blockchain_address)
+    identifier = bytes.fromhex(strip_0x(blockchain_address))
     custom_metadata_client = CustomMetadata(identifier=identifier)
     custom_metadata_client.create(data=data)
 
 
 @celery_app.task()
 def add_preferences_metadata(blockchain_address: str, data: dict):
-    identifier = bytes.fromhex(blockchain_address)
+    identifier = bytes.fromhex(strip_0x(blockchain_address))
     preferences_metadata_client = PreferencesMetadata(identifier=identifier)
     preferences_metadata_client.create(data=data)
 
@@ -75,7 +76,7 @@ def query_preferences_metadata(blockchain_address: str):
     :param blockchain_address: Blockchain address of an account.
     :type blockchain_address: str | Ox-hex
     """
-    identifier = bytes.fromhex(blockchain_address)
+    identifier = bytes.fromhex(strip_0x(blockchain_address))
     logg.debug(f'Retrieving preferences metadata for address: {blockchain_address}.')
     person_metadata_client = PreferencesMetadata(identifier=identifier)
     return person_metadata_client.query()

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

@@ -24,14 +24,12 @@ def transaction(notification_data: dict):
     :rtype:
     """
     role = notification_data.get('role')
-    token_value = notification_data.get('token_value')
+    amount = from_wei(notification_data.get('token_value'))
-    amount = token_value if token_value == 0 else from_wei(token_value)
     balance = notification_data.get('available_balance')
     phone_number = notification_data.get('phone_number')
     preferred_language = notification_data.get('preferred_language')
     token_symbol = notification_data.get('token_symbol')
-    alt_metadata_id = notification_data.get('alt_metadata_id')
+    transaction_account_metadata = notification_data.get('metadata_id')
-    metadata_id = notification_data.get('metadata_id')
     transaction_type = notification_data.get('transaction_type')
     timestamp = datetime.datetime.now().strftime('%d-%m-%y, %H:%M %p')
 
@@ -49,8 +47,7 @@ def transaction(notification_data: dict):
                                            preferred_language=preferred_language,
                                            amount=amount,
                                            token_symbol=token_symbol,
-                                           tx_recipient_information=metadata_id,
+                                           tx_sender_information=transaction_account_metadata,
-                                           tx_sender_information=alt_metadata_id,
                                            timestamp=timestamp,
                                            balance=balance)
         if role == 'sender':
@@ -59,7 +56,6 @@ def transaction(notification_data: dict):
                                            preferred_language=preferred_language,
                                            amount=amount,
                                            token_symbol=token_symbol,
-                                           tx_recipient_information=alt_metadata_id,
+                                           tx_recipient_information=transaction_account_metadata,
-                                           tx_sender_information=metadata_id,
                                            timestamp=timestamp,
                                            balance=balance)

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

@@ -5,13 +5,12 @@ import logging
 # third-party imports
 import celery
 import i18n
+from chainlib.hash import strip_0x
 
 # local imports
-from cic_ussd.account.metadata import get_cached_preferred_language
 from cic_ussd.account.statement import get_cached_statement
 from cic_ussd.account.transaction import aux_transaction_data, validate_transaction_account
 from cic_ussd.cache import cache_data, cache_data_key
-from cic_ussd.db.models.account import Account
 from cic_ussd.db.models.base import SessionBase
 
 
@@ -23,13 +22,17 @@ logg = logging.getLogger(__file__)
 def generate_statement(self, querying_party: str, transaction: dict):
     """"""
     queue = self.request.delivery_info.get('routing_key')
+
+    s_preferences = celery.signature(
+        'cic_ussd.tasks.metadata.query_preferences_metadata', [querying_party], queue=queue
+    )
     s_parse_transaction = celery.signature(
         'cic_ussd.tasks.processor.parse_transaction', [transaction], queue=queue
     )
     s_cache_statement = celery.signature(
         'cic_ussd.tasks.processor.cache_statement', [querying_party], queue=queue
     )
-    celery.chain(s_parse_transaction, s_cache_statement).apply_async()
+    celery.chain(s_preferences, s_parse_transaction, s_cache_statement).apply_async()
 
 
 @celery_app.task
@@ -48,38 +51,34 @@ def cache_statement(parsed_transaction: dict, querying_party: str):
         statement_transactions = json.loads(cached_statement)
     statement_transactions.append(parsed_transaction)
     data = json.dumps(statement_transactions)
-    identifier = bytes.fromhex(querying_party)
+    identifier = bytes.fromhex(strip_0x(querying_party))
     key = cache_data_key(identifier, ':cic.statement')
     cache_data(key, data)
 
 
 @celery_app.task
-def parse_transaction(transaction: dict) -> dict:
+def parse_transaction(preferences: dict, transaction: dict) -> dict:
     """This function parses transaction objects and collates all relevant data for system use i.e:
     - An account's set preferred language.
     - Account identifier that facilitates notification.
     - Contextual tags i.e action and direction tags.
+    :param preferences: An account's set preferences.
+    :type preferences: dict
     :param transaction: Transaction object.
     :type transaction: dict
     :return: Transaction object with contextual data for use in the system.
     :rtype: dict
     """
-    preferred_language = get_cached_preferred_language(transaction.get('blockchain_address'))
+    preferred_language = preferences.get('preferred_language')
     if not preferred_language:
         preferred_language = i18n.config.get('fallback')
-    transaction['preferred_language'] = preferred_language
+
     transaction = aux_transaction_data(preferred_language, transaction)
     session = SessionBase.create_session()
-    role = transaction.get('role')
+    account = validate_transaction_account(session, transaction)
-    alt_blockchain_address = transaction.get('alt_blockchain_address')
+    metadata_id = account.standard_metadata_id()
-    blockchain_address = transaction.get('blockchain_address')
+    transaction['metadata_id'] = metadata_id
-    account = validate_transaction_account(blockchain_address, role, session)
-    alt_account = session.query(Account).filter_by(blockchain_address=alt_blockchain_address).first()
-    if alt_account:
-        transaction['alt_metadata_id'] = alt_account.standard_metadata_id()
-    else:
-        transaction['alt_metadata_id'] = 'GRASSROOTS ECONOMICS'
-    transaction['metadata_id'] = account.standard_metadata_id()
     transaction['phone_number'] = account.phone_number
+    session.commit()
     session.close()
     return transaction