.coveragerc

@@ -0,0 +1,2 @@
+[report]
+omit = 

.drone.yml

@@ -0,0 +1,65 @@
+---
+################
+# Test #
+################
+
+kind: pipeline
+name: default
+type: docker
+
+steps:
+  # Run tests against Python with pytest
+  - name: test
+    image: python:3.8
+    commands:
+      # Install dependencies
+      - pip install poetry
+      - poetry install -E eth
+      - poetry run pylint cic --fail-under=8.00
+      - poetry run pytest
+    environment:
+      LOGLEVEL: info
+
+    volumes:
+      - name: poetry_cache
+        path: /root/.cache/pypoetry
+      - name: pip_cache
+        path: /root/.cache/pip
+    when:
+      event:
+        - push
+  - name: publish
+    image: python:3.8
+    commands:
+      # Install dependencies
+      - pip install poetry
+      - poetry install
+      - poetry run semantic-release publish
+    depends_on:
+      - test
+    when:
+      branch:
+        - master
+      event:
+        - push
+    environment:
+      LOGLEVEL: info
+      GIT_SSL_NO_VERIFY: 1
+      REPOSITORY_USERNAME: __token__
+      REPOSITORY_PASSWORD:
+        from_secret: pypi_token
+      GITEA_TOKEN:
+        from_secret: gitea_token
+
+    volumes:
+      - name: poetry_cache
+        path: /root/.cache/pypoetry
+      - name: pip_cache
+        path: /root/.cache/pip
+volumes:
+  - name: poetry_cache
+    host:
+      path: /tmp/cache/drone/pypoetry
+  - name: pip_cache
+    host:
+      path: /tmp/cache/drone/pip

.gitignore

@@ -1,3 +1,12 @@
 __pycache__
 *.pyc
 *.egg-info
+.venv
+build/
+.vscode
+.idea
+contracts
+*.egg
+.coverage
+deployments/
+dist/

.pylintrc

@@ -0,0 +1,402 @@
+[MASTER]
+
+# Specify a configuration file.
+#rcfile=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Add files or directories to the blacklist. They should be base names, not
+# paths.
+ignore=third_party
+
+# Add files or directories matching the regex patterns to the blacklist. The
+# regex matches against base names, not paths.
+ignore-patterns=object_detection_grpc_client.py,prediction_pb2.py,prediction_pb2_grpc.py
+
+# Pickle collected data for later comparisons.
+persistent=no
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Use multiple processes to speed up Pylint.
+jobs=4
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code
+extension-pkg-whitelist=
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
+confidence=
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+#enable=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once).You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use"--disable=all --enable=classes
+# --disable=W"
+#
+# Kubeflow disables string-interpolation because we are starting to use f
+# style strings
+disable=import-star-module-level,old-octal-literal,oct-method,print-statement,unpacking-in-except,parameter-unpacking,backtick,old-raise-syntax,old-ne-operator,long-suffix,dict-view-method,dict-iter-method,metaclass-assignment,next-method-called,raising-string,indexing-exception,raw_input-builtin,long-builtin,file-builtin,execfile-builtin,coerce-builtin,cmp-builtin,buffer-builtin,basestring-builtin,apply-builtin,filter-builtin-not-iterating,using-cmp-argument,useless-suppression,range-builtin-not-iterating,suppressed-message,missing-docstring,no-absolute-import,old-division,cmp-method,reload-builtin,zip-builtin-not-iterating,intern-builtin,unichr-builtin,reduce-builtin,standarderror-builtin,unicode-builtin,xrange-builtin,coerce-method,delslice-method,getslice-method,setslice-method,input-builtin,round-builtin,hex-method,nonzero-method,map-builtin-not-iterating,relative-import,invalid-name,bad-continuation,no-member,locally-disabled,fixme,import-error,too-many-locals,no-name-in-module,too-many-instance-attributes,no-self-use,logging-fstring-interpolation
+
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html. You can also give a reporter class, eg
+# mypackage.mymodule.MyReporterClass.
+output-format=text
+
+# Put messages in a separate file for each module / package specified on the
+# command line instead of printing them on stdout. Reports (if any) will be
+# written in a file name "pylint_global.[txt|html]". This option is deprecated
+# and it will be removed in Pylint 2.0.
+files-output=no
+
+# Tells whether to display a full report or only the messages
+reports=no
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details
+#msg-template=
+
+
+[BASIC]
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=i,j,k,ex,Run,_
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=foo,bar,baz,toto,tutu,tata
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Include a hint for the correct naming format with invalid-name
+include-naming-hint=no
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+property-classes=abc.abstractproperty
+
+# Regular expression matching correct function names
+function-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for function names
+function-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct variable names
+variable-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for variable names
+variable-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct constant names
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Naming hint for constant names
+const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Regular expression matching correct attribute names
+attr-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for attribute names
+attr-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct argument names
+argument-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for argument names
+argument-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression matching correct class attribute names
+class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
+
+# Naming hint for class attribute names
+class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
+
+# Regular expression matching correct inline iteration names
+inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
+
+# Naming hint for inline iteration names
+inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$
+
+# Regular expression matching correct class names
+class-rgx=[A-Z_][a-zA-Z0-9]+$
+
+# Naming hint for class names
+class-name-hint=[A-Z_][a-zA-Z0-9]+$
+
+# Regular expression matching correct module names
+module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Naming hint for module names
+module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Regular expression matching correct method names
+method-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Naming hint for method names
+method-name-hint=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+
+[ELIF]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+
+[TYPECHECK]
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=140
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+# List of optional constructs for which whitespace checking is disabled. `dict-
+# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
+# `trailing-comma` allows a space between comma and closing bracket: (a, ).
+# `empty-line` allows space-only lines.
+no-space-check=trailing-comma,dict-separator
+
+# Maximum number of lines in a module
+max-module-lines=1000
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+# Use 2 spaces consistent with TensorFlow style.
+indent-string='    '
+
+# Number of spaces of indent required inside a hanging  or continued line.
+indent-after-paren=4
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,XXX,TODO
+
+
+[VARIABLES]
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# A regular expression matching the name of dummy variables (i.e. expectedly
+# not used).
+dummy-variables-rgx=(_+[a-zA-Z0-9]*?$)|dummy
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,_cb
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,future.builtins
+
+
+[LOGGING]
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format
+logging-modules=logging
+
+
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+
+[SPELLING]
+
+# Spelling dictionary name. Available dictionaries: none. To make it working
+# install python-enchant package.
+spelling-dict=
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to indicated private dictionary in
+# --spelling-private-dict-file option instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=regsub,TERMIOS,Bastion,rexec
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+
+[DESIGN]
+
+# Maximum number of arguments for function / method
+max-args=7
+
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore
+ignored-argument-names=_.*
+
+# Maximum number of locals for function / method body
+max-locals=15
+
+# Maximum number of return / yield for function / method body
+max-returns=6
+
+# Maximum number of branch for function / method body
+max-branches=12
+
+# Maximum number of statements in function / method body
+max-statements=50
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=0
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of boolean expressions in a if statement
+max-bool-expr=5
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,__new__,setUp
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,_fields,_replace,_source,_make
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception"
+overgeneral-exceptions=Exception

cic/__init__.py

@@ -1,2 +1 @@
-from .proof import Proof
+__version__ = "0.0.2"
-from .processor import Processor

cic/cmd/export.py

@@ -1,39 +1,51 @@
 # standard imports
-import logging
 import importlib
+import logging
 import os
+from typing import Optional
 
 # external imports
 from cic_types.ext.metadata import MetadataRequestsHandler
 from cic_types.ext.metadata.signer import Signer as MetadataSigner
 
 # local imports
-from cic import (
+from cic.contract.processor import ContractProcessor
-        Proof,
+from cic.contract.components.proof import Proof
-        Processor,
+from cic.contract.components.attachment import Attachment
-        )
+from cic.contract.components.meta import Meta
-from cic.output import (
+from cic.contract.network import Network
-        HTTPWriter,
+from cic.contract.components.token import Token
-        KeyedWriterFactory,
+from cic.writers import HTTPWriter, KeyedWriterFactory, MetadataWriter
-        )
-from cic.meta import (
-        Meta,
-        MetadataWriter,
-        )
-from cic.attachment import Attachment
-from cic.network import Network
-from cic.token import Token
 
 logg = logging.getLogger(__name__)
 
 
 def process_args(argparser):
-    argparser.add_argument('-d', '--directory', type=str, dest='directory', default='.', help='directory')
+    argparser.add_argument(
-    argparser.add_argument('-o', '--output-directory', type=str, dest='output_directory', help='output directory')
+        "-d", "--directory", type=str, dest="directory", default=".", help="directory"
-    argparser.add_argument('--metadata-endpoint', dest='metadata_endpoint', type=str, help='metadata endpoint to interact with')
+    )
-    argparser.add_argument('-y', '--signer', type=str, dest='y', help='target-specific signer to use for export')
+    argparser.add_argument(
-    argparser.add_argument('-p', type=str, help='RPC endpoint')
+        "-o",
-    argparser.add_argument('target', type=str, help='target network type')
+        "--output-directory",
+        type=str,
+        dest="output_directory",
+        help="output directory",
+    )
+    argparser.add_argument(
+        "--metadata-endpoint",
+        dest="metadata_endpoint",
+        type=str,
+        help="metadata endpoint to interact with",
+    )
+    argparser.add_argument(
+        "-y",
+        "--signer",
+        type=str,
+        dest="y",
+        help="target-specific signer to use for export",
+    )
+    argparser.add_argument("-p", type=str, help="RPC endpoint")
+    argparser.add_argument("target", type=str, help="target network type")
 
 
 def validate_args(args):
@@ -42,14 +54,14 @@ def validate_args(args):
 
 def init_writers_from_config(config):
     w = {
-            'meta': None,
+        "meta": None,
-            'attachment': None,
+        "attachment": None,
-            'proof': None,
+        "proof": None,
-            'ext': None,
+        "ext": None,
     }
     for v in w.keys():
-        k = 'CIC_CORE_{}_WRITER'.format(v.upper())
+        k = "CIC_CORE_{}_WRITER".format(v.upper())
-        (d, c) = config.get(k).rsplit('.', maxsplit=1)
+        (d, c) = config.get(k).rsplit(".", maxsplit=1)
         m = importlib.import_module(d)
         o = getattr(m, c)
         w[v] = o
@@ -57,8 +69,17 @@ def init_writers_from_config(config):
     return w
 
 
-def execute(config, eargs):
+ExtraArgs = {
-    modname = 'cic.ext.{}'.format(eargs.target)
+    "target": str,
+    "directory": str,
+    "output_directory": str,
+    "metadata_endpoint": Optional[str],
+    "y": str,
+}
+
+
+def execute(config, eargs: ExtraArgs):
+    modname = f"cic.ext.{eargs.target}"
     cmd_mod = importlib.import_module(modname)
 
     writers = init_writers_from_config(config)
@@ -66,18 +87,26 @@ def execute(config, eargs):
     output_writer_path_meta = eargs.output_directory
     if eargs.metadata_endpoint != None:
         MetadataRequestsHandler.base_url = eargs.metadata_endpoint
-        MetadataSigner.gpg_path = os.path.join('/tmp')
+        MetadataSigner.gpg_path = os.path.join("/tmp")
-        MetadataSigner.key_file_path = '/home/lash/src/client/cic/grassrootseconomics/cic-internal-integration/apps/cic-ussd/tests/data/pgp/privatekeys_meta.asc'
+        MetadataSigner.key_file_path = config.get("AUTH_KEYFILE_PATH")
-        MetadataSigner.gpg_passphrase = 'merman'
+        MetadataSigner.gpg_passphrase = config.get("AUTH_PASSPHRASE")
-        writers['proof'] = KeyedWriterFactory(MetadataWriter, HTTPWriter).new
+        writers["proof"] = KeyedWriterFactory(MetadataWriter, HTTPWriter).new
-        writers['attachment'] = KeyedWriterFactory(None, HTTPWriter).new
+        writers["attachment"] = KeyedWriterFactory(None, HTTPWriter).new
-        writers['meta'] = MetadataWriter
+        writers["meta"] = MetadataWriter
         output_writer_path_meta = eargs.metadata_endpoint
 
     ct = Token(path=eargs.directory)
-    cm = Meta(path=eargs.directory, writer=writers['meta'](path=output_writer_path_meta))
+    cm = Meta(
-    ca = Attachment(path=eargs.directory, writer=writers['attachment'](path=output_writer_path_meta))
+        path=eargs.directory, writer=writers["meta"](path=output_writer_path_meta)
-    cp = Proof(path=eargs.directory, attachments=ca, writer=writers['proof'](path=output_writer_path_meta))
+    )
+    ca = Attachment(
+        path=eargs.directory, writer=writers["attachment"](path=output_writer_path_meta)
+    )
+    cp = Proof(
+        path=eargs.directory,
+        attachments=ca,
+        writer=writers["proof"](path=output_writer_path_meta),
+    )
     cn = Network(path=eargs.directory)
 
     ca.load()
@@ -88,20 +117,29 @@ def execute(config, eargs):
 
     chain_spec = None
     try:
-        chain_spec = config.get('CHAIN_SPEC')
+        chain_spec = config.get("CHAIN_SPEC")
     except KeyError:
         chain_spec = cn.chain_spec
-        config.add(chain_spec, 'CHAIN_SPEC', exists_ok=True)
+        config.add(chain_spec, "CHAIN_SPEC", exists_ok=True)
-        logg.debug('CHAIN_SPEC config set to {}'.format(str(chain_spec)))
+        logg.debug(f"CHAIN_SPEC config set to {str(chain_spec)}")
 
     # signer = cmd_mod.parse_signer(eargs.y)
     (rpc, signer) = cmd_mod.parse_adapter(config, eargs.y)
 
     ref = cn.resource(eargs.target)
     chain_spec = cn.chain_spec(eargs.target)
-    logg.debug('found reference {} chain spec {} for target {}'.format(ref['contents'], chain_spec, eargs.target))
+    logg.debug(
-    c = getattr(cmd_mod, 'new')(chain_spec, ref['contents'], cp, signer_hint=signer, rpc=rpc, outputs_writer=writers['ext'](path=eargs.output_directory))
+        f"found reference {ref['contents']} chain spec {chain_spec} for target {eargs.target}"
+    )
+    c = getattr(cmd_mod, "new")(
+        chain_spec,
+        ref["contents"],
+        cp,
+        signer_hint=signer,
+        rpc=rpc,
+        outputs_writer=writers["ext"](path=eargs.output_directory),
+    )
     c.apply_token(ct)
 
-    p = Processor(proof=cp, attachment=ca, metadata=cm, extensions=[c])
+    p = ContractProcessor(proof=cp, attachment=ca, metadata=cm, extensions=[c])
     p.process()

cic/cmd/ext.py

@@ -3,16 +3,21 @@ import importlib
 
 # external imports
 from chainlib.chain import ChainSpec
+
 # local imports
-from cic.network import Network
+from cic.contract.network import Network
 
 
 def process_args(argparser):
-    argparser.add_argument('--registry', required=True, type=str, help='contract registry address')
+    argparser.add_argument(
-    argparser.add_argument('-d', '--directory', type=str, dest='directory', default='.', help='directory')
+        "--registry", type=str, help="contract registry address"
-    argparser.add_argument('-p', type=str, help='RPC endpoint')
+    )
-    argparser.add_argument('-i', type=str, help='chain spec string')
+    argparser.add_argument(
-    argparser.add_argument('target', help='target to initialize')
+        "-d", "--directory", type=str, dest="directory", default=".", help="directory"
+    )
+    argparser.add_argument("-p", type=str, help="RPC endpoint")
+    argparser.add_argument("-i", type=str, help="chain spec string")
+    argparser.add_argument("target", help="target to initialize")
 
 
 def validate_args(args):
@@ -23,8 +28,11 @@ def execute(config, eargs):
     cn = Network(eargs.directory, targets=eargs.target)
     cn.load()
 
