cic-internal-integration/apps/contract-migration/scripts/proofs.py

129 lines
5.5 KiB
Python
Raw Normal View History

2021-11-17 09:20:31 +01:00
# standard imports
import hashlib
import json
import logging
import os
from typing import Union
# external imports
import cic_eth.cli
from chainlib.chain import ChainSpec
from chainlib.eth.connection import EthHTTPConnection
from chainlib.eth.gas import OverrideGasOracle
from chainlib.eth.nonce import RPCNonceOracle
from cic_types.condiments import MetadataPointer
from cic_types.ext.metadata import MetadataRequestsHandler, Signer
from eth_address_declarator import Declarator
from eth_address_declarator.declarator import AddressDeclarator
from funga.eth.signer import EIP155Signer
from funga.eth.keystore.dict import DictKeystore
from hexathon import add_0x, strip_0x
from okota.token_index.index import to_identifier
2021-11-17 09:20:31 +01:00
# local imports
logging.basicConfig(level=logging.WARNING)
logg = logging.getLogger()
script_dir = os.path.dirname(os.path.realpath(__file__))
root_dir = os.path.join(script_dir, '..')
base_config_dir = os.path.join(root_dir, 'config', 'proofs')
token_data_dir = os.path.join(root_dir, 'token_data')
arg_flags = cic_eth.cli.argflag_std_base
arg_parser = cic_eth.cli.ArgumentParser(arg_flags)
arg_parser.add_argument('--token-symbol', type=str, help='Token symbol whose metadata is being processed.')
arg_parser.add_argument('--address-declarator', type=str, help='Address to address declarator contract')
arg_parser.add_argument('--signer-address', type=str, help='Wallet keyfile address')
arg_parser.add_argument('-e', type=str, help='Token address.')
args = arg_parser.parse_args()
config = cic_eth.cli.Config.from_args(args, arg_flags, 0, base_config_dir=base_config_dir)
token_metadata = os.path.join(token_data_dir, 'meta.json')
token_proof = os.path.join(token_data_dir, 'proof.json')
def hash_proof(data: bytes) -> hex:
hash_object = hashlib.sha256()
hash_object.update(data)
return hash_object.digest().hex()
def init_meta():
MetadataRequestsHandler.base_url = config.get('META_URL')
Signer.gpg_path = config.get('PGP_EXPORT_DIR')
Signer.key_file_path = f"{config.get('PGP_KEYS_PATH')}{config.get('PGP_PRIVATE_KEYS')}"
Signer.gpg_passphrase = config.get('PGP_PASSPHRASE')
def wrapper(chain_spec: ChainSpec, rpc: EthHTTPConnection) -> Declarator:
gas_oracle = OverrideGasOracle(limit=AddressDeclarator.gas(), conn=rpc)
nonce_oracle = RPCNonceOracle(address=add_0x(args.signer_address.lower()), conn=rpc)
keystore = DictKeystore()
keystore.import_keystore_file(keystore_file=config.get('WALLET_KEY_FILE'))
signer = EIP155Signer(keystore)
return Declarator(chain_spec, gas_oracle=gas_oracle, nonce_oracle=nonce_oracle, signer=signer)
2021-11-29 16:04:50 +01:00
def write_to_declarator(contract_address: hex, contract_wrapper: Declarator, proof: any, rpc: EthHTTPConnection,
signer_address: hex, token_address: hex):
2021-11-17 09:20:31 +01:00
operation = contract_wrapper.add_declaration(contract_address, signer_address, token_address, proof)
results = rpc.do(operation[1])
rpc.wait(results)
def write_metadata(writer: MetadataRequestsHandler, data: Union[dict, str]):
writer.create(data)
if __name__ == '__main__':
init_meta()
chain_spec = ChainSpec.from_chain_str(config.get('CHAIN_SPEC'))
token_address_bytes = bytes.fromhex(strip_0x(args.e))
token_symbol_bytes = args.token_symbol.encode('utf-8')
token_meta_file = open(token_metadata, 'r')
token_proof_file = open(token_proof, 'r')
token_meta_data = json.load(token_meta_file)
token_proof_data = json.load(token_proof_file)
token_meta_file.close()
token_proof_file.close()
token_meta_writer = MetadataRequestsHandler(cic_type=MetadataPointer.TOKEN_META, identifier=token_address_bytes)
write_metadata(token_meta_writer, token_meta_data)
2021-11-29 16:04:50 +01:00
token_meta_symbol_writer = MetadataRequestsHandler(cic_type=MetadataPointer.TOKEN_META_SYMBOL,
identifier=token_symbol_bytes)
2021-11-17 09:20:31 +01:00
write_metadata(token_meta_symbol_writer, token_meta_data)
token_proof_writer = MetadataRequestsHandler(cic_type=MetadataPointer.TOKEN_PROOF, identifier=token_address_bytes)
write_metadata(token_proof_writer, token_proof_data)
2021-11-29 16:04:50 +01:00
token_proof_symbol_writer = MetadataRequestsHandler(cic_type=MetadataPointer.TOKEN_PROOF_SYMBOL,
identifier=token_symbol_bytes)
2021-11-17 09:20:31 +01:00
write_metadata(token_proof_symbol_writer, token_proof_data)
rpc = EthHTTPConnection(url=config.get('RPC_PROVIDER'), chain_spec=chain_spec)
contract_wrapper = wrapper(chain_spec, rpc)
hashed_token_proof = hash_proof(data=json.dumps(token_proof_data).encode('utf-8'))
identifier = bytes.fromhex(hashed_token_proof)
token_immutable_proof_writer = MetadataRequestsHandler(cic_type=MetadataPointer.NONE, identifier=identifier)
write_metadata(token_immutable_proof_writer, token_proof_data)
logg.debug(f'Writing hashed proof: {hashed_token_proof}')
2021-11-17 09:20:31 +01:00
write_to_declarator(contract_address=args.address_declarator,
contract_wrapper=contract_wrapper,
proof=hashed_token_proof,
rpc=rpc,
signer_address=args.signer_address,
token_address=args.e)
2021-11-29 16:04:50 +01:00
hashed_token_proof = to_identifier(args.token_symbol)
logg.debug(f'Writing hashed proof: {hashed_token_proof}')
2021-11-29 16:04:50 +01:00
write_to_declarator(contract_address=args.address_declarator,
contract_wrapper=contract_wrapper,
proof=hashed_token_proof,
2021-11-29 16:04:50 +01:00
rpc=rpc,
signer_address=args.signer_address,
token_address=args.e)