391 lines
12 KiB
Python
391 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
# standard import
|
|
import importlib
|
|
import json
|
|
import logging
|
|
import os
|
|
from typing import TYPE_CHECKING, List
|
|
|
|
import requests
|
|
|
|
# external imports
|
|
from chainlib.chain import ChainSpec
|
|
|
|
# local imports
|
|
from cic import Proof
|
|
from cic.actions.deploy import deploy
|
|
from cic.actions.types import Contract, Options
|
|
from cic.attachment import Attachment
|
|
from cic.meta import Meta
|
|
from cic.network import Network
|
|
from cic.token import Token
|
|
|
|
if TYPE_CHECKING:
|
|
from chainlib.cli.config import Config
|
|
|
|
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
|
|
|
|
|
|
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, directory: str, filename=None) -> (str, bytes):
|
|
os.makedirs(directory, exist_ok=True)
|
|
filename = filename if filename else url.split("/")[-1]
|
|
path = os.path.join(directory, filename)
|
|
if not os.path.exists(path):
|
|
log.debug(f"Downloading {filename}")
|
|
r = requests.get(url, allow_redirects=True)
|
|
open(path, "wb").write(r.content)
|
|
return 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 print_contract_args(json_path: str):
|
|
json_data = json.load(open(json_path, encoding="utf-8"))
|
|
print("Contract Args:")
|
|
for contract_arg in get_contract_args(json_data):
|
|
print(
|
|
f"\t{contract_arg.get('name', '<no name>')} - {contract_arg.get('type', '<no type>')}"
|
|
)
|
|
|
|
|
|
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)]
|
|
directory = f"./contracts/{contract['name']}"
|
|
bin_path = os.path.abspath(download_file(contract["url"] + ".bin", directory))
|
|
json_path = download_file(contract["url"] + ".json", directory)
|
|
elif val == "C":
|
|
possible_bin_location = input("Enter path/url to contract: ")
|
|
# possible_bin_location is path
|
|
if possible_bin_location[0] == "." or possible_bin_location[0] == "/":
|
|
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
|
|
# possible_bin_location is url
|
|
else:
|
|
bin_path = download_file(possible_bin_location, directory)
|
|
else:
|
|
print("Invalid selection")
|
|
exit(1)
|
|
contract_extra_args = []
|
|
contract_extra_args_types = []
|
|
|
|
if os.path.exists(json_path):
|
|
json_data = json.load(open(json_path, encoding="utf-8"))
|
|
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,
|
|
}
|
|
|
|
|
|
def init_token(directory: str, code=""):
|
|
contract = select_contract()
|
|
code = contract["bin_path"]
|
|
contract_extra_args = contract["extra_args"]
|
|
contract_extra_args_types = contract["extra_args_types"]
|
|
|
|
name = input("Enter Token Name (Foo Token): ") or "Foo Token"
|
|
symbol = input("Enter Token Symbol (FOO): ") or "FOO"
|
|
precision = input("Enter Token Precision (6): ") or 6
|
|
supply = input("Enter Token Supply (0): ") or 0
|
|
|
|
contract_token = Token(
|
|
directory,
|
|
name=name,
|
|
symbol=symbol,
|
|
precision=precision,
|
|
extra_args=contract_extra_args,
|
|
extra_args_types=contract_extra_args_types,
|
|
supply=supply,
|
|
code=code,
|
|
)
|
|
contract_token.start()
|
|
return contract_token
|
|
|
|
|
|
def init_proof(directory):
|
|
description = input("Enter Proof Description (None): ") or None
|
|
namespace = input("Enter Proof Namespace (ge): ") or "ge"
|
|
issuer = input("Enter Proof Issuer (None): ") or None
|
|
contract_proof = Proof(directory, description, namespace, issuer)
|
|
contract_proof.start()
|
|
return contract_proof
|
|
|
|
|
|
def init_meta(directory):
|
|
name = input("Enter Name (None): ") or ""
|
|
country_code = input("Enter Country Code (KE): ") or "KE"
|
|
location = input("Enter Location (None): ") or ""
|
|
adding_contact_info = True
|
|
contact = {}
|
|
while adding_contact_info:
|
|
value = input("Enter 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
|
|
contract_meta = Meta(
|
|
directory,
|
|
name=name,
|
|
country_code=country_code,
|
|
location=location,
|
|
contact=contact,
|
|
)
|
|
contract_meta.start()
|
|
return contract_meta
|
|
|
|
|
|
def init_attachment(directory):
|
|
contract_attchment = Attachment(directory)
|
|
contract_attchment.start()
|
|
input(
|
|
f"Please add attachment files to '{os.path.abspath(os.path.join(directory,'attachments'))}' and then press ENTER to continue"
|
|
)
|
|
contract_attchment.load()
|
|
return contract_attchment
|
|
|
|
|
|
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 init_network(
|
|
directory,
|
|
options: Options,
|
|
targets: List[str],
|
|
):
|
|
contract_network = Network(directory, targets=targets)
|
|
contract_network.start()
|
|
|
|
for target in targets:
|
|
m = importlib.import_module(f"cic.ext.{target}.start")
|
|
m.extension_start(
|
|
contract_network,
|
|
registry_address=options.contract_registry,
|
|
chain_spec=options.chain_spec,
|
|
rpc_provider=options.rpc_provider,
|
|
key_account_address=options.key_account,
|
|
)
|
|
contract_network.load()
|
|
return contract_network
|
|
|
|
|
|
def generate(directory: str, target: str, options: Options) -> Contract:
|
|
if os.path.exists(directory):
|
|
contine = input(
|
|
"Directory already exists, Would you like to delete it? (y/n): "
|
|
)
|
|
if contine.lower() != "y":
|
|
print("Exiting")
|
|
exit(1)
|
|
else:
|
|
print(f"Deleted {directory}")
|
|
os.system(f"rm -rf {directory}")
|
|
os.makedirs(directory)
|
|
|
|
token = init_token(directory)
|
|
proof = init_proof(directory)
|
|
meta = init_meta(directory)
|
|
attachment = init_attachment(directory)
|
|
network = init_network(
|
|
directory,
|
|
options,
|
|
targets=[target],
|
|
)
|
|
return Contract(
|
|
token=token, proof=proof, meta=meta, attachment=attachment, network=network
|
|
)
|
|
|
|
|
|
def get_options(config: Config, eargs) -> Options:
|
|
# Defaults
|
|
default_contract_registry = config.get(
|
|
"CIC_REGISTRY_ADDRESS"
|
|
) # Comes from /home/will/grassroots/cic-staff-installer/var/cic-staff-client/CIC_REGISTRY_ADDRESS
|
|
default_key_account = config.get("AUTH_KEY")
|
|
# https://meta.grassrootseconomics.net
|
|
# https://auth.grassrootseconomics.net Authenticated Meta
|
|
|
|
default_metadata_endpoint = config.get("META_URL")
|
|
# Keyring folder needs to be dumped out as a private key file from $HOME/.config/cic/staff-client/.gnupg
|
|
default_wallet_keyfile = eargs.y or config.get(
|
|
"WALLET_KEY_FILE"
|
|
) # Show possible wallet keys
|
|
|
|
# Should be an input???
|
|
default_wallet_passphrase = config.get("WALLET_PASSPHRASE", "merman")
|
|
default_chain_spec = config.get("CHAIN_SPEC")
|
|
default_rpc_provider = config.get("RPC_PROVIDER")
|
|
|
|
contract_registry = (
|
|
input(f"Enter Contract Registry ({default_contract_registry}): ")
|
|
or default_contract_registry
|
|
)
|
|
rpc_provider = (
|
|
input(f"Enter RPC Provider ({default_rpc_provider}): ") or default_rpc_provider
|
|
)
|
|
chain_spec = ChainSpec.from_chain_str(
|
|
(input(f"Enter ChainSpec ({default_chain_spec}): ") or default_chain_spec)
|
|
)
|
|
key_account = (
|
|
input(f"Enter KeyAccount ({default_key_account}): ") or default_key_account
|
|
)
|
|
metadata_endpoint = (
|
|
input(f"Enter Metadata Endpoint ({default_metadata_endpoint}): ")
|
|
or default_metadata_endpoint
|
|
)
|
|
auth_passphrase = config.get("AUTH_PASSPHRASE")
|
|
auth_keyfile_path = config.get("AUTH_KEYFILE_PATH")
|
|
auth_db_path = config.get("AUTH_DB_PATH")
|
|
|
|
options = Options(
|
|
auth_db_path,
|
|
auth_keyfile_path,
|
|
auth_passphrase,
|
|
contract_registry,
|
|
key_account,
|
|
chain_spec,
|
|
rpc_provider,
|
|
metadata_endpoint,
|
|
default_wallet_keyfile,
|
|
default_wallet_passphrase,
|
|
)
|
|
print(options)
|
|
return options
|
|
|
|
|
|
|
|
|
|
|
|
ExtraArgs = {"skip_gen": str, "skip_deploy": str, "target": str, "path": str, "p": str}
|
|
|
|
|
|
def execute(config, eargs: ExtraArgs):
|
|
print(f"eargs: {eargs}")
|
|
directory = eargs.path
|
|
target = eargs.target
|
|
skip_gen = eargs.skip_gen
|
|
skip_deploy = eargs.skip_deploy
|
|
|
|
options = get_options(config, eargs)
|
|
|
|
if not skip_gen:
|
|
contract = generate(directory, target, options)
|
|
else:
|
|
contract = load_contract(directory)
|
|
|
|
print_contract(contract)
|
|
|
|
if not skip_deploy:
|
|
ready_to_deploy = input("Ready to deploy? (y/n): ")
|
|
if ready_to_deploy == "y":
|
|
deploy(
|
|
config=config,
|
|
contract_directory=directory,
|
|
options=options,
|
|
target=target,
|
|
)
|
|
print("Deployed")
|
|
else:
|
|
print("Not deploying")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# execute()
|
|
print("Not Implemented")
|