-
+    chain_spec = ChainSpec.from_chain_str(eargs.i or config.get("CHAIN_SPEC"))
-    chain_spec = ChainSpec.from_chain_str(eargs.i)
+    m = importlib.import_module(f"cic.ext.{eargs.target}.start")
-    m = importlib.import_module('cic.ext.{}.start'.format(eargs.target))
+    m.extension_start(
-    m.extension_start(cn, registry_address=eargs.registry, chain_spec=chain_spec, rpc_provider=config.get('RPC_PROVIDER'))
+        cn,
-
+        registry_address=eargs.registry or config.get("CIC_REGISTRY_ADDRESS"),
+        chain_spec=chain_spec,
+        rpc_provider=config.get("RPC_PROVIDER"),
+    ) # TODO add key account address

cic/cmd/init.py

@@ -3,21 +3,27 @@ import logging
 import os
 
 # local imports
-from cic import Proof
+from cic.contract.components.proof import Proof
-from cic.meta import Meta
+from cic.contract.components.meta import Meta
-from cic.attachment import Attachment
+from cic.contract.components.attachment import Attachment
-from cic.network import Network
+from cic.contract.network import Network
-from cic.token import Token
+from cic.contract.components.token import Token
 
 logg = logging.getLogger(__name__)
 
 
 def process_args(argparser):
-    argparser.add_argument('--target', action='append', type=str, default=[], help='initialize network specification file with target')
+    argparser.add_argument(
-    argparser.add_argument('--name', type=str, help='token name')
+        "--target",
-    argparser.add_argument('--symbol', type=str, help='token symbol')
+        action="append",
-    argparser.add_argument('--precision', type=str, help='token unit precision')
+        type=str,
-    argparser.add_argument('directory', help='directory to initialize')
+        default=[],
+        help="initialize network specification file with target",
+    )
+    argparser.add_argument("--name", type=str, help="token name")
+    argparser.add_argument("--symbol", type=str, help="token symbol")
+    argparser.add_argument("--precision", type=str, help="token unit precision")
+    argparser.add_argument("directory", help="directory to initialize")
 
 
 def validate_args(args):
@@ -25,11 +31,13 @@ def validate_args(args):
 
 
 def execute(config, eargs):
-    logg.info('initializing in {}'.format(eargs.directory))
+    logg.info("initializing in {}".format(eargs.directory))
 
     os.makedirs(eargs.directory)
 
-    ct = Token(eargs.directory, name=eargs.name, symbol=eargs.symbol, precision=eargs.precision)
+    ct = Token(
+        eargs.directory, name=eargs.name, symbol=eargs.symbol, precision=eargs.precision
+    )
     cp = Proof(eargs.directory)
     cm = Meta(eargs.directory)
     ca = Attachment(eargs.directory)

cic/cmd/show.py

@@ -1,14 +1,21 @@
 # local imports
-from cic import Proof
+from cic.contract.components.proof import Proof
-from cic.meta import Meta
+from cic.contract.components.meta import Meta
-from cic.attachment import Attachment
+from cic.contract.components.attachment import Attachment
-from cic.network import Network
+from cic.contract.network import Network
-from cic.token import Token
+from cic.contract.components.token import Token
 
 
 def process_args(argparser):
-    argparser.add_argument('-f', '--file', type=str, help='add file')
+    argparser.add_argument("-f", "--file", type=str, help="add file")
-    argparser.add_argument('-d', '--directory', type=str, dest='directory', default='.', help='cic data directory')
+    argparser.add_argument(
+        "-d",
+        "--directory",
+        type=str,
+        dest="directory",
+        default=".",
+        help="cic data directory",
+    )
 
 
 def validate_args(args):
@@ -28,8 +35,12 @@ def execute(config, eargs):
     ca.load()
     cn.load()
 
-    print("""[cic.header]
+    print(
-version = {}\n""".format(cp.version()))
+        """[cic.header]
+version = {}\n""".format(
+            cp.version()
+        )
+    )
     print("[cic.token]\n{}".format(ct))
     print("[cic.proof]\n{}".format(cp))
     print("[cic.meta]\n{}".format(cm))

cic/cmd/wizard.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+# standard import
+import logging
+
+from chainlib.cli.config import Config
+
+# local imports
+from cic.contract.contract import deploy_contract, generate_contract, load_contract
+
+log = logging.getLogger(__name__)
+
+
+def process_args(argparser):
+    argparser.add_argument(
+        "--skip-gen", action="store_true", default=False, help="Skip Generation"
+    )
+    argparser.add_argument(
+        "--skip-deploy",
+        action="store_true",
+        help="Skip Deployment",
+    )
+    argparser.add_argument(
+        "--target",
+        default="eth",
+        help="Contract Target (eth)",
+    )
+    argparser.add_argument(
+        "path",
+        type=str,
+        help="Path to generate/use contract deployment info",
+    )
+    argparser.add_argument(
+        "-p",
+        type=str,
+        help="RPC Provider (http://localhost:8545)",
+    )
+    argparser.add_argument(
+        "-y",
+        type=str,
+        help="Wallet Keystore",
+    )
+
+
+def validate_args(_args):
+    pass
+
+
+ExtraArgs = {"skip_gen": str, "skip_deploy": str, "target": str, "path": str, "p": str}
+
+
+def execute(config: Config, eargs: ExtraArgs):
+    directory = eargs.path
+    target = eargs.target
+    skip_gen = eargs.skip_gen
+    skip_deploy = eargs.skip_deploy
+    wallet_keystore = eargs.y
+    if wallet_keystore:
+        config.add(wallet_keystore, "WALLET_KEY_FILE", exists_ok=True)
+
+    if not skip_gen:
+        contract = generate_contract(directory, [target], config, interactive=True)
+    else:
+        contract = load_contract(directory)
+
+    print(contract)
+
+    print(f"Meta: {config.get('META_URL')}")
+    print(f"ChainSpec: {config.get('CHAIN_SPEC', contract.network.chain_spec(target))}")
+    print(f"RPC: {config.get('RPC_PROVIDER')}\n")
+
+    if not skip_deploy:
+        ready_to_deploy = input("Are you ready to Deploy? (y/n): ")
+        if ready_to_deploy == "y":
+            deploy_contract(
+                config=config,
+                contract_directory=directory,
+                target=target,
+            )
+            print("Deployed")
+        else:
+            print("Skipping deployment")
+
+
+if __name__ == "__main__":
+    # execute()
+    print("Not Implemented")

cic/contract/base.py

@@ -3,7 +3,7 @@ import os
 import hashlib
 
 
-mod_dir = os.path.dirname(os.path.realpath(__file__))
+mod_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')
 root_dir = os.path.join(mod_dir, '..')
 data_dir = os.path.join(mod_dir, 'data')
 schema_dir = os.path.join(mod_dir, 'schema')

cic/contract/components/attachment.py

@@ -1,9 +1,9 @@
 # standard imports
-import os
 import logging
+import os
 
 # local imports
-from .base import *
+from cic.contract.base import Data, data_dir
 
 logg = logging.getLogger(__name__)
 
@@ -14,38 +14,39 @@ class Attachment(Data):
     :param path: Path to settings directory
     :type path: str
     :param writer: Writer interface receiving the output of the processor
-    :type writer: cic.output.OutputWriter
+    :type writer: cic.writers.OutputWriter
     """
-    def __init__(self, path='.', writer=None):
+
+    def __init__(self, path=".", writer=None, interactive=False):
         super(Attachment, self).__init__()
         self.contents = {}
         self.path = path
         self.writer = writer
-        self.attachment_path = os.path.join(self.path, 'attachments')
+        self.attachment_path = os.path.join(self.path, "attachments")
-
+        if interactive:
+            self.start()
+            input(
+                f"Please add attachment files to '{os.path.abspath(os.path.join(self.path,'attachments'))}' and then press ENTER to continue"
+            )
+            self.load()
 
     def load(self):
-        """Loads attachment data from settings.
+        """Loads attachment data from settings."""
-        """
         for s in os.listdir(self.attachment_path):
             fp = os.path.realpath(os.path.join(self.attachment_path, s))
-            f = open(fp, 'rb')
+            with open(fp, "rb") as f:
                 r = f.read()
-            f.close()
 
             z = self.hash(r).hex()
             self.contents[z] = fp
 
-            logg.debug('loaded attachment file {} digest {}'.format(fp, z))
+            logg.debug(f"loaded attachment file {fp} digest {z}")
-
 
     def start(self):
-        """Initialize attachment settings from template.
+        """Initialize attachment settings from template."""
-        """
         super(Attachment, self).start()
         os.makedirs(self.attachment_path)
 
-
     def get(self, k):
         """Get a single attachment by the sha256 hash of the content.
 
@@ -54,13 +55,10 @@ class Attachment(Data):
         """
         return self.contents[k]
 
-
     def asdict(self):
-        """Output attachment state to dict
+        """Output attachment state to dict"""
-        """
         return self.contents
 
-
     def process(self, token_address=None, token_symbol=None, writer=None):
         """Serialize and publish attachments.
 
@@ -69,18 +67,16 @@ class Attachment(Data):
         if writer == None:
             writer = self.writer
 
-        for k in self.contents.keys():
+        for key, value in self.contents.items():
-            fp = os.path.join(self.attachment_path, self.contents[k])
+            fp = os.path.join(self.attachment_path, value)
-            f = open(fp, 'rb')
+            with open(fp, "rb") as f:
-            v = f.read()
+                data = f.read()
-            f.close()
+            logg.debug(f"writing attachment {key}")
-            logg.debug('writing attachment {}'.format(k))
+            writer.write(key, data)
-            writer.write(k, v)
-
 
     def __str__(self):
-        s = ''
+        s = ""
-        for k in self.contents.keys():
+        for key, value in self.contents.items():
-            s += '{} = {}\n'.format(k, self.contents[k]) #self.digests[i].hex(), self.contents[i])
+            s += f"{key} = {value}\n"  # self.digests[i].hex(), self.contents[i])
 
         return s

cic/contract/components/meta.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+# standard imports
+import os
+import json
+import logging
+
+# external imports
+from cic_types import MetadataPointer
+from cic_types.processor import generate_metadata_pointer
+from hexathon import strip_0x
+
+# local imports
+from cic.contract.base import Data, data_dir
+from cic.utils import object_to_str
+
+logg = logging.getLogger(__name__)
+
+
+class Meta(Data):
+    """Serialize and publish metadata for token.
+
+    The token metadata is any mutable data that is not part of the initial token proof, but published simultaneously as the token nonetheless.
+
+    :param path: Path to settings directory
+    :type path: str
+    :param writer: Writer interface receiving the output of the processor
+    :type writer: cic.writers.OutputWriter
+    """
+
+    def __init__(
+        self, path=".", writer=None, name="", location="", country_code="KE", contact={}, interactive=False
+    ):
+        super(Meta, self).__init__()
+        self.name = name
+        self.contact = contact
+        self.country_code = country_code
+        self.location = location
+        self.path = path
+        self.writer = writer
+        self.meta_path = os.path.join(self.path, "meta.json")
+
+        if interactive:
+            self.name = input(f"Enter Metadata Name ({self.name}): ") or self.name
+            self.country_code = input(f"Enter Metadata Country Code ({self.country_code}): ") or self.country_code
+            self.location = input(f"Enter Metadata Location ({self.location}): ") or self.location
+            
+            adding_contact_info = True
+            contact = {}
+            while adding_contact_info:
+                value = input("Enter Metadata contact info (e.g 'phone: +254723522718'): ") or None
+                if value:
+                    data = value.split(":")
+                    if len(data) != 2:
+                        print("Invalid contact info, you must enter in the format 'key: value'")
+                        continue
+                    contact[data[0].strip()] = data[1].strip()
+                else:
+                    adding_contact_info = False
+            self.contact = contact
+
+    def load(self):
+        """Load metadata from settings."""
+        super(Meta, self).load()
+
+        f = open(self.meta_path, "r", encoding="utf-8")
+        o = json.load(f)
+        f.close()
+
+        self.name = o["name"]
+        self.contact = o["contact"]
+        self.country_code = o["country_code"]
+        self.location = o["location"]
+        self.inited = True
+
+    def start(self):
+        """Initialize metadata settings from template."""
+        super(Meta, self).start()
+
+        meta_template_file_path = os.path.join(
+            data_dir, f"meta_template_v{self.version()}.json"
+        )
+
+        f = open(meta_template_file_path, encoding="utf-8")
+        o = json.load(f)
+        f.close()
+
+        o["name"] = self.name
+        o["contact"] = self.contact
+        o["country_code"] = self.country_code
+        o["location"] = self.location
+
+        f = open(self.meta_path, "w", encoding="utf-8")
+        json.dump(o, f, sort_keys=True, indent="\t")
+        f.close()
+
+    def reference(self, token_address):
+        """Calculate the mutable reference for the token metadata."""
+        token_address_bytes = bytes.fromhex(strip_0x(token_address))
+        return generate_metadata_pointer(
+            token_address_bytes, MetadataPointer.TOKEN_META
+        )
+
+    def asdict(self):
+        """Output proof state to dict."""
+        return {
+            "name": self.name,
+            "country_code": self.country_code,
+            "location": self.location,
+            "contact": self.contact,
+        }
+
+    def process(self, token_address=None, token_symbol=None, writer=None):
+        """Serialize and publish metadata.
+
+        See cic.processor.Processor.process
+        """
+        if writer is None:
+            writer = self.writer
+
+        v = json.dumps(self.asdict(), separators=(",", ":"))
+
+        token_address_bytes = bytes.fromhex(strip_0x(token_address))
+        k = generate_metadata_pointer(token_address_bytes, MetadataPointer.TOKEN_META)
+        writer.write(k, v.encode("utf-8"))
+
+        token_symbol_bytes = token_symbol.encode("utf-8")
+        k = generate_metadata_pointer(
+            token_symbol_bytes, MetadataPointer.TOKEN_META_SYMBOL
+        )
+        writer.write(k, v.encode("utf-8"))
+
+        return (k, v)
+
+    def __str__(self):
+        return object_to_str(self, ["name", "contact", "country_code", "location"])
+

cic/contract/components/proof.py

