352 lines
12 KiB
Python
352 lines
12 KiB
Python
# standard import
|
|
import importlib
|
|
import json
|
|
import logging
|
|
import os
|
|
import subprocess
|
|
|
|
import requests
|
|
|
|
# external imports
|
|
from chainlib.chain import ChainSpec
|
|
|
|
# local imports
|
|
from cic import Proof
|
|
from cic.actions.deploy import deploy
|
|
from cic.attachment import Attachment
|
|
from cic.meta import Meta
|
|
from cic.network import Network
|
|
from cic.token import Token
|
|
|
|
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 Tech 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)",
|
|
)
|
|
|
|
|
|
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/DemurrageTokenMultiCap",
|
|
"name": "Demurrage Token Multi Cap (Might not work)",
|
|
},
|
|
{
|
|
"url": "https://gitlab.com/cicnet/erc20-demurrage-token/-/raw/master/python/erc20_demurrage_token/data/DemurrageTokenMultiNocap",
|
|
"name": "Demurrage Token Multi No Cap (Might not work)",
|
|
},
|
|
{
|
|
"url": "https://gitlab.com/cicnet/erc20-demurrage-token/-/raw/master/python/erc20_demurrage_token/data/DemurrageTokenSingleCap",
|
|
"name": "Demurrage Token Single Cap (Might not work)",
|
|
},
|
|
{
|
|
"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))
|
|
print(f"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(f"Contracts:")
|
|
print(f"\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(contract["url"] + ".bin", directory)
|
|
else:
|
|
print("Invalid selection")
|
|
exit(1)
|
|
extra_args = []
|
|
extra_args_types = []
|
|
|
|
if os.path.exists(json_path):
|
|
json_data = json.load(open(json_path))
|
|
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}): ")
|
|
extra_args.append(val)
|
|
extra_args_types.append(arg_type)
|
|
|
|
return {
|
|
"bin_path": bin_path,
|
|
"json_path": json_path,
|
|
"extra_args": extra_args,
|
|
"extra_args_types": extra_args_types,
|
|
}
|
|
|
|
|
|
def init_token(
|
|
directory: str,
|
|
code="",
|
|
extra_args=[],
|
|
extra_args_types=[],
|
|
):
|
|
contract = select_contract()
|
|
code = contract["bin_path"]
|
|
extra_args = contract["extra_args"]
|
|
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=extra_args,
|
|
extra_args_types=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 init_network(
|
|
directory, registry_address,key_account_address, chain_spec, rpc_provider, targets=["eth"]
|
|
):
|
|
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=registry_address,
|
|
chain_spec=chain_spec,
|
|
rpc_provider=rpc_provider,
|
|
key_account_address=key_account_address
|
|
)
|
|
contract_network.load()
|
|
return contract_network
|
|
|
|
|
|
def execute(config, eargs):
|
|
directory = eargs.path
|
|
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}")
|
|
target = eargs.target
|
|
if not eargs.skip_gen:
|
|
os.makedirs(directory)
|
|
# Defaults
|
|
default_contract_registry = config.get(
|
|
"CIC_CONTRACT_REGISTRY_ADDRESS",
|
|
"0xcf60ebc445b636a5ab787f9e8bc465a2a3ef8299",
|
|
)
|
|
default_key_account = config.get(
|
|
"CIC_KEY_ACCOUNT_ADDRESS", "eb3907ecad74a0013c259d5874ae7f22dcbcc95c"
|
|
)
|
|
default_metadata_endpoint = "http://localhost:63380" or config.get(
|
|
"META_ENDPOINT", "http://localhost:63380"
|
|
)
|
|
default_wallet_keyfile = config.get(
|
|
"WALLET_KEY_FILE",
|
|
"/home/will/grassroots/cic-internal-integration/apps/cic-ussd/tests/data/pgp/privatekeys_meta.asc",
|
|
)
|
|
default_wallet_passphrase = config.get("WALLET_PASSPHRASE", "merman")
|
|
|
|
default_chain_spec = config.get("CHAIN_SPEC", "evm:byzantium:8996:bloxberg")
|
|
default_rpc_provider = config.get("RPC_PROVIDER", "http://localhost:63545")
|
|
|
|
# Options
|
|
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
|
|
)
|
|
|
|
token = init_token(directory)
|
|
proof = init_proof(directory)
|
|
meta = init_meta(directory)
|
|
attachment = init_attachment(directory)
|
|
network = init_network(
|
|
directory,
|
|
registry_address=contract_registry,
|
|
key_account_address=key_account,
|
|
chain_spec=chain_spec,
|
|
rpc_provider=rpc_provider,
|
|
targets=[target],
|
|
)
|
|
print(f"[cic.header]\nversion = {proof.version()}\n")
|
|
print(f"[cic.token]\n{token}")
|
|
print(f"[cic.proof]\n{proof}")
|
|
print(f"[cic.meta]\n{meta}")
|
|
print(f"[cic.attachment]\n{attachment}")
|
|
print(f"[cic.network]\n{network}")
|
|
if not eargs.skip_deploy:
|
|
ready_to_deploy = input("Ready to deploy? (y/n): ")
|
|
if ready_to_deploy == "y":
|
|
deploy(
|
|
config,
|
|
contract_directory=directory,
|
|
gpg_passphrase=default_wallet_passphrase,
|
|
key_file_path=default_wallet_keyfile,
|
|
metadata_endpoint=metadata_endpoint,
|
|
keystore_directory="/home/will/grassroots/cic-internal-integration/apps/contract-migration/keystore",
|
|
target=target,
|
|
)
|
|
print("Deployed")
|
|
else:
|
|
print("Not deploying")
|
|
|
|
|
|
#
|
|
#
|
|
# rpc="http://localhost:63545"
|
|
|
|
# python -m cic.runnable.cic_cmd init --target eth --name "$token_name" --symbol $token_symbol --precision 6 $token_symbol_lowercase
|
|
|
|
# python -m cic.runnable.cic_cmd ext -p $rpc -i $chain_spec --registry $contract_registry -d $token_symbol_lowercase eth -vv
|
|
# python -m cic.runnable.cic_cmd export -p $rpc --metadata-endpoint http://localhost:63380 -vv -y /home/will/grassroots/cic-internal-integration/apps/contract-migration/keystore -o $token_symbol_lowercase/out -d $token_symbol_lowercase eth
|
|
if __name__ == "__main__":
|
|
execute()
|