@@ -0,0 +1,192 @@
+# standard imports
+import json
+import logging
+import os
+import tempfile
+
+# external imports
+from hexathon import strip_0x
+from cic_types import MetadataPointer
+from cic_types.processor import generate_metadata_pointer
+
+# local imports
+from cic.contract.base import Data, data_dir
+from cic.utils import object_to_str
+
+
+logg = logging.getLogger(__name__)
+
+
+class Proof(Data):
+    """Proof handles the immutable token proof data mapped to the initial token deployment.
+
+    It processes inputs from the proof.json file in the session directory.
+
+    Optionally, attachment objects can be added to the proof. If added, the resulting proof digest will consists of the attachment digests added to the root digest. These are then are deterministically ordered, regardless of which order attachments were given to the constructor.
+
+    :param path: Path to settings directory
+    :type path: str
+    :param attachments: List of attachment objects to include in the proof
+    :type attachments: cic.attachment.Attachment
+    :param writer: Writer interface receiving the output of the processor
+    :type writer: cic.writers.OutputWriter
+    """
+
+    def __init__(
+        self,
+        path=".",
+        description="",
+        namespace="ge",
+        issuer="",
+        attachments=None,
+        writer=None,
+        interactive=False,
+    ):
+        super(Proof, self).__init__()
+        self.proofs = []
+        self.namespace = namespace
+        self.description = description
+        self.issuer = issuer
+        self.path = path
+        self.writer = writer
+        self.extra_attachments = attachments
+        self.attachments = {}
+        self.proof_path = os.path.join(self.path, "proof.json")
+        self.temp_proof_path = tempfile.mkstemp()[1]
+
+        if interactive:
+            self.description = (
+                input(f"Enter Proof Description ({self.description}): ") or self.description
+            )
+            self.namespace = (
+                input(f"Enter Proof Namespace ({self.namespace}): ") or self.namespace
+            )
+            self.issuer = input(f"Enter Proof Issuer ({self.issuer}): ") or self.issuer
+
+    def load(self):
+        """Load proof data from settings."""
+        super(Proof, self).load()
+
+        f = open(self.proof_path, "r")
+        o = json.load(f)
+        f.close()
+
+        self.set_version(o["version"])
+        self.description = o["description"]
+        self.namespace = o["namespace"]
+        self.issuer = o["issuer"]
+        self.proofs = o["proofs"]
+
+        if self.extra_attachments != None:
+            a = self.extra_attachments.asdict()
+            for k in a.keys():
+                self.attachments[k] = a[k]
+
+        hshs = self.__get_ordered_hashes()
+        self.proofs = list(map(strip_0x, hshs))
+
+        self.inited = True
+
+    def start(self):
+        """Initialize proof settings from template."""
+        super(Proof, self).start()
+
+        proof_template_file_path = os.path.join(
+            data_dir, f"proof_template_v{self.version()}.json"
+        )
+
+        with open(proof_template_file_path, "r", encoding="utf-8") as f:
+            o = json.load(f)
+
+        o["issuer"] = self.issuer
+        o["description"] = self.description
+        o["namespace"] = self.namespace
+
+        with open(self.proof_path, "w", encoding="utf-8") as f:
+            json.dump(o, f, sort_keys=True, indent="\t")
+
+    def asdict(self):
+        """Output proof state to dict."""
+        return {
+            "version": self.version(),
+            "namespace": self.namespace,
+            "description": self.description,
+            "issuer": self.issuer,
+            "proofs": self.proofs,
+        }
+
+    # TODO: the efficiency of this method could probably be improved.
+    def __get_ordered_hashes(self):
+        ks = list(self.attachments.keys())
+        ks.sort()
+
+        return ks
+
+    #    def get(self):
+    #        hsh = self.hash(b).hex()
+    #        self.attachments[hsh] = self.temp_proof_path
+    #        logg.debug('cbor of {} is {} hashes to {}'.format(v, b.hex(), hsh))
+
+    def root(self):
+        """Calculate the root digest from the serialized proof object."""
+        v = self.asdict()
+        # b = cbor2.dumps(v)
+        b = json.dumps(v, separators=(",", ":"))
+
+        with open(self.temp_proof_path, "w", encoding="utf-8") as f:
+            f.write(b)
+
+        b = b.encode("utf-8")
+        k = self.hash(b)
+
+        return (k.hex(), b)
+
+    def process(self, token_address=None, token_symbol=None, writer=None):
+        """Serialize and publish proof.
+
+        See cic.processor.Processor.process
+        """
+        if writer is None:
+            writer = self.writer
+
+        (k, v) = self.root()
+        writer.write(k, v)
+        root_key = k
+
+        token_symbol_bytes = token_symbol.encode("utf-8")
+        k = generate_metadata_pointer(
+            token_symbol_bytes, MetadataPointer.TOKEN_PROOF_SYMBOL
+        )
+        writer.write(k, v)
+
+        token_address_bytes = bytes.fromhex(strip_0x(token_address))
+        k = generate_metadata_pointer(token_address_bytes, MetadataPointer.TOKEN_PROOF)
+        writer.write(k, v)
+
+        #        (hsh, hshs) = self.get()
+        # hshs = list(map(strip_0x, hshs))
+        #        hshs_bin = list(map(bytes.fromhex, hshs))
+        #        hshs_cat = b''.join(hshs_bin)
+
+        #        f = open(self.temp_proof_path, 'rb')
+        #        v = f.read()
+        #        f.close()
+        #        writer.write(hsh, v)
+
+        #        r = self.hash(hshs_cat)
+        #        r_hex = r.hex()
+
+        # logg.debug('generated proof {} for hashes {}'.format(r_hex, hshs))
+
+        # writer.write(r_hex, hshs_cat)
+
+        o = self.asdict()
+        with open(self.proof_path, "w", encoding="utf-8") as f:
+            json.dump(o, f, sort_keys=True, indent="\t")
+
+        return root_key
+
+    def __str__(self):
+        return object_to_str(
+            self, ["description", "issuer", "namespace", "version()", "proofs"]
+        )

cic/contract/components/token.py

@@ -0,0 +1,123 @@
+# standard imports
+import json
+import os
+
+# local imports
+from cic.contract.base import Data, data_dir
+from cic.contract.helpers import select_contract
+
+
+class Token(Data):
+    """Encapsulates the token data used by the extension to deploy and/or register token and token related applications on chain.
+
+    Token details (name, symbol etc) will be used to initialize the token settings when start is called. If load is called instead, any token detail parameters passed to the constructor will be overwritten by data stored in the settings.
+
+    :param path: Settings directory path
+    :type path: str
+    :param name: Token name
+    :type name: str
+    :param symbol: Token symbol
+    :type symbol: str
+    :param precision: Token value precision (number of decimals)
+    :type precision: int
+    :param supply: Token supply (in smallest precision units)
+    :type supply: int
+    :param code: Bytecode for token chain application
+    :type code: str (hex)
+    """
+
+    def __init__(
+        self,
+        path=".",
+        name="Foo Token",
+        symbol="FOO",
+        precision=6,
+        supply=0,
+        code=None,
+        extra_args=[],
+        extra_args_types=[],
+        interactive=False,
+    ):
+        super(Token, self).__init__()
+        self.name = name
+        self.symbol = symbol
+        self.supply = supply
+        self.precision = precision
+        self.code = code
+        self.extra_args = extra_args
+        self.extra_args_types = extra_args_types
+        self.path = path
+        self.token_path = os.path.join(self.path, "token.json")
+
+        if interactive:
+            contract = select_contract()
+            self.code = contract["bin_path"]
+            self.extra_args = contract["extra_args"]
+            self.extra_args_types = contract["extra_args_types"]
+
+            self.name = input(f"Enter Token Name ({self.name}): ") or self.name
+            self.symbol = input(f"Enter Token Symbol ({self.symbol}): ") or self.symbol
+            self.precision = input(f"Enter Token Precision ({self.precision}): ") or self.precision
+            self.supply = input(f"Enter Token Supply ({self.supply}): ") or self.supply
+
+    def load(self):
+        """Load token data from settings."""
+        super(Token, self).load()
+
+        with open(self.token_path, "r", encoding="utf-8") as f:
+            o = json.load(f)
+
+        self.name = o["name"]
+        self.symbol = o["symbol"]
+        self.precision = o["precision"]
+        self.code = o["code"]
+        self.supply = o["supply"]
+        extras = []
+        extra_types = []
+        token_extras: list = o["extra"]
+        if token_extras:
+            for idx, token_extra in enumerate(token_extras):
+                arg = token_extra.get("arg")
+                arg_type = token_extra.get("arg_type")
+                if arg and arg_type:
+                    extras.append(arg)
+                    extra_types.append(arg_type)
+                elif (arg and not arg_type) or (not arg and arg_type):
+                    raise ValueError(
+                        f"Extra contract args must have a 'arg' and 'arg_type', Please check {self.token_path}:extra[{idx}] "
+                    )
+        self.extra_args = extras
+        self.extra_args_types = extra_types
+        self.inited = True
+
+    def start(self):
+        """Initialize token settings from arguments passed to the constructor and/or template."""
+        super(Token, self).load()
+
+        token_template_file_path = os.path.join(
+            data_dir, f"token_template_v{self.version()}.json"
+        )
+        with open(token_template_file_path, encoding="utf-8") as f:
+            o = json.load(f)
+        o["name"] = self.name
+        o["symbol"] = self.symbol
+        o["precision"] = self.precision
+        o["code"] = self.code
+        o["supply"] = self.supply
+        extra = []
+        for idx, extra_arg in enumerate(self.extra_args):
+            extra.append({"arg": extra_arg, "arg_type": self.extra_args_types[idx]})
+        if len(extra) != 0:
+            o["extra"] = extra
+
+        with open(self.token_path, "w", encoding="utf-8") as f:
+            json.dump(o, f, sort_keys=True, indent="\t")
+
+    def __str__(self):
+        s = f"name = {self.name}\n"
+        s += f"symbol = {self.symbol}\n"
+        s += f"precision = {self.precision}\n"
+        s += f"supply = {self.supply}\n"
+        for idx, extra in enumerate(self.extra_args):
+            s += f"extra_args[{idx}]({self.extra_args_types[idx]}) = {extra}\n"
+        return s

cic/contract/contract.py

@@ -0,0 +1,224 @@
+# Standard
+import importlib
+import json
+import logging
+import os
+from typing import TYPE_CHECKING, List
+
+import requests
+from chainlib.chain import ChainSpec
+from chainlib.cli.config import Config
+from cic.contract.components.attachment import Attachment
+from cic.contract.components.meta import Meta
+from cic.contract.components.proof import Proof
+from cic.contract.components.token import Token
+from cic.contract.helpers import init_writers_from_config
+from cic.contract.network import Network
+
+# Local Modules
+from cic.contract.processor import ContractProcessor
+from cic.writers import HTTPWriter, KeyedWriterFactory, MetadataWriter, OutputWriter
+
+# external imports
+from cic_types.ext.metadata import MetadataRequestsHandler
+from cic_types.ext.metadata.signer import Signer as MetadataSigner
+
+log = logging.getLogger(__name__)
+
+
+class Contract:
+    """ """
+
+    def __init__(
+        self,
+        token: Token,
+        proof: Proof,
+        meta: Meta,
+        attachment: Attachment,
+        network: Network,
+    ):
+        self.token = token
+        self.proof = proof
+        self.meta = meta
+        self.attachment = attachment
+        self.network = network
+
+    def __str__(self):
+        s = ""
+        s += f"\n[cic.header]\nversion = {self.proof.version()}\n\n"
+        s += f"[cic.token]\n{self.token}\n"
+        s += f"[cic.proof]\n{self.proof}\n"
+        s += f"[cic.meta]\n{self.meta}\n"
+        s += f"[cic.attachment]\n{self.attachment}\n"
+        s += f"[cic.network]\n{self.network}\n"
+        return s
+
+
+def load_contract(directory) -> Contract:
+    token = Token(path=directory)
+    proof = Proof(path=directory)
+    meta = Meta(path=directory)
+    attachment = Attachment(path=directory)
+    network = Network(directory)
+
+    token.load()
+    proof.load()
+    meta.load()
+    attachment.load()
+    network.load()
+    return Contract(
+        token=token, proof=proof, meta=meta, attachment=attachment, network=network
+    )
+
+
+def generate_contract(
+    directory: str, targets: List[str], config, interactive=True
+) -> Contract:
+    if os.path.exists(directory):
+        contine = input(
+            f"Directory {directory} already exists, Would you like to delete it? (y/n): "
+        )
+        if contine.lower() != "y":
+            log.debug("Trying to load existing contract")
+            return load_contract(directory)
+        else:
+            print(f"Deleted {directory}")
+            os.system(f"rm -rf {directory}")
+    os.makedirs(directory)
+    log.debug("Generating token")
+    token = Token(directory, interactive=interactive)
+    token.start()
+
+    log.debug("Generating proof")
+    proof = Proof(directory, interactive=interactive)
+    proof.start()
+
+    log.debug("Generating meta")
+    meta = Meta(directory, interactive=interactive)
+    meta.start()
+
+    log.debug("Generating attachment")
+    attachment = Attachment(directory, interactive=interactive)
+
+    log.debug("Generating network")
+    network = Network(directory, targets=targets)
+    network.start()
+
+    log.debug(
+        f"""Populating infomation from network:
+    CIC_REGISTRY_ADDRESS: {config.get("CIC_REGISTRY_ADDRESS")}
+    CHAIN_SPEC: {config.get("CHAIN_SPEC")}
+    RPC_PROVIDER: {config.get("RPC_PROVIDER")}
+    """
+    )
+    for target in targets:
+        # TODO Clean this up
+        modname = f"cic.ext.{target}"
+        cmd_mod = importlib.import_module(modname)
+        signer_hint = config.get("WALLET_KEY_FILE")
+        keys = cmd_mod.list_keys(config, signer_hint)
+        if len(keys) > 1:
+            print(f"More than one key found, please select one:")
+            for idx, key in enumerate(keys):
+                print(f"{idx} - {key} ")
+            selecting_key = True
+            while selecting_key:
+                idx = int(input("Select key: "))
+                if keys[idx] is not None:
+                    key_account_address = keys[idx]
+                    selecting_key = False
+                else:
+                    print("Invalid key, try again")
+        else:
+            key_account_address = keys[0]
+
+        m = importlib.import_module(f"cic.ext.{target}.start")
+        m.extension_start(
+            network,
+            registry_address=config.get("CIC_REGISTRY_ADDRESS"),
+            chain_spec=ChainSpec.from_chain_str(config.get("CHAIN_SPEC")),
+            rpc_provider=config.get("RPC_PROVIDER"),
+            key_account_address=key_account_address,
+        )
+    network.load()
+
+    return Contract(
+        token=token, proof=proof, meta=meta, attachment=attachment, network=network
+    )
+
+
+def deploy_contract(
+    config: Config,
+    target: str,
+    contract_directory: str,
+):
+
+    modname = f"cic.ext.{target}"
+    cmd_mod = importlib.import_module(modname)
+
+    writers = init_writers_from_config(config)
+    output_directory = os.path.join(contract_directory, "out")
+    output_writer_path_meta = output_directory
+
+    metadata_endpoint = config.get("META_URL")
+
+    if metadata_endpoint is not None:
+        MetadataRequestsHandler.base_url = metadata_endpoint
+        MetadataSigner.gpg_path = "/tmp"
+        MetadataSigner.key_file_path = config.get("AUTH_KEYFILE_PATH")
+        MetadataSigner.gpg_passphrase = config.get("AUTH_PASSPHRASE")
+        writers["proof"] = KeyedWriterFactory(MetadataWriter, HTTPWriter).new
+        writers["attachment"] = KeyedWriterFactory(None, HTTPWriter).new
+        writers["meta"] = MetadataWriter
+        output_writer_path_meta = metadata_endpoint
+
+    ct = Token(path=contract_directory)
+    cm = Meta(
+        path=contract_directory, writer=writers["meta"](path=output_writer_path_meta)
+    )
+    ca = Attachment(
+        path=contract_directory,
+        writer=writers["attachment"](path=output_writer_path_meta),
+    )
+    cp = Proof(
+        path=contract_directory,
+        attachments=ca,
+        writer=writers["proof"](path=output_writer_path_meta),
+    )
+    cn = Network(path=contract_directory)
+
+    ca.load()
+    ct.load()
+    cp.load()
+    cm.load()
+    cn.load()
+
+    chain_spec = None
+    try:
+        chain_spec = config.get("CHAIN_SPEC")
+        log.debug(f"using CHAIN_SPEC from config: {chain_spec}")
+    except KeyError:
+        chain_spec = cn.chain_spec
+        config.add(chain_spec, "CHAIN_SPEC", exists_ok=True)
+        log.debug(f"using CHAIN_SPEC: {str(chain_spec)} from network")
+
+    signer_hint = config.get("WALLET_KEY_FILE")
+    (rpc, signer) = cmd_mod.parse_adapter(config, signer_hint)
+
+    target_network_reference = cn.resource(target)
+    chain_spec = cn.chain_spec(target)
+    log.debug(
+        f'found reference {target_network_reference["contents"]} chain spec {chain_spec} for target {target}'
+    )
+    c = getattr(cmd_mod, "new")(
+        chain_spec,
+        target_network_reference["contents"],
+        cp,
+        signer_hint=signer,
+        rpc=rpc,
+        outputs_writer=writers["ext"](path=output_directory),
+    )
+    c.apply_token(ct)
+
+    p = ContractProcessor(proof=cp, attachment=ca, metadata=cm, extensions=[c])
+    p.process()

cic/contract/helpers.py

@@ -0,0 +1,123 @@
+# standard imports
+import os
+import logging
+import sys
+import json
+import requests
+import importlib
+import tempfile
+import hashlib
+
+# local imports
+from cic.writers import OutputWriter
+
+log = logging.getLogger(__name__)
+
+
+CONTRACTS = [
+    {
+        "url": "https://gitlab.com/cicnet/eth-erc20/-/raw/master/python/giftable_erc20_token/data/GiftableToken",
+        "name": "Giftable Token",
+    },
+    {
+        "url": "https://gitlab.com/cicnet/erc20-demurrage-token/-/raw/master/python/erc20_demurrage_token/data/DemurrageTokenSingleNocap",
+        "name": "Demurrage Token Single No Cap",
+    }
+]
+
+# Download File from Url
+def download_file(url: str, filename=None) -> (str, bytes):
+    directory = tempfile.gettempdir()
+    filename = filename if filename else url.split("/")[-1]
+    log.debug(f"Downloading {filename}")
+    r = requests.get(url, allow_redirects=True)
+    content_hash = hashlib.md5(r.content).hexdigest()
+    path = os.path.join(directory, content_hash)
+    with open(path, "wb") as f:
+        f.write(r.content)
+    log.debug(f"{filename} downloaded to {path}")
+    return path
+
+def get_contract_args(data: list):
+    for item in data:
+        if item["type"] == "constructor":
+            return item["inputs"]
+    raise Exception("No constructor found in contract")
+
+def select_contract():
+    print("Contracts:")
+    print("\t C - Custom (path/url to contract)")
+    for idx, contract in enumerate(CONTRACTS):
+        print(f"\t {idx} - {contract['name']}")
+
+    val = input("Select contract (C,0,1..): ")
+    if val.isdigit() and int(val) < len(CONTRACTS):
+        contract = CONTRACTS[int(val)]
+        bin_path = os.path.abspath(download_file(contract["url"] + ".bin"))
+        json_path = download_file(contract["url"] + ".json")
+
+    elif val == "C":
+        possible_bin_location = input("Enter a path or url to a contract.bin: ")
+        if possible_bin_location.startswith('http'):
+            # possible_bin_location is url
+            bin_path = download_file(possible_bin_location)
+        else:
+            # possible_bin_location is path
+            if os.path.exists(possible_bin_location):
+                bin_path = os.path.abspath(possible_bin_location)
+            else:
+                raise Exception(f"File {possible_bin_location} does not exist")
+
+            possible_json_path = val.replace(".bin", ".json")
+            if os.path.exists(possible_json_path):
+                json_path = possible_json_path
+    else:
+        print("Invalid selection")
+        sys.exit(1)
+    contract_extra_args = []
+    contract_extra_args_types = []
+
+    if os.path.exists(json_path):
+        with open(json_path, encoding="utf-8") as f:
+            json_data = json.load(f)
+        for contract_arg in get_contract_args(json_data):
+            arg_name = contract_arg.get("name")
+            arg_type = contract_arg.get("type")
+            if arg_name not in ["_decimals", "_name", "_symbol"]:
+                val = input(f"Enter value for {arg_name} ({arg_type}): ")
+                contract_extra_args.append(val)
+                if arg_type == "uint128":
+                    contract_extra_args_types.append("uint256")
+                else:
+                    contract_extra_args_types.append(arg_type)
+
+    return {
+        "bin_path": bin_path,
+        "json_path": json_path,
+        "extra_args": contract_extra_args,
+        "extra_args_types": contract_extra_args_types,
+    }
+
+
+Writers = {
+    "meta": OutputWriter,
+    "attachment": OutputWriter,
+    "proof": OutputWriter,
+    "ext": OutputWriter,
+}
+
+def init_writers_from_config(config) -> Writers:
+    writers: Writers = {
+        "meta": None,
+        "attachment": None,
+        "proof": None,
+        "ext": None,
+    }
+    for key in writers:
+        writer_config_name = f"CIC_CORE_{key.upper()}_WRITER"
+        (module_name, attribute_name) = config.get(writer_config_name).rsplit(".", maxsplit=1)
+        mod = importlib.import_module(module_name)
+        writer = getattr(mod, attribute_name)
+        writers[key] = writer
+
+    return writers

cic/contract/network.py

@@ -1,16 +1,12 @@
 # standard imports
-import os
 import json
 import logging
+import os
 
 # external imports
 from chainlib.chain import ChainSpec
-
 # local imports
-from .base import (
+from cic.contract.base import Data, data_dir
-        Data,
-        data_dir,
-        )
 
 logg = logging.getLogger(__name__)
 
@@ -38,9 +34,8 @@ class Network(Data):
         """
         super(Network, self).load()
 
-        f = open(self.network_path, 'r')
+        with open(self.network_path, 'r', encoding='utf-8') as f:
             o = json.load(f)
-        f.close()
 
         self.resources = o['resources']
 
@@ -54,11 +49,10 @@ class Network(Data):
         """
         super(Network, self).load()
 
-        network_template_file_path = os.path.join(data_dir, 'network_template_v{}.json'.format(self.version()))
+        network_template_file_path = os.path.join(data_dir, f'network_template_v{self.version()}.json')
         
-        f = open(network_template_file_path)
+        with open(network_template_file_path, encoding='utf-8') as f:
             o_part = json.load(f)
-        f.close() 
 
         self.resources = {}
         for v in self.targets:
@@ -70,11 +64,10 @@ class Network(Data):
     def save(self):
         """Save network settings to file.
         """
-        f = open(self.network_path, 'w')
+        with open(self.network_path, 'w', encoding='utf-8') as f:
             json.dump({
                 'resources': self.resources,
                 }, f, sort_keys=True, indent="\t")
-        f.close()
 
 
     def resource(self, k):
@@ -86,8 +79,8 @@ class Network(Data):
         :return: Extension settings
         """
         v = self.resources.get(k)
-        if v  == None:
+        if v is None:
-            raise AttributeError('no defined reference for {}'.format(k))
+            raise AttributeError(f'No defined reference for {k}')
         return v
 
 
@@ -132,17 +125,19 @@ class Network(Data):
         """
         chain_spec_dict = chain_spec.asdict()
         for k in chain_spec_dict.keys():
-            logg.debug('resources {}'.format(self.resources))
+            logg.debug(f'resources: {self.resources}')
             self.resources[resource_key]['chain_spec'][k] = chain_spec_dict[k]
 
 
     def __str__(self):
         s = ''
-        for k in self.resources.keys():
+        for resource in self.resources.keys():
-            for kk in self.resources[k]['contents'].keys():
+            chainspec = ChainSpec.from_dict(self.resources[resource]['chain_spec'])
-                v = self.resources[k]['contents'][kk]
+            s += f'{resource}.chain_spec: {str(chainspec)}\n'
-                if v == None:
+            for content_key in self.resources[resource]['contents'].keys():
-                    v = ''
+                content_value = self.resources[resource]['contents'][content_key]
-                s += '{}.{} = {}\n'.format(k, kk, v)
+                if content_value is None:
+                    content_value = ''
+                s += f'{resource}.contents.{content_key} = {json.dumps(content_value, indent=4, sort_keys=True)}\n'
 
         return s

cic/contract/processor.py

@@ -4,7 +4,7 @@ import logging
 logg = logging.getLogger(__name__)
 
 
-class Processor:
+class ContractProcessor:
     """Drives the serialization and publishing of contracts, proofs and metadata for the token.
 
     :param proof: Proof object to publish
@@ -14,31 +14,37 @@ class Processor:
     :param metadata: Metadata object to publish
     :type metadata: cic.meta.Meta
     :param writer: Writer interface receiving the output of the processor
-    :type writer: cic.output.OutputWriter
+    :type writer: cic.writers.OutputWriter
     :param extensions: Extension contexts to publish to
     :type extensions: list of cic.extension.Extension
     """
-    def __init__(self, proof=None, attachment=None, metadata=None, outputs_writer=None, extensions=[]):
+
+    def __init__(
+        self,
+        proof=None,
+        attachment=None,
+        metadata=None,
+        outputs_writer=None,
+        extensions=[],
+    ):
         self.token_address = None
         self.extensions = extensions
         self.cores = {
-            'metadata': metadata,
+            "metadata": metadata,
-            'attachment': attachment,
+            "attachment": attachment,
-            'proof': proof,
+            "proof": proof,
         }
         self.outputs = []
         self.__outputs_writer = outputs_writer
 
-
     def writer(self):
         """Return the writer instance that the process is using.
 
-        :rtype: cic.output.OutputWriter
+        :rtype: cic.writers.OutputWriter
         :return: Writer
         """
         return self.__outputs_writer
 
-
     def get_outputs(self):
         """Return all written outputs.
 
@@ -53,7 +59,6 @@ class Processor:
         outputs += self.outputs
         return outputs
 
-
     def process(self, writer=None):
         """Serializes and publishes all token data.
 
@@ -62,13 +67,13 @@ class Processor:
         All output written to the publish writer will also be cached so that it subsequently be recalled using the get_outputs method.
 
         :param writer: Writer to use for publishing.
-        :type writer: cic.output.OutputWriter
+        :type writer: cic.writers.OutputWriter
         """
 
         tasks = [
-            'attachment',
+            "attachment",
-            'proof',
+            "proof",
-            'metadata',
+            "metadata",
         ]
 
         for ext in self.extensions:
@@ -76,8 +81,12 @@ class Processor:
 
             for task in tasks:
                 a = self.cores.get(task)
-                if a == None:
+                if a is None:
-                    logg.debug('skipping missing task receiver "{}"'.format(task))
+                    logg.debug(f'skipping missing task receiver "{task}"')
                     continue
-                v = a.process(token_address=token_address, token_symbol=token_symbol, writer=self.__outputs_writer)
+                v = a.process(
+                    token_address=token_address,
+                    token_symbol=token_symbol,
+                    writer=self.__outputs_writer,
+                )
                 self.outputs.append(v)

cic/data/config/config.ini

@@ -1,5 +1,18 @@
 [cic_core]
-meta_writer = cic.output.KVWriter
+meta_writer = cic.writers.KVWriter
-attachment_writer = cic.output.KVWriter
+attachment_writer = cic.writers.KVWriter
-proof_writer = cic.output.KVWriter
+proof_writer = cic.writers.KVWriter
-ext_writer = cic.output.KVWriter
+ext_writer = cic.writers.KVWriter
+
+[cic]
+registry_address = 0xcf60ebc445b636a5ab787f9e8bc465a2a3ef8299
+
+[meta]
+url = https://meta.grassecon.net
+http_origin = 
+
+[auth]
+type = gnupg
+keyfile_path = 
+passphrase = 
+

cic/data/token_template_v0.json

@@ -4,5 +4,10 @@
 	"precision": 0,
 	"code": null,
 	"supply": 0,
-	"extra": {}
+	"extra": [
+		{
+			"arg": "",
+			"arg_type": ""
+		}
+	]
 }

cic/ext/eth/__init__.py

@@ -1,43 +1,41 @@
 # standard imports
-import logging
 import copy
 import json
+import logging
 
 # external imports
 from chainlib.chain import ChainSpec
-from chainlib.eth.tx import (
+from chainlib.eth.address import is_address, to_checksum_address
-        TxFormat,
-        TxFactory,
-        Tx,
-        receipt,
-        )
 from chainlib.eth.connection import RPCConnection
-from chainlib.eth.contract import (
+from chainlib.eth.contract import ABIContractEncoder, ABIContractType
-        ABIContractEncoder,
-        ABIContractType
-        )
 from chainlib.eth.gas import OverrideGasOracle
 from chainlib.eth.nonce import RPCNonceOracle
-from chainlib.eth.address import (
+from chainlib.eth.tx import Tx, TxFactory, TxFormat, receipt
-        is_address,
-        to_checksum_address,
-        )
-from hexathon import add_0x
-from eth_token_index import TokenUniqueSymbolIndex
 from eth_address_declarator import Declarator
 from eth_address_declarator.declarator import AddressDeclarator
+from eth_token_index import TokenUniqueSymbolIndex
 from giftable_erc20_token import GiftableToken
+from hexathon import add_0x, strip_0x
 
 # local imports
-from cic.ext.eth.rpc import parse_adapter
+from cic.ext.eth.rpc import parse_adapter, list_keys
 from cic.extension import Extension
 
+
 logg = logging.getLogger(__name__)
 
 
 class CICEth(Extension):
-
+    def __init__(
-    def __init__(self, chain_spec, resources, proof, signer=None, rpc=None, outputs_writer=None, fee_oracle=None):
+        self,
+        chain_spec,
+        resources,
+        proof,
+        signer=None,
+        rpc=None,
+        outputs_writer=None,
+        fee_oracle=None,
+    ):
 
         """Implementation for the eth extension.
 
@@ -54,19 +52,25 @@ class CICEth(Extension):
         :param rpc: RPC adapter capable of submitting and querying the chain network node
         :type rpc: chainlib.connection.RPCConnection
         :param outputs_writer: Writer interface receiving the output of the processor
-        :type outputs_writer: cic.output.OutputWriter
+        :type outputs_writer: cic.writers.OutputWriter
         :param fee_oracle: Fee oracle required by signer
         :type fee_oracle: chainlib.fee.FeeOracle
         """
-        super(CICEth, self).__init__(chain_spec, resources, proof, signer=signer, rpc=rpc, outputs_writer=outputs_writer)
+        super(CICEth, self).__init__(
+            chain_spec,
+            resources,
+            proof,
+            signer=signer,
+            rpc=rpc,
+            outputs_writer=outputs_writer,
+        )
         self.fee_oracle = fee_oracle
         self.tx_format = TxFormat.RAW_ARGS
-        if self.rpc != None:
+        if self.rpc is not None:
             self.tx_format = TxFormat.JSONRPC
-        elif self.signer != None:
+        elif self.signer is not None:
             self.tx_format = TxFormat.RLP_SIGNED
 
-   
     def __detect_arg_type(self, v):
         typ = None
         try:
@@ -75,7 +79,7 @@ class CICEth(Extension):
         except TypeError:
             pass
 
-        if typ == None:
+        if typ is None:
             try:
                 vv = strip_0x(v)
                 if is_address(vv):
@@ -85,26 +89,27 @@ class CICEth(Extension):
             except ValueError:
                 pass
 
-        if typ == None:
+        if typ is None:
             try:
-                v.encode('utf-8') 
+                v.encode("utf-8")
                 typ = ABIContractType.STRING
             except ValueError:
                 pass
 
-        if typ == None:
+        if typ is None:
-            raise ValueError('cannot automatically determine type for value {}'.format(v))
+            raise ValueError(
+                f"cannot automatically determine type for value {v}"
+            )
 
-        logg.info('argument {} parsed as abi contract type {}'.format(typ.value))
+        logg.info(f"argument {v} parsed as abi contract type {typ.value}")
 
         return typ
 
-
     def __order_args(self):
         args = [
-                self.token_details['name'],
+            self.token_details["name"],
-                self.token_details['symbol'],
+            self.token_details["symbol"],
-                self.token_details['precision'],
+            self.token_details["precision"],
         ]
         args_types = [
             ABIContractType.STRING.value,
@@ -112,22 +117,21 @@ class CICEth(Extension):
             ABIContractType.UINT256.value,
         ]
 
-        for i, x in enumerate(self.token_details['extra']):
+        for i, x in enumerate(self.token_details["extra"]):
             args.append(x)
             typ = None
-            if self.token_details['extra_types'] != None:
+            if self.token_details["extra_types"] is not None:
-                typ = self.token_details['extra_types'][i]
+                typ = self.token_details["extra_types"][i]
             else:
                 typ = self.__detect_arg_type(x)
             args_types.append(typ)
 
-        positions = self.token_details['positions']
+        positions = self.token_details["positions"]
-        if positions == None:
+        if positions is None:
             positions = list(range(len(args)))
 
         return (args, args_types, positions)
 
-
     def add_outputs(self, k, v):
         """Adds given key/value pair to outputs array.
 
@@ -136,10 +140,9 @@ class CICEth(Extension):
         :param v: Output value
         :param v: bytes or str
         """
-        logg.debug('adding outputs {} {}'.format(k, v))
+        logg.debug(f"adding outputs {k} {v}")
         self.outputs.append((k, v))
 
-
     def get_outputs(self):
         """Get wrapper for outputs captured from processing.
 
@@ -148,14 +151,13 @@ class CICEth(Extension):
         """
         return self.outputs
 
-
     def process_token(self, writer=None):
         """Deploy token, and optionally mint token supply to token deployer account.
 
         :param writer: Writer interface receiving the output of the processor step
-        :type writer: cic.output.OutputWriter
+        :type writer: cic.writers.OutputWriter
         """
-        if writer == None:
+        if writer is None:
             writer = self.outputs_writer
 
         (args, args_types, positions) = self.__order_args()
@@ -166,106 +168,148 @@ class CICEth(Extension):
             getattr(enc, args_types[i])(args[i])
 
         code = enc.get()
-        if self.token_code != None:
+        if self.token_code is not None:
             code = self.token_code + code
 
-        logg.debug('resource {}'.format(self.resources))
+        logg.debug(f"resource {self.resources}")
-        signer_address = add_0x(to_checksum_address(self.resources['token']['key_account']))
+        signer_address = add_0x(
+            to_checksum_address(self.resources["token"]["key_account"])
+        )
         nonce_oracle = None
-        if self.rpc != None:
+        if self.rpc is not None:
             nonce_oracle = RPCNonceOracle(signer_address, conn=self.rpc)
 
-        c = TxFactory(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle, gas_oracle=self.fee_oracle)
+        c = TxFactory(
+            self.chain_spec,
+            signer=self.signer,
+            nonce_oracle=nonce_oracle,
+            gas_oracle=self.fee_oracle,
+        )
         tx = c.template(signer_address, None, use_nonce=True)
         tx = c.set_code(tx, code)
         o = c.finalize(tx, self.tx_format)
 
         token_address_tx = None
         r = None
-        if self.rpc != None:
+        if self.rpc is not None:
             r = self.rpc.do(o[1])
             token_address_tx = r
             o = self.rpc.wait(r)
             o = Tx.src_normalize(o)
-            self.token_address = o['contract_address']
+            self.token_address = o["contract_address"]
-        elif self.signer != None:
+        elif self.signer is not None:
             r = o[1]
             token_address_tx = r
 
-        if r == None:
+        if r is None:
             r = code
-        writer.write('token', r.encode('utf-8'))
+        writer.write("token", r.encode("utf-8"))
-        writer.write('token_address', self.token_address.encode('utf-8'))
+        writer.write("token_address", self.token_address.encode("utf-8"))
-        self.add_outputs('token', r)
+        self.add_outputs("token", r)
 
-        if self.token_details['supply'] > 0:
+        if int(self.token_details["supply"]) > 0:
-            c = GiftableToken(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle, gas_oracle=self.fee_oracle)
+            c = GiftableToken(
-            o = c.mint_to(self.token_address, self.resources['token']['key_account'], self.resources['token']['key_account'], self.token_details['supply'])
+                self.chain_spec,
+                signer=self.signer,
+                nonce_oracle=nonce_oracle,
+                gas_oracle=self.fee_oracle,
+            )
+            o = c.mint_to(
+                self.token_address,
+                self.resources["token"]["key_account"],
+                self.resources["token"]["key_account"],
+                self.token_details["supply"],
+            )
             r = None
-            if self.rpc != None:
+            if self.rpc is not None:
                 r = self.rpc.do(o[1])
                 self.rpc.wait(r)
-                writer.write('token_supply', r.encode('utf-8'))
+                writer.write("token_supply", r.encode("utf-8"))
-            elif self.signer != None:
+            elif self.signer is not None:
                 r = o[1]
-                writer.write('token_supply', json.dumps(r).encode('utf-8'))
+                writer.write(
+                    "token_supply", json.dumps(r, separators=(",", ":")).encode("utf-8")
+                )
             else:
                 r = o
-                writer.write('token_supply', r.encode('utf-8'))
+                writer.write("token_supply", r.encode("utf-8"))
 
         return token_address_tx
 
-
     def process_token_index(self, writer=None):
         """Register deployed token with token index.
 
         :param writer: Writer interface receiving the output of the processor step
-        :type writer: cic.output.OutputWriter
+        :type writer: cic.writers.OutputWriter
         """
-        if writer == None:
+        if writer is None:
             writer = self.outputs_writer
 
-        signer_address = add_0x(to_checksum_address(self.resources['token_index']['key_account']))
+        signer_address = add_0x(
-        contract_address = add_0x(to_checksum_address(self.resources['token_index']['reference']))
+            to_checksum_address(self.resources["token_index"]["key_account"])
+        )
+        contract_address = add_0x(
+            to_checksum_address(self.resources["token_index"]["reference"])
+        )
 
-        gas_oracle = OverrideGasOracle(limit=TokenUniqueSymbolIndex.gas(), conn=self.rpc)
+        gas_oracle = OverrideGasOracle(
+            limit=TokenUniqueSymbolIndex.gas(), conn=self.rpc
+        )
         nonce_oracle = None
-        if self.rpc != None:
+        if self.rpc is not None:
             nonce_oracle = RPCNonceOracle(add_0x(signer_address), conn=self.rpc)
-        c = TokenUniqueSymbolIndex(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle)
+        c = TokenUniqueSymbolIndex(
+            self.chain_spec,
+            signer=self.signer,
+            nonce_oracle=nonce_oracle,
+            gas_oracle=gas_oracle,
+        )
 
-        o = c.register(contract_address, signer_address, self.token_address, tx_format=self.tx_format)
+        o = c.register(
+            contract_address,
+            signer_address,
+            self.token_address,
+            tx_format=self.tx_format,
+        )
         r = None
-        if self.rpc != None:
+        if self.rpc is not None:
             r = self.rpc.do(o[1])
             self.rpc.wait(r)
-        elif self.signer != None:
+        elif self.signer is not None:
             r = o[1]
         else:
             r = o
 
-        writer.write('token_index', r.encode('utf-8'))
+        writer.write("token_index", r.encode("utf-8"))
-        self.add_outputs('token_index', r)
+        self.add_outputs("token_index", r)
         return r
 
-
     def process_address_declarator(self, writer=None):
         """Register token proofs with address declarator.
 
         :param writer: Writer interface receiving the output of the processor step
-        :type writer: cic.output.OutputWriter
+        :type writer: cic.writers.OutputWriter
         """
-        if writer == None:
+        if writer is None:
             writer = self.outputs_writer
 
-        signer_address = add_0x(to_checksum_address(self.resources['address_declarator']['key_account']))
+        signer_address = add_0x(
-        contract_address = add_0x(to_checksum_address(self.resources['address_declarator']['reference']))
+            to_checksum_address(self.resources["address_declarator"]["key_account"])
+        )
+        contract_address = add_0x(
+            to_checksum_address(self.resources["address_declarator"]["reference"])
+        )
 
         gas_oracle = OverrideGasOracle(limit=AddressDeclarator.gas(), conn=self.rpc)
         nonce_oracle = None
-        if self.rpc != None:
+        if self.rpc is not None:
             nonce_oracle = RPCNonceOracle(signer_address, conn=self.rpc)
-        c = Declarator(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle)
+        c = Declarator(
+            self.chain_spec,
+            signer=self.signer,
+            nonce_oracle=nonce_oracle,
+            gas_oracle=gas_oracle,
+        )
 
         results = []
         # (main_proof, all_proofs) = self.proof.get()
@@ -275,31 +319,35 @@ class CICEth(Extension):
 
         (k, v) = self.proof.root()
 
-        fk = 'address_declarator_' + k
+        fk = "address_declarator_" + k
-        o = c.add_declaration(contract_address, signer_address, self.token_address, k, tx_format=self.tx_format)
+        o = c.add_declaration(
+            contract_address,
+            signer_address,
+            self.token_address,
+            k,
+            tx_format=self.tx_format,
+        )
         r = None
-        if self.rpc != None:
+        if self.rpc is not None:
             r = self.rpc.do(o[1])
             self.rpc.wait(r)
-        elif self.signer != None:
+        elif self.signer is not None:
             r = o[1]
         else:
             r = o
         self.add_outputs(fk, r)
         results.append(r)
-        v = r.encode('utf-8')
+        v = r.encode("utf-8")
-        if writer != None:
+        if writer is not None:
             writer.write(fk, v)
 
         return results
 
-    
     def prepare_extension(self):
-        """Sets token address for extension if defined in settings.
+        """Sets token address for extension if defined in settings."""
-        """
         super(CICEth, self).prepare_extension()
 
-        if self.token_address != None:
+        if self.token_address is not None:
             self.token_address = add_0x(to_checksum_address(self.token_address))
 
 
@@ -308,4 +356,11 @@ def new(chain_spec, resources, proof, signer_hint=None, rpc=None, outputs_writer
 
     See CICEth constructor for details.
     """
-    return CICEth(chain_spec, resources, proof, signer=signer_hint, rpc=rpc, outputs_writer=outputs_writer)
+    return CICEth(
+        chain_spec,
+        resources,
+        proof,
+        signer=signer_hint,
+        rpc=rpc,
+        outputs_writer=outputs_writer,
+    )

cic/ext/eth/rpc.py

@@ -1,17 +1,19 @@
 # standard imports
-import stat
+from getpass import getpass
-import os
 import logging
+import os
+import stat
 
 # external imports
 from funga.eth.keystore.dict import DictKeystore
 from funga.eth.signer import EIP155Signer
-from chainlib.eth.cli import Rpc
 from chainlib.cli import Wallet
+from chainlib.eth.cli import Rpc
 
 # local imports
 from cic.keystore import KeystoreDirectory
 
+
 logg = logging.getLogger(__name__)
 
 
@@ -20,9 +22,11 @@ class EthKeystoreDirectory(DictKeystore, KeystoreDirectory):
 
     TODO: Move to funga
     """
-    pass
 
 
+def get_passphrase():
+    return getpass('Enter passphrase: ')
+
 def parse_adapter(config, signer_hint):
     """Determine and instantiate signer and rpc from configuration.
 
@@ -36,14 +40,14 @@ def parse_adapter(config, signer_hint):
     :return: RPC interface, signer interface
     """
     keystore = None
-    if signer_hint == None:
+    if signer_hint is None:
-        logg.info('signer hint missing')
+        logg.info("signer hint missing")
         return None
     st = os.stat(signer_hint)
     if stat.S_ISDIR(st.st_mode):
-        logg.debug('signer hint is directory')
+        logg.debug("signer hint is directory")
         keystore = EthKeystoreDirectory()
-        keystore.process_dir(signer_hint)
+        keystore.process_dir(signer_hint, password_retriever=get_passphrase)
 
     w = Wallet(EIP155Signer, keystore=keystore)
     signer = EIP155Signer(keystore)
@@ -51,3 +55,17 @@ def parse_adapter(config, signer_hint):
     rpc.connect_by_config(config)
 
     return (rpc.conn, signer)
+
+# TODO Find a better place for this
+def list_keys(config, signer_hint):
+    keystore = None
+    if signer_hint is None:
+        logg.info("signer hint missing")
+        return None
+    st = os.stat(signer_hint)
+    if stat.S_ISDIR(st.st_mode):
+        logg.debug("signer hint is directory")
+        keystore = EthKeystoreDirectory()
+        keystore.process_dir(signer_hint, default_password=config.get('WALLET_PASSPHRASE', ''), password_retriever=get_passphrase)
+        
+    return keystore.list()

cic/ext/eth/start.py

@@ -1,6 +1,6 @@
 # external imports
-from cic_eth_registry import CICRegistry
 from chainlib.eth.connection import RPCConnection
+from cic_eth_registry import CICRegistry
 
 
 def extension_start(network, *args, **kwargs):
@@ -9,18 +9,26 @@ def extension_start(network, *args, **kwargs):
     :param network: Network object to read and write settings from
     :type network: cic.network.Network
     """
-    CICRegistry.address = kwargs['registry_address']
+    CICRegistry.address = kwargs.get("registry_address")
+    key_account_address = kwargs.get("key_account_address")
+    RPCConnection.register_location(
+        kwargs.get("rpc_provider"), kwargs.get("chain_spec")
+    )
+    conn = RPCConnection.connect(kwargs.get("chain_spec"))
 
-    RPCConnection.register_location(kwargs['rpc_provider'], kwargs['chain_spec'])
+    registry = CICRegistry(kwargs.get("chain_spec"), conn)
-    conn = RPCConnection.connect(kwargs['chain_spec'])
 
-    registry = CICRegistry(kwargs['chain_spec'], conn)
+    address_declarator = registry.by_name("AddressDeclarator")
+    network.resource_set(
+        "eth", "address_declarator", address_declarator, key_account=key_account_address
+    )
 
-    address_declarator = registry.by_name('AddressDeclarator')
+    token_index = registry.by_name("TokenRegistry")
-    network.resource_set('eth', 'address_declarator', address_declarator)
+    network.resource_set(
+        "eth", "token_index", token_index, key_account=key_account_address
+    )
 
-    token_index = registry.by_name('TokenRegistry')
+    network.resource_set("eth", "token", None, key_account=key_account_address)
-    network.resource_set('eth', 'token_index', token_index)
 
-    network.set('eth', kwargs['chain_spec'])
+    network.set("eth", kwargs["chain_spec"])
     network.save()

cic/extension.py

@@ -5,7 +5,8 @@ import logging
 from hexathon import valid as valid_hex
 
 # local imports
-from cic.output import StdoutWriter
+from cic.writers import StdoutWriter
+from cic.contract.components.token import Token
 
 logg = logging.getLogger(__name__)
 
@@ -24,9 +25,18 @@ class Extension:
     :param rpc: RPC adapter capable of submitting and querying the chain network node
     :type rpc: chainlib.connection.RPCConnection
     :param writer: Writer interface receiving the output of the processor
-    :type writer: cic.output.OutputWriter
+    :type writer: cic.writers.OutputWriter
     """
-    def __init__(self, chain_spec, resources, proof, signer=None, rpc=None, outputs_writer=StdoutWriter()):
+
+    def __init__(
+        self,
+        chain_spec,
+        resources,
+        proof,
+        signer=None,
+        rpc=None,
+        outputs_writer=StdoutWriter(),
+    ):
         self.resources = resources
         self.proof = proof
         self.chain_spec = chain_spec
@@ -38,9 +48,8 @@ class Extension:
         self.outputs = []
         self.outputs_writer = outputs_writer
 
-
     # TODO: apply / prepare token can be factored out
-    def apply_token(self, token):
+    def apply_token(self, token: Token):
         """Initialize extension with token data from settings.
 
         :param token: Token object
@@ -48,10 +57,27 @@ class Extension:
         :rtype: dict
         :returns: Token data state of extension after load
         """
-        return self.prepare_token(token.name, token.symbol, token.precision, token.code, token.supply)
+        return self.prepare_token(
+            token.name,
+            token.symbol,
+            token.precision,
+            token.code,
+            token.supply,
+            token.extra_args,
+            token.extra_args_types,
+        )
 
-
+    def prepare_token(
-    def prepare_token(self, name, symbol, precision, code, supply, extra=[], extra_types=[], positions=None):
+        self,
+        name,
+        symbol,
+        precision,
+        code,
+        supply,
+        extra=None,
+        extra_types=None,
+        positions=None,
+    ):
         """Initialize extension token data.
 
         :param name: Token name
@@ -74,22 +100,20 @@ class Extension:
         :returns: Token data state of extension after load
         """
         self.token_details = {
-            'name': name,
+            "name": name,
-            'symbol': symbol,
+            "symbol": symbol,
-            'precision': precision,
+            "precision": precision,
-            'code': code,
+            "code": code,
-            'supply': supply,
+            "supply": supply,
-            'extra': extra,
+            "extra": extra or [],
-            'extra_types': extra_types,
+            "extra_types": extra_types or [],
-            'positions': positions,
+            "positions": positions,
         }
+        logg.debug(f"token details: {self.token_details}")
         return self.token_details
 
-
     def prepare_extension(self):
-        """Prepare extension for publishing (noop)
+        """Prepare extension for publishing (noop)"""
-        """
-        pass
 
 
     def parse_code_as_file(self, v):
@@ -101,17 +125,14 @@ class Extension:
         :type v: str
         """
         try:
-            f = open(v, 'r')
+            f = open(v, "r", encoding="utf-8")
             r = f.read()
             f.close()
             self.parse_code_as_hex(r)
-        except FileNotFoundError:
+        except FileNotFoundError as e:
-            logg.debug('could not parse code as file: {}'.format(e))
+            logg.debug(f"could not parse code as file: {e}")
-            pass
+        except IsADirectoryError as e:
-        except IsADirectoryError:
+            logg.debug(f"could not parse code as file: {e}")
-            logg.debug('could not parse code as file: {}'.format(e))
-            pass
-
 
     def parse_code_as_hex(self, v):
         """Helper method to load application bytecode from hex data into extension token data state.
@@ -124,9 +145,7 @@ class Extension:
         try:
             self.token_code = valid_hex(v)
         except ValueError as e:
-            logg.debug('could not parse code as hex: {}'.format(e))
+            logg.debug(f"could not parse code as hex: {e}")
-            pass
-
 
     def load_code(self, hint=None):
         """Attempt to load token application bytecode using token settings.
@@ -136,8 +155,8 @@ class Extension:
         :rtype: str (hex)
         :return: Bytecode loaded into extension token data state
         """
-        code = self.token_details['code']
+        code = self.token_details["code"]
-        if hint == 'hex':
+        if hint == "hex":
             self.token_code = valid_hex(code)
 
         for m in [
@@ -145,48 +164,48 @@ class Extension:
             self.parse_code_as_file,
         ]:
             m(code)
-            if self.token_code != None:
+            if self.token_code is not None:
                 break
 
-        if self.token_code == None:
+        if self.token_code is None:
-            raise RuntimeError('could not successfully parse token code')
+            raise RuntimeError("could not successfully parse token code")
 
         return self.token_code
 
-
     def process(self, writer=None):
         """Adapter used by Processor to process the extensions implementing the Extension base class.
 
-        Requires either token address or a valid token code reference to have been included in settings. If token address is not set, the token application code will be deployed.
+        Requires either token address or a valid token code reference to have been included in settings.
+        If token address is not set, the token application code will be deployed.
 
         :param writer: Writer to use for publishing.
-        :type writer: cic.output.OutputWriter
+        :type writer: cic.writers.OutputWriter
         :rtype: tuple
         :return: Token address, token symbol
         """
-        if writer == None:
+        if writer is None:
             writer = self.outputs_writer
 
         tasks = []
-        self.token_address = self.resources['token']['reference']
+        self.token_address = self.resources["token"]["reference"]
 
         # TODO: get token details when token address is not none
-        if self.token_address == None:
+        if self.token_address is None:
-            if self.token_details['code'] == None:
+            if self.token_details["code"] is None:
-                raise RuntimeError('neither token address nor token code has been set')
+                raise RuntimeError("neither token address nor token code has been set")
             self.load_code()
-            tasks.append('token')
+            tasks.append("token")
 
         for k in self.resources.keys():
-            if k == 'token':
+            if k == "token":
                 continue
-            if self.resources[k]['reference'] != None:
+            if self.resources[k]["reference"] is not None:
                 tasks.append(k)
 
         self.prepare_extension()
 
         for task in tasks:
-            logg.debug('extension adapter process {}'.format(task))
+            logg.debug(f"extension adapter process {task}")
-            r = getattr(self, 'process_' + task)(writer=writer)
+            _r = getattr(self, "process_" + task)(writer=writer)
 
-        return (self.token_address, self.token_details.get('symbol'))
+        return (self.token_address, self.token_details.get("symbol"))

cic/hash.py

@@ -1,10 +0,0 @@
-class Hasher:
-
-    def __basehasher(self, v):
-        h = hashlib.sha256()
-        h.update(v)
-        return h.digest()
-
-
-    def hash(self, v):
-        return self.__basehasher(v)

cic/keystore.py

@@ -23,9 +23,9 @@ class KeystoreDirectory(Keystore):
             except IsADirectoryError:
                 pass
             except KeyfileError as e:
-                logg.warning('file {} could not be parsed as keyfile: {}'.format(fp, e))
+                logg.warning(f'file {fp} could not be parsed as keyfile: {e}')
             except DecryptError as e:
-                if password_retriever == None:
+                if password_retriever is None:
                     raise e
                 password = password_retriever()
                 self.import_keystore_file(fp, password=password)

cic/meta.py

@@ -1,141 +0,0 @@
-# standard imports
-import os
-import json
-import logging
-import base64
-
-# external imports
-from cic_types import MetadataPointer
-from cic_types.processor import generate_metadata_pointer
-from cic_types.ext.metadata import MetadataRequestsHandler
-from hexathon import strip_0x
-
-# local imports
-from .base import (
-        Data,
-        data_dir,
-        )
-from cic.output import OutputWriter
-logg = logging.getLogger(__name__)
-
-
-class Meta(Data):
-    """Serialize and publish metadata for token.
-
-    The token metadata is any mutable data that is not part of the initial token proof, but published simultaneously as the token nonetheless.
-
-    :param path: Path to settings directory
-    :type path: str
-    :param writer: Writer interface receiving the output of the processor
-    :type writer: cic.output.OutputWriter
-    """
-    def __init__(self, path='.', writer=None):
-        super(Meta, self).__init__()
-        self.name = None
-        self.contact = {}
-        self.path = path
-        self.writer = writer
-        self.meta_path = os.path.join(self.path, 'meta.json')
-
-
-    def load(self):
-        """Load metadata from settings.
-        """
-        super(Meta, self).load()
-
-        f = open(self.meta_path, 'r')
-        o = json.load(f)
-        f.close()
-
-        self.name = o['name']
-        self.contact = o['contact']
-
-        self.inited = True
-
-
-    def start(self):
-        """Initialize metadata settings from template.
-        """
-        super(Meta, self).start()
-
-        meta_template_file_path = os.path.join(data_dir, 'meta_template_v{}.json'.format(self.version()))
-        
-        f = open(meta_template_file_path)
-        o = json.load(f)
-        f.close() 
-       
-        f = open(self.meta_path, 'w')
-        json.dump(o, f, sort_keys=True, indent="\t")
-        f.close()
-
-
-    def reference(self, token_address):
-        """Calculate the mutable reference for the token metadata.
-        """
-        token_address_bytes = bytes.fromhex(strip_0x(token_address))
-        return generate_metadata_pointer(token_address_bytes, MetadataPointer.TOKEN_META)
-
-
-    def asdict(self):
-        """Output proof state to dict.
-        """
-        return {
-            'name': self.name,
-            'contact': self.contact,
-                }
-
-    
-    def process(self, token_address=None, token_symbol=None, writer=None):
-        """Serialize and publish metadata.
-
-        See cic.processor.Processor.process 
-        """
-        if writer == None:
-            writer = self.writer
-
-        v = json.dumps(self.asdict())
-
-        token_address_bytes = bytes.fromhex(strip_0x(token_address))
-        k = generate_metadata_pointer(token_address_bytes, MetadataPointer.TOKEN_META)
-        writer.write(k, v.encode('utf-8'))
-
-        token_symbol_bytes = token_symbol.encode('utf-8')
-        k = generate_metadata_pointer(token_symbol_bytes, MetadataPointer.TOKEN_META_SYMBOL)
-        writer.write(k, v.encode('utf-8'))
-
-        return (k, v)
-
-
-    def __str__(self):
-        s = "contact.name = {}\n".format(self.name)
-
-        for k in self.contact.keys():
-            if self.contact[k] == '':
-                continue
-            s += "contact.{} = {}\n".format(k.lower(), self.contact[k])
-
-        return s
-
-
-class MetadataWriter(OutputWriter):
-    """Custom writer for publishing data under immutable content-addressed pointers in the cic-meta storage backend.
-
-    Data that is not utf-8 will be converted to base64 before publishing.
-
-    Implements cic.output.OutputWriter
-    """
-
-    def write(self, k, v):
-        rq = MetadataRequestsHandler(MetadataPointer.NONE, bytes.fromhex(k))
-        try:
-            v = v.decode('utf-8')
-            v = json.loads(v)
-            logg.debug('metadatawriter bindecode {} {}'.format(k, v))
-        except UnicodeDecodeError:
-            v = base64.b64encode(v).decode('utf-8')
-            v = json.loads(json.dumps(v))
-            logg.debug('metadatawriter b64encode {} {}'.format(k, v))
-        r = rq.create(v)
-        logg.info('metadata submitted at {}'.format(k))
-        return r
-

cic/proof.py

@@ -1,181 +0,0 @@
-# standard imports
-import os
-import json
-import logging
-import tempfile
-import cbor2
-
-# external imports
-from hexathon import strip_0x
-from cic_types import MetadataPointer
-from cic_types.processor import generate_metadata_pointer
-from cic_types.ext.metadata import MetadataRequestsHandler
-
-# local imports
-from .base import *
-from cic.output import OutputWriter
-
-logg = logging.getLogger(__name__)
-
-
-class Proof(Data):
-    """Proof handles the immutable token proof data mapped to the initial token deployment.
-
-    It processes inputs from the proof.json file in the session directory.
-
-    Optionally, attachment objects can be added to the proof. If added, the resulting proof digest will consists of the attachment digests added to the root digest. These are then are deterministically ordered, regardless of which order attachments were given to the constructor.
-
-    :param path: Path to settings directory
-    :type path: str
-    :param attachments: List of attachment objects to include in the proof
-    :type attachments: cic.attachment.Attachment
-    :param writer: Writer interface receiving the output of the processor
-    :type writer: cic.output.OutputWriter
-    """
-
-    def __init__(self, path='.', attachments=None, writer=None):
-        super(Proof, self).__init__()
-        self.proofs = []
-        self.namespace = 'ge'
-        self.description = None
-        self.issuer = None
-        self.path = path
-        self.writer = writer
-        self.extra_attachments = attachments
-        self.attachments = {}
-        self.proof_path = os.path.join(self.path, 'proof.json')
-        self.temp_proof_path = tempfile.mkstemp()[1]
-                
-
-    def load(self):
-        """Load proof data from settings.
-        """
-        super(Proof, self).load()
-
-        f = open(self.proof_path, 'r')
-        o = json.load(f)
-        f.close()
-
-        self.set_version(o['version'])
-        self.description = o['description']
-        self.namespace = o['namespace']
-        self.issuer = o['issuer']
-        self.proofs = o['proofs']
-
-        if self.extra_attachments != None:
-            a = self.extra_attachments.asdict()
-            for k in a.keys():
-                self.attachments[k] = a[k]
-
-        hshs = self.__get_ordered_hashes()
-        self.proofs = list(map(strip_0x, hshs))
-
-        self.inited = True
-
-
-    def start(self):
-        """Initialize proof settings from template.
-        """
-        super(Proof, self).start()
-
-        proof_template_file_path = os.path.join(data_dir, 'proof_template_v{}.json'.format(self.version()))
-        
-        f = open(proof_template_file_path)
-        o = json.load(f)
-        f.close() 
-       
-        f = open(self.proof_path, 'w')
-        json.dump(o, f, sort_keys=True, indent="\t")
-        f.close()
-
-
-    def asdict(self):
-        """Output proof state to dict.
-        """
-        return {
-            'version': self.version(),
-            'namespace': self.namespace,
-            'description': self.description,
-            'issuer': self.issuer,
-            'proofs': self.proofs,
-                }
-
-
-    # TODO: the efficiency of this method could probably be improved.
-    def __get_ordered_hashes(self):
-        ks = list(self.attachments.keys())
-        ks.sort()
-
-        return ks
-
-
-#    def get(self):
-#        hsh = self.hash(b).hex()
-#        self.attachments[hsh] = self.temp_proof_path
-#        logg.debug('cbor of {} is {} hashes to {}'.format(v, b.hex(), hsh))
-
-
-    def root(self):
-        """Calculate the root digest from the serialized proof object.
-        """
-        v = self.asdict() 
-        #b = cbor2.dumps(v)
-        b = json.dumps(v)
-
-        f = open(self.temp_proof_path, 'w')
-        f.write(b)
-        f.close()
-
-        b = b.encode('utf-8')
-        k = self.hash(b)
-
-        return (k.hex(), b)
-
-
-    def process(self, token_address=None, token_symbol=None, writer=None):
-        """Serialize and publish proof.
-
-        See cic.processor.Processor.process 
-        """
-        if writer == None:
-            writer = self.writer
-
-        (k, v) = self.root()
-        writer.write(k, v)
-        root_key = k
-
-        token_symbol_bytes = token_symbol.encode('utf-8')
-        k = generate_metadata_pointer(token_symbol_bytes, MetadataPointer.TOKEN_PROOF_SYMBOL)
-        writer.write(k, v)
-
-        token_address_bytes = bytes.fromhex(strip_0x(token_address))
-        k = generate_metadata_pointer(token_address_bytes, MetadataPointer.TOKEN_PROOF)
-        writer.write(k, v)
-
-#        (hsh, hshs) = self.get()
-        #hshs = list(map(strip_0x, hshs))
-#        hshs_bin = list(map(bytes.fromhex, hshs))
-#        hshs_cat = b''.join(hshs_bin)
-
-#        f = open(self.temp_proof_path, 'rb')
-#        v = f.read()
-#        f.close()
-#        writer.write(hsh, v)
-
-#        r = self.hash(hshs_cat)
-#        r_hex = r.hex()
-
-        #logg.debug('generated proof {} for hashes {}'.format(r_hex, hshs))
-
-        #writer.write(r_hex, hshs_cat)
-
-        o = self.asdict()
-        f = open(self.proof_path, 'w')
-        json.dump(o, f, sort_keys=True, indent="\t")
-        f.close()
-
-        return root_key
-
-
-    def __str__(self):
-        return "description = {}\n".format(self.description)

cic/runnable/cic_cmd.py

@@ -1,16 +1,18 @@
 # standard imports
 import os
 import logging
-import argparse
 import sys
 import importlib
 
 # external imports
 import chainlib.cli
+
+# local imports
 import cic.cmd.init as cmd_init
 import cic.cmd.show as cmd_show
 import cic.cmd.ext as cmd_ext
 import cic.cmd.export as cmd_export
+import cic.cmd.wizard as cmd_wizard
 
 logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
@@ -21,41 +23,53 @@ base_config_dir = os.path.join(data_dir, 'config')
 schema_dir = os.path.join(script_dir, '..', 'schema')
 
 arg_flags = chainlib.cli.argflag_std_read | chainlib.cli.Flag.SEQ
-argparser = chainlib.cli.ArgumentParser(env=os.environ, arg_flags=arg_flags, description='CIC cli tool for generating and publishing tokens')
+argparser = chainlib.cli.ArgumentParser(
+    env=os.environ,
+    arg_flags=arg_flags,
+    description='CIC cli tool for generating and publishing tokens'
+)
 
 sub = argparser.add_subparsers()
 sub.dest = 'command'
+
 sub_init = sub.add_parser('init', help='initialize new cic data directory')
 cmd_init.process_args(sub_init)
+
 sub_show = sub.add_parser('show', help='display summary of current state of cic data directory')
 cmd_show.process_args(sub_show)
+
 sub_export = sub.add_parser('export', help='export cic data directory state to a specified target')
 cmd_export.process_args(sub_export)
+
 sub_ext = sub.add_parser('ext', help='extension helpers')
 cmd_ext.process_args(sub_ext)
 
+sub_wizard = sub.add_parser('wizard', help='An interactive wizard for creating and publishing contracts')
+cmd_wizard.process_args(sub_wizard)
 
 args = argparser.parse_args(sys.argv[1:])
 
-if args.command == None:
+if args.command is None:
     logg.critical('Subcommand missing')
     sys.stderr.write("\033[;91m" + 'subcommand missing' + "\033[;39m\n")
+    argparser.print_help(sys.stderr)
     sys.exit(1)
 
-modname = 'cic.cmd.{}'.format(args.command)
+modname = f'cic.cmd.{args.command}'
-logg.debug('using module {}'.format(modname))
+logg.debug(f'using module {modname}')
 cmd_mod = importlib.import_module(modname)
 
 extra_args = {
     'p': 'RPC_PROVIDER',
 }
+
 config = chainlib.cli.Config.from_args(args, arg_flags=arg_flags, base_config_dir=base_config_dir, extra_args=extra_args)
 
 def main():
     try:
         cmd_mod.execute(config, args)
     except Exception as e:
-        logg.exception(e) #'{}'.format(e))
+        logg.exception(e)
         sys.stderr.write("\033[;91m" + str(e) + "\033[;39m\n")
         sys.exit(1)
 

cic/token.py

@@ -1,88 +0,0 @@
-# standard imports
-import os
-import json
-
-# local imports
-from .base import (
-        Data,
-        data_dir,
-        )
-
-
-class Token(Data):
-    """Encapsulates the token data used by the extension to deploy and/or register token and token related applications on chain.
-
-    Token details (name, symbol etc) will be used to initialize the token settings when start is called. If load is called instead, any token detail parameters passed to the constructor will be overwritten by data stored in the settings.
-
-    :param path: Settings directory path
-    :type path: str
-    :param name: Token name
-    :type name: str
-    :param symbol: Token symbol
-    :type symbol: str
-    :param precision: Token value precision (number of decimals)
-    :type precision: int
-    :param supply: Token supply (in smallest precision units)
-    :type supply: int
-    :param code: Bytecode for token chain application
-    :type code: str (hex)
-    """
-    def __init__(self, path='.', name=None, symbol=None, precision=1, supply=0, code=None):
-        super(Token, self).__init__()
-        self.name = name
-        self.symbol = symbol
-        self.supply = supply
-        self.precision = precision
-        self.code = code
-        self.extra_args = None
-        self.path = path
-        self.token_path = os.path.join(self.path, 'token.json')
-
-
-    def load(self):
-        """Load token data from settings.
-        """
-        super(Token, self).load()
-
-        f = open(self.token_path, 'r')
-        o = json.load(f)
-        f.close()
-
-        self.name = o['name']
-        self.symbol = o['symbol']
-        self.precision = o['precision']
-        self.code = o['code']
-        self.supply = o['supply']
-        self.extra_args = o['extra']
-
-        self.inited = True
-
-
-    def start(self):
-        """Initialize token settings from arguments passed to the constructor and/or template.
-        """
-        super(Token, self).load()
-
-        token_template_file_path = os.path.join(data_dir, 'token_template_v{}.json'.format(self.version()))
-        
-        f = open(token_template_file_path)
-        o = json.load(f)
-        f.close() 
-
-        o['name'] = self.name
-        o['symbol'] = self.symbol
-        o['precision'] = self.precision
-        o['code'] = self.code
-        o['supply'] = self.supply
-
-        f = open(self.token_path, 'w')
-        json.dump(o, f, sort_keys=True, indent="\t")
-        f.close()
-
-
-    def __str__(self):
-        s = """name = {}
-symbol = {}
-precision = {}
-""".format(self.name, self.symbol, self.precision)
-        return s

cic/utils.py

@@ -0,0 +1,24 @@
+def object_to_str(obj, keys):
+    """Return a string representation of an object."""
+    s = ""
+    for key in keys:
+        value = eval("obj." + key)
+        key = key.replace("()", "")
+        if type(value) == str:
+            s += f"{key} = {value}\n"
+        elif type(value) == list:
+            for idx, vv in enumerate(value):
+                if not vv:
+                    s += f"{key}[{idx}] = \n"
+                    continue
+                s += f"{key}[{idx}] = {vv}\n"
+        elif type(value) == dict:
+            for vv_key in value.keys():
+                vv_value = value[vv_key]
+                if not vv_value:
+                    s += f"{key}.{vv_key} = \n"
+                    continue
+                s += f"{key}.{vv_key} = {vv_value}\n"
+        else:
+            s += f"{key} = {str(value)}\n"
+    return s

cic/writers.py

@@ -1,14 +1,17 @@
 # standard imports
+import base64
+import logging
 import os
 import sys
-import logging
 import urllib.request
+import json
+
+from cic_types.ext.metadata import MetadataRequestsHandler, MetadataPointer
 
 logg = logging.getLogger(__name__)
 
 
 class OutputWriter:
-
     def __init__(self, *args, **kwargs):
         pass
 
@@ -17,13 +20,11 @@ class OutputWriter:
 
 
 class StdoutWriter(OutputWriter):
-
     def write(self, k, v):
-        sys.stdout.write('{}\t{}\n'.format(k, v))
+        sys.stdout.write(f"{k}\t{v}\n")
 
 
 class KVWriter(OutputWriter):
-
     def __init__(self, path=None, *args, **kwargs):
         try:
             os.stat(path)
@@ -31,65 +32,83 @@ class KVWriter(OutputWriter):
             os.makedirs(path)
         self.path = path
 
-
     def write(self, k, v):
         fp = os.path.join(self.path, str(k))
-        logg.debug('path write {} {}'.format(fp, str(v)))
+        logg.debug(f"path write {fp} {str(v)}")
-        f = open(fp, 'wb')
+        f = open(fp, "wb")
         f.write(v)
         f.close()
 
 
 class HTTPWriter(OutputWriter):
-
     def __init__(self, path=None, *args, **kwargs):
         super(HTTPWriter, self).__init__(*args, **kwargs)
         self.path = path
 
-  
     def write(self, k, v):
         path = self.path
-        if k != None:
+        if k is not None:
             path = os.path.join(path, k)
-        logg.debug('http writer post {}'.format(path))
+        logg.debug(f"http writer post {path} \n key: {k}, value: {v}")
-        rq = urllib.request.Request(path, method='POST', data=v)
+        rq = urllib.request.Request(path, method="POST", data=v)
         r = urllib.request.urlopen(rq)
-        logg.info('http writer submitted at {}'.format(r.read()))
+        logg.info(f"http writer submitted at {r.read()}")
 
 
 class KeyedWriter(OutputWriter):
-
     def __init__(self, writer_keyed, writer_immutable):
         self.writer_keyed = writer_keyed
         self.writer_immutable = writer_immutable
 
-
     def write(self, k, v):
-        logg.debug('writing keywriter {} {}'.format(k, v))
+        logg.debug(f"writing keywriter key: {k} value: {v}")
         if isinstance(v, str):
-            v = v.encode('utf-8')
+            v = v.encode("utf-8")
-        if self.writer_keyed != None:
+        if self.writer_keyed is not None:
             self.writer_keyed.write(k, v)
-        if self.writer_immutable != None:
+        if self.writer_immutable is not None:
             self.writer_immutable.write(None, v)
 
 
 class KeyedWriterFactory:
-
+    def __init__(
-    def __init__(self, key_writer_constructor, immutable_writer_constructor, *args, **kwargs):
+        self, key_writer_constructor, immutable_writer_constructor, *args, **kwargs
+    ):
         self.key_writer_constructor = key_writer_constructor
         self.immutable_writer_constructor = immutable_writer_constructor
         self.x = {}
-        for k in kwargs.keys():
+        for k, v in kwargs.items():
-            logg.debug('adding key {} t keyed writer factory'.format(k))
+            logg.debug(f"adding key {k} t keyed writer factory")
-            self.x[k] = kwargs[k] 
+            self.x[k] = v
-       
 
     def new(self, path=None, *args, **kwargs):
         writer_keyed = None
         writer_immutable = None
-        if self.key_writer_constructor != None:
+        if self.key_writer_constructor is not None:
             writer_keyed = self.key_writer_constructor(path, **self.x)
-        if self.immutable_writer_constructor != None:
+        if self.immutable_writer_constructor is not None:
             writer_immutable = self.immutable_writer_constructor(path, **self.x)
         return KeyedWriter(writer_keyed, writer_immutable)
+
+
+class MetadataWriter(OutputWriter):
+    """Custom writer for publishing data under immutable content-addressed pointers in the cic-meta storage backend.
+
+    Data that is not utf-8 will be converted to base64 before publishing.
+
+    Implements cic.writers.OutputWriter
+    """
+
+    def write(self, k, v):
+        rq = MetadataRequestsHandler(MetadataPointer.NONE, bytes.fromhex(k))
+        try:
+            v = v.decode("utf-8")
+            v = json.loads(v)
+            logg.debug(f"metadatawriter bindecode {k} {v}")
+        except UnicodeDecodeError:
+            v = base64.b64encode(v).decode("utf-8")
+            v = json.loads(json.dumps(v, separators=(",", ":")))
+            logg.debug(f"metadatawriter b64encode {k} {v}")
+        r = rq.create(v)
+        logg.info(f"metadata submitted at {k}")
+        return r

config/docker/config.ini

@@ -0,0 +1,27 @@
+[cic_core]
+meta_writer = cic.writers.KVWriter
+attachment_writer = cic.writers.KVWriter
+proof_writer = cic.writers.KVWriter
+ext_writer = cic.writers.KVWriter
+
+[cic]
+registry_address = 0xcf60ebc445b636a5ab787f9e8bc465a2a3ef8299
+
+[meta]
+url = http://localhost:63380
+http_origin = 
+
+[rpc]
+provider = http://localhost:63545
+
+[auth]
+type = gnupg
+keyfile_path = /home/will/grassroots/cic-internal-integration/apps/cic-ussd/tests/data/pgp/privatekeys_meta.asc
+passphrase = merman
+
+[wallet]
+key_file = /home/will/.config/cic/keystore
+passphrase = 
+
+[chain]
+spec = evm:byzantium:8996:bloxberg

config/local/config.ini

@@ -0,0 +1,27 @@
+[cic_core]
+meta_writer = cic.writers.KVWriter
+attachment_writer = cic.writers.KVWriter
+proof_writer = cic.writers.KVWriter
+ext_writer = cic.writers.KVWriter
+
+[cic]
+registry_address = 0xcf60ebc445b636a5ab787f9e8bc465a2a3ef8299
+
+[meta]
+url = http://localhost:8000
+http_origin = 
+
+[rpc]
+provider = http://localhost:8545
+
+[auth]
+type = gnupg
+keyfile_path = /home/will/grassroots/cic-internal-integration/apps/cic-ussd/tests/data/pgp/privatekeys_meta.asc
+passphrase = merman
+
+[wallet]
+key_file = /home/will/grassroots/cic-internal-integration/apps/contract-migration/keystore
+passphrase = 
+
+[chain]
+spec = evm:byzantium:8996:bloxberg

config/mainnet/config.ini

@@ -0,0 +1,27 @@
+[cic_core]
+meta_writer = cic.writers.KVWriter
+attachment_writer = cic.writers.KVWriter
+proof_writer = cic.writers.KVWriter
+ext_writer = cic.writers.KVWriter
+
+[cic]
+registry_address = 0x999487d8B1EC2b2ac9F4a9D1A6D35a24D75D7EF4
+
+[meta]
+url = https://meta.grassecon.net
+http_origin = 
+
+[rpc]
+provider = https://rpc.kitabu.grassecon.net
+
+[auth]
+type = gnupg
+keyfile_path = /home/will/.config/cic/staff-client/user.asc
+passphrase = queenmarlena
+
+[wallet]
+key_file = /home/will/grassroots/cic-internal-integration/apps/contract-migration/keystore
+passphrase = 
+
+[chain]
+spec = evm:kitabu:5050:sarafu

config/testnet/config.ini

@@ -0,0 +1,27 @@
+[cic_core]
+meta_writer = cic.writers.KVWriter
+attachment_writer = cic.writers.KVWriter
+proof_writer = cic.writers.KVWriter
+ext_writer = cic.writers.KVWriter
+
+[cic]
+registry_address = 0xcf60ebc445b636a5ab787f9e8bc465a2a3ef8299
+
+[meta]
+url = http://localhost:6700
+http_origin = 
+
+[rpc]
+provider = https://rpc.grassecon.net
+
+[auth]
+type = gnupg
+keyfile_path = /home/will/grassroots/cic-internal-integration/apps/cic-ussd/tests/data/pgp/privatekeys_meta.asc
+passphrase = merman
+
+[wallet]
+key_file =  /home/will/grassroots/cic-internal-integration/apps/contract-migration/keystore
+passphrase = 
+
+[chain]
+spec = evm:byzantium:5050:bloxberg

eth_requirements.txt

@@ -1,7 +0,0 @@
-chainlib-eth~=0.0.13
-funga-eth~=0.5.1
-eth-token-index~=0.2.4
-eth-address-index~=0.2.4
-okota~=0.2.5a1
-cic_eth_registry~=0.6.2
-cic_contracts~=0.0.5

pyproject.toml

@@ -0,0 +1,96 @@
+[tool.poetry]
+name = "cic-cli"
+version = "0.0.2"
+description = "Generic cli tooling for the CIC token network"
+authors = [
+  "Louis Holbrook <dev@holbrook.no>",
+  "William Luke <williamluke4@gmail.com>",
+]
+license = "GPL-3.0-or-later"
+readme = "README.md"
+repository = "https://git.grassecon.net/cicnet/cic-cli"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+  "Topic :: Internet",
+]
+keywords = ["dlt", "blockchain", "cryptocurrency"]
+packages = [
+  { include = "cic" },
+  { include = "cic/runnable/*.py" },
+  { include = "cic/ext/**/*.py" },
+  { include = "cic/cmd/**/*.py" },
+]
+
+[tool.poetry.scripts]
+cic = 'cic.runnable.cic_cmd:main'
+
+[[tool.poetry.source]]
+name = "grassroots_"
+url = "https://pip.grassrootseconomics.net/"
+default = true
+
+[[tool.poetry.source]]
+name = "pypi_"
+url = "https://pypi.org/simple/"
+secondary = true
+
+[tool.poetry.dependencies]
+python = "^3.8"
+funga-eth = "~0.5.5"
+cic-types = "~0.2.1a8"
+confini = "~0.5.3"
+chainlib = "~0.0.17"
+cbor2 = "5.4.1"
+
+chainlib-eth = { version = "~0.0.25", optional = true }
+eth-token-index = { version = "0.2.4", optional = true }
+eth-address-index = { version = "~0.2.4", optional = true }
+okota = { version = "~0.2.5", optional = true }
+cic_eth_registry = { version = "~0.6.6", optional = true }
+cic_contracts = { version = "~0.0.5", optional = true }
+
+
+[tool.poetry.dev-dependencies]
+pytest = "6.2.5"
+pytest-cov = "2.10.1"
+python-semantic-release = "^7.25.2"
+pylint = "^2.12.2"
+black = { version = "^22.1.0", allow-prereleases = true }
+eth-erc20 = ">0.1.2a3,<0.2.0"
+eth_tester = "0.5.0b3"
+py-evm = "0.3.0a20"
+rlp = "2.0.1"
+
+[tool.poetry.extras]
+eth = [
+  "chainlib-eth",
+  "eth-token-index",
+  "eth-address-index",
+  "okota",
+  "cic_eth_registry",
+  "cic_contracts",
+]
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+addopts = "--cov=cic --cov-fail-under=40 --cov-report term-missing"
+testpaths = ["tests"]
+
+[tool.semantic_release]
+version_variable = ["cic/__init__.py:__version__", "pyproject.toml:version"]
+version_source = "commit"
+branch = "main"
+upload_to_repository = true
+upload_to_release = true
+build_command = "pip install poetry && poetry build"
+hvcs = "gitea"
+hvcs_domain = "git.grassecon.net"
+check_build_status = false

requirements.txt

@@ -1,5 +0,0 @@
-funga-eth~=0.5.1
-cic-types~=0.2.1a5
-confini~=0.5.1
-chainlib~=0.0.13
-cbor2==5.4.1

run_tests.sh

@@ -1,17 +0,0 @@
-#!/bin/bash
-
-set -a
-set -e
-set -x
-default_pythonpath=$PYTHONPATH:.
-export PYTHONPATH=${default_pythonpath:-.}
->&2 echo using pythonpath $PYTHONPATH
-for f in `ls tests/*.py`; do
-	python $f
-done
-for f in `ls tests/eth/*.py`; do
-	python $f
-done
-set +x
-set +e
-set +a

setup.cfg

@@ -1,32 +0,0 @@
-[metadata]
-name = cic
-version = 0.0.2
-description = Generic cli tooling for the CIC token network
-author = Louis Holbrook
-author_email = dev@holbrook.no
-url = https://git.grassecon.net/cic-cli.git
-keywords =
-	dlt
-	blockchain
-	cryptocurrency
-classifiers =
-	Programming Language :: Python :: 3
-	Operating System :: OS Independent
-	Development Status :: 3 - Alpha
-	Environment :: Console
-	Intended Audience :: Developers
-	License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-	Topic :: Internet
-license = GPL3
-licence_files =
-	LICENSE.txt
-
-
-[options]
-python_requires = >= 3.8
-include_package_data = True
-packages = 
-	cic
-	cic.runnable
-	cic.ext.eth
-	cic.cmd

setup.py

@@ -1,35 +0,0 @@
-from setuptools import setup
-import configparser
-import os
-
-
-requirements = []
-f = open('requirements.txt', 'r')
-while True:
-    l = f.readline()
-    if l == '':
-        break
-    requirements.append(l.rstrip())
-f.close()
-
-eth_requirements = []
-f = open('eth_requirements.txt', 'r')
-while True:
-    l = f.readline()
-    if l == '':
-        break
-    eth_requirements.append(l.rstrip())
-f.close()
-
-
-setup(
-        install_requires=requirements,
-        extras_require={
-            'eth': eth_requirements,
-            },
-        entry_points={
-            'console_scripts': [
-                'cic-cli=cic.runnable.cic_cmd:main',
-            ],
-        },
-    )

test_requirements.txt

@@ -1,7 +0,0 @@
-eth-erc20>=0.1.2a3,<0.2.0
-eth_tester==0.5.0b3
-py-evm==0.3.0a20
-rlp==2.0.1
-chainlib-eth>=0.0.10a2,<0.1.0
-eth-address-index>=0.2.4a1,<0.3.0
-okota>=0.2.4a6,<0.3.0

tests/base_cic.py

@@ -1,42 +1,41 @@
 # standard imports
 import os
-import tempfile
-import logging
-import unittest
 import random
+import tempfile
+import unittest
+
+from cic.contract.components.attachment import Attachment
+from cic.contract.components.proof import Proof
+from cic.contract.processor import ContractProcessor
+
+# local imports
+from cic.writers import KVWriter
 
 # external imports
 from hexathon import add_0x
 
-# local imports
-from cic.output import KVWriter
-from cic.processor import Processor
-from cic.attachment import Attachment
-from cic import Proof
-
 test_base_dir = os.path.dirname(os.path.realpath(__file__))
-test_data_dir = os.path.join(test_base_dir, 'testdata')
+test_data_dir = os.path.join(test_base_dir, "testdata")
 
-proof_hash = '0f6fc017f29caf512c0feaaf83bc10614b488311cace2973dc248dc24b01e04f'
+proof_hash = "0f6fc017f29caf512c0feaaf83bc10614b488311cace2973dc248dc24b01e04f"
-foo_hash = '2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae'
+foo_hash = "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"
-bar_hash = 'fcde2b2edba56bf408601fb721fe9b5c338d10ee429ea04fae5511b68fbf8fb9'
+bar_hash = "fcde2b2edba56bf408601fb721fe9b5c338d10ee429ea04fae5511b68fbf8fb9"
-root_merged_hash = '795fed550ada0ec1eea4309a282f5910bc3bdb3a9762c7d9cc25d6de71c45096'
+root_merged_hash = "2a27a488377c753fffea58ad535cfdacc2fcb5cf0ae495ec71d88e31757ec0c3"
-root_unmerged_hash = '5dc81e51703e624f498663e7d5d70429b824e9ff60f92b61fe47eb6862a971b4'
+root_unmerged_hash = "14dc271290eca763e99c2e7c21c541bded86fb803c6b01bac28cd367db34399c"
 
 
 class TestCICBase(unittest.TestCase):
-
     def setUp(self):
         super(TestCICBase, self).setUp()
         random.seed(42)
 
-        f = open('/dev/urandom', 'rb')
+        f = open("/dev/urandom", "rb")
         addresses = []
-        for i in range(3):
+        for _i in range(3):
             address_bytes = f.read(32)
             addresses.append(add_0x(address_bytes.hex()))
 
-        self.token_symbol = 'FOO'
+        self.token_symbol = "FOO"
 
         token_address_bytes = f.read(20)
         token_index_address_bytes = f.read(20)
@@ -50,23 +49,23 @@ class TestCICBase(unittest.TestCase):
 
         self.outputs_dir = tempfile.mkdtemp()
         self.outputs_writer = KVWriter(self.outputs_dir)
-        self.core_processor = Processor(outputs_writer=self.outputs_writer)
+        self.core_processor = ContractProcessor(outputs_writer=self.outputs_writer)
 
         self.resources = {
-                'token': {
+            "token": {
-                    'reference': self.token_address,
+                "reference": self.token_address,
-                    'key_address': addresses[0],
+                "key_address": addresses[0],
             },
-                'token_index': {
+            "token_index": {
-                    'reference': self.token_index_address,
+                "reference": self.token_index_address,
-                    'key_address': addresses[1],
+                "key_address": addresses[1],
             },
-                'address_declarator': {
+            "address_declarator": {
-                    'reference': self.address_declarator_address,
+                "reference": self.address_declarator_address,
-                    'key_address': addresses[2],
+                "key_address": addresses[2],
             },
         }
-        proof_dir = os.path.join(test_data_dir, 'proof')
+        proof_dir = os.path.join(test_data_dir, "proof")
         attach = Attachment(path=proof_dir)
         attach.load()
         self.proofs = Proof(proof_dir, attachments=attach)

tests/eth/base_eth.py

@@ -1,4 +1,4 @@
-# standard imports import unittestimport logging
+# standard imports
 import random
 import os
 import logging
@@ -24,10 +24,10 @@ from cic_contracts.writer import CICWriter
 
 # local imports
 from cic.ext.eth import CICEth
-from cic import Proof
+from cic.writers import KVWriter
-from cic.attachment import Attachment
+from cic.contract.processor import ContractProcessor
-from cic.output import KVWriter
+from cic.contract.components.proof import Proof
-from cic.processor import Processor
+from cic.contract.components.attachment import Attachment
 
 
 # test imports
@@ -127,4 +127,4 @@ class TestCICEthTokenBase(TestCICEthBase):
         self.token_precision = 8
         self.token_supply = 1073741824
 
-        self.core_processor = Processor(outputs_writer=self.outputs_writer, extensions=[self.adapter])
+        self.core_processor = ContractProcessor(outputs_writer=self.outputs_writer, extensions=[self.adapter])

tests/eth/test_eth_full.py

@@ -27,8 +27,8 @@ from giftable_erc20_token import GiftableToken
         
 # local imports
 from cic.ext.eth import CICEth
-from cic.processor import Processor
+from cic.contract.processor import ContractProcessor
-from cic.token import Token
+from cic.contract.components.token import Token
 
 # test imports
 from tests.eth.base_eth import TestCICEthTokenBase
@@ -46,7 +46,7 @@ class TestCICEthRPC(TestCICEthTokenBase):
         gas_oracle = RPCGasOracle(self.rpc)
 
         self.adapter = CICEth(self.chain_spec, self.resources, self.proofs, signer=self.signer, rpc=self.rpc, fee_oracle=gas_oracle, outputs_writer=self.outputs_writer)
-        self.core_processor = Processor(outputs_writer=self.outputs_writer, extensions=[self.adapter])
+        self.core_processor = ContractProcessor(outputs_writer=self.outputs_writer, extensions=[self.adapter])
 
 
     def test_rpc_process_notoken(self):

tests/eth/test_eth_offline.py

@@ -5,7 +5,7 @@ import os
 
 # local imports
 from cic.ext.eth import CICEth
-from cic.processor import Processor
+from cic.contract.processor import ContractProcessor
 
 # tests imports
 from tests.eth.base_eth import TestCICEthBase

tests/eth/test_eth_sign.py

@@ -11,7 +11,7 @@ from hexathon import (
 
 # local imports
 from cic.ext.eth import CICEth
-from cic.processor import Processor
+from cic.contract.processor import ContractProcessor
 
 # tests imports
 from tests.eth.base_eth import TestCICEthBase
@@ -25,7 +25,7 @@ class TestCICEthSign(TestCICEthBase):
     def setUp(self):
         super(TestCICEthSign, self).setUp()
         self.adapter = CICEth(self.chain_spec, self.resources, self.proofs, signer=self.signer)
-        self.core_processor = Processor(outputs_writer=self.outputs_writer, extensions=[self.adapter])
+        self.core_processor = ContractProcessor(outputs_writer=self.outputs_writer, extensions=[self.adapter])
 
 
     def test_sign_token_index(self):

tests/test_keyfile.py

@@ -1,14 +1,16 @@
 # standard imports
+import logging
 import os
 import unittest
-import logging
 
 # local imports
-from cic.keystore import KeystoreDirectory
-from funga.eth.keystore.dict import DictKeystore
 from funga.error import DecryptError
+from funga.eth.keystore.dict import DictKeystore
 from hexathon import uniform as hex_uniform
 
+# external imports
+from cic.keystore import KeystoreDirectory
+
 # test imports
 from tests.base_cic import test_base_dir
 
@@ -16,8 +18,9 @@ logging = logging.getLogger()
 
 script_dir = test_base_dir
 
+
 def pass_getter():
-    return 'test'
+    return "test"
 
 
 class EthKeystoreDirectory(DictKeystore, KeystoreDirectory):
@@ -25,25 +28,25 @@ class EthKeystoreDirectory(DictKeystore, KeystoreDirectory):
 
 
 class TestKeyfile(unittest.TestCase):
-
     def setUp(self):
-        self.path = os.path.join(script_dir, 'testdata', 'keystore')
+        self.path = os.path.join(script_dir, "testdata", "keystore")
         self.keystore = EthKeystoreDirectory()
 
-
     def test_keystore_bogus(self):
-        bogus_path = os.path.join(self.path, 'bogus')
+        bogus_path = os.path.join(self.path, "bogus")
         self.keystore.process_dir(bogus_path)
 
-
     def test_keystore_ok(self):
-        ok_path = os.path.join(self.path, 'ok')
+        ok_path = os.path.join(self.path, "ok")
         with self.assertRaises(DecryptError):
             self.keystore.process_dir(ok_path)  # wrong password
-        self.keystore.process_dir(ok_path, default_password='test')
+        self.keystore.process_dir(ok_path, default_password="test")
         self.keystore.process_dir(ok_path, password_retriever=pass_getter)
-        self.assertTrue(hex_uniform('cc4f82F5DacDE395E1E0CFc4d62827C8B8B5688C') in self.keystore.list())
+        self.assertTrue(
+            hex_uniform("cc4f82F5DacDE395E1E0CFc4d62827C8B8B5688C")
+            in self.keystore.list()
+        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

tests/test_meta.py

@@ -7,25 +7,49 @@ import os
 from hexathon import strip_0x
 
 # local imports
-from cic.meta import Meta
+from cic.contract.components.meta import Meta
 
 # test imports
-from tests.base_cic import (
+from tests.base_cic import TestCICBase, test_data_dir
-        TestCICBase,
-        test_data_dir,
-        )
 
 logging.basicConfig(level=logging.DEBUG)
 logg = logging.getLogger()
 
 
 class TestCICMeta(TestCICBase):
-
     def test_meta(self):
-        fp = os.path.join(test_data_dir, 'proof')
+        fp = os.path.join(test_data_dir, "proof")
         m = Meta(fp)
         m.load()
+        self.assertEquals(
+            str(m),
+            """name = Test
+contact.phone = 0700-123456
+country_code = KE
+location = Kilifi
+""",
+        )
+
+    def test_meta_with_initial_values(self):
+        fp = os.path.join(test_data_dir, "proof")
+        m = Meta(
+            fp,
+            name="TestName",
+            location="TestLocation",
+            country_code="TestCC",
+            contact={
+                "phone": "0723578455158",
+            },
+        )
+        self.assertEquals(
+            str(m),
+            """name = TestName
+contact.phone = 0723578455158
+country_code = TestCC
+location = TestLocation
+""",
+        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

tests/test_processor.py

@@ -3,17 +3,12 @@ import unittest
 import logging
 import os
 import json
-import sys
-
-# external imports
-from hexathon import strip_0x
 
 # local imports
-from cic import Proof
+from cic.contract.processor import ContractProcessor
-from cic.processor import Processor
+from cic.contract.components.proof import Proof
-from cic.attachment import Attachment
+from cic.contract.components.attachment import Attachment
-from cic.meta import Meta
+from cic.contract.components.meta import Meta
-from cic.output import KVWriter
 
 # test imports
 from tests.base_cic import (
@@ -28,66 +23,65 @@ logg.setLevel(logging.DEBUG)
 
 
 class MockExt:
-
     def __init__(self, address):
         self.address = address
 
     def process(self):
-        return (self.address, 'foo')
+        return (self.address, "foo")
 
 
 class TestCICProcessor(TestCICBase):
-
     def test_processor_meta(self):
-        fp = os.path.join(test_data_dir, 'proof')
+        fp = os.path.join(test_data_dir, "proof")
         m = Meta(fp)
         m.load()
 
         mock_ext = MockExt(self.token_address)
-        p = Processor(metadata=m, outputs_writer=self.outputs_writer, extensions=[mock_ext])
+        p = ContractProcessor(
+            metadata=m, outputs_writer=self.outputs_writer, extensions=[mock_ext]
+        )
         p.token_address = self.token_address
         p.process()
 
         meta_reference = m.reference(self.token_address)
 
         fp = os.path.join(self.outputs_dir, meta_reference)
-        f = open(fp, 'r')
+        with open(fp, "r", encoding="utf-8") as f:
             o = json.load(f)
-        f.close()
         self.assertEqual(m.asdict(), o)
 
-
     def test_processor_attachment(self):
-        fp = os.path.join(test_data_dir, 'proof')
+        fp = os.path.join(test_data_dir, "proof")
         m = Attachment(fp)
         m.load()
 
         mock_ext = MockExt(self.token_address)
-        p = Processor(attachment=m, outputs_writer=self.outputs_writer, extensions=[mock_ext])
+        p = ContractProcessor(
+            attachment=m, outputs_writer=self.outputs_writer, extensions=[mock_ext]
+        )
         p.process()
 
-
+        for _k in list(m.contents.keys()):
-        for k in list(m.contents.keys()):
             os.stat(fp)
 
-
     def test_processor_proof_noattachment(self):
-        fp = os.path.join(test_data_dir, 'proof')
+        fp = os.path.join(test_data_dir, "proof")
         m = Proof(fp)
 
-        ap = os.path.join(test_data_dir, 'proof_empty')
+        ap = os.path.join(test_data_dir, "proof_empty")
         m.extra_attachments = Attachment(ap)
         m.load()
 
         mock_ext = MockExt(self.token_address)
-        p = Processor(proof=m, outputs_writer=self.outputs_writer, extensions=[mock_ext])
+        p = ContractProcessor(
+            proof=m, outputs_writer=self.outputs_writer, extensions=[mock_ext]
+        )
         p.process()
 
         self.assertEqual(p.outputs[0], root_unmerged_hash)
 
-
     def test_processor_proof_attachment(self):
-        fp = os.path.join(test_data_dir, 'proof')
+        fp = os.path.join(test_data_dir, "proof")
 
         ma = Attachment(fp)
         ma.load()
@@ -96,11 +90,13 @@ class TestCICProcessor(TestCICBase):
         mp.load()
 
         mock_ext = MockExt(self.token_address)
-        p = Processor(proof=mp, outputs_writer=self.outputs_writer, extensions=[mock_ext])
+        p = ContractProcessor(
+            proof=mp, outputs_writer=self.outputs_writer, extensions=[mock_ext]
+        )
         p.process()
 
         self.assertEqual(p.outputs[0], root_merged_hash)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

tests/test_proof.py

@@ -4,23 +4,35 @@ import unittest
 import logging
 
 # local imports
-from cic import Proof
+from cic.contract.components.proof import Proof
-from cic.attachment import Attachment
+from cic.contract.components.attachment import Attachment
 
 # test imports
-from tests.base_cic import (
+from tests.base_cic import test_data_dir, TestCICBase, root_merged_hash
-        test_data_dir,
-        TestCICBase,
-        root_merged_hash,
-        )
 
 logging.basicConfig(level=logging.DEBUG)
 logg = logging.getLogger()
 
 class TestProof(TestCICBase):
+    def test_proof_load(self):
+        proof_path = os.path.join(test_data_dir, "proof")
+        attach = Attachment(proof_path, writer=self.outputs_writer)
+        attach.load()
+        c = Proof(path=proof_path, attachments=attach)
+        c.load()
+        self.assertEquals(
+            str(c),
+            """description = foo bar baz
+issuer = the man
+namespace = ge
+version = 0
+proofs[0] = 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae
+proofs[1] = fcde2b2edba56bf408601fb721fe9b5c338d10ee429ea04fae5511b68fbf8fb9
+""",
+        )
 
     def test_proof_serialize_merge(self):
-        proof_path = os.path.join(test_data_dir, 'proof')
+        proof_path = os.path.join(test_data_dir, "proof")
 
         attach = Attachment(proof_path, writer=self.outputs_writer)
         attach.load()
@@ -31,5 +43,5 @@ class TestProof(TestCICBase):
         self.assertEqual(v, root_merged_hash)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

tests/test_writers.py

@@ -7,7 +7,7 @@ import logging
 from hexathon import strip_0x
         
 # local imports
-from cic.output import KVWriter
+from cic.writers import KVWriter
 
 # test imports
 from tests.base_cic import TestCICBase

tests/testdata/proof/meta.json

@@ -1,7 +1,8 @@
 {
-	"name": "",
+	"name": "Test",
-	"location": "",
+	"location": "Kilifi",
-	"country_code": "",
+	"country_code": "KE",
 	"contact": {
+		"phone": "0700-123456"
 	}
 }