chainlib

Generic blockchain access library and tooling
Log | Files | Refs | README | LICENSE

commit 1b946447ae5feac97373bf942a76b0c59df594ac
parent 64ba891b21564c342d976693bbae902c1f4e48fd
Author: Louis Holbrook <accounts-gitlab@holbrook.no>
Date:   Sat, 21 Aug 2021 07:31:59 +0000

Add docstrings

Diffstat:
MCHANGELOG | 8+++++++-
MMANIFEST.in | 2+-
MREADME.md | 2+-
Achainlib/auth.py | 32++++++++++++++++++++++++++++++++
Mchainlib/block.py | 59+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mchainlib/chain.py | 66+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
Achainlib/cli/__init__.py | 10++++++++++
Achainlib/cli/arg.py | 101+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Achainlib/cli/base.py | 38++++++++++++++++++++++++++++++++++++++
Achainlib/cli/config.py | 159+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Achainlib/cli/rpc.py | 82+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Achainlib/cli/wallet.py | 57+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mchainlib/connection.py | 183++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------
Achainlib/data/config/config.ini | 12++++++++++++
Mchainlib/error.py | 17++++++++++++++++-
Dchainlib/eth/address.py | 13-------------
Dchainlib/eth/block.py | 70----------------------------------------------------------------------
Dchainlib/eth/connection.py | 130-------------------------------------------------------------------------------
Dchainlib/eth/constant.py | 5-----
Dchainlib/eth/contract.py | 288-------------------------------------------------------------------------------
Dchainlib/eth/error.py | 23-----------------------
Dchainlib/eth/gas.py | 138-------------------------------------------------------------------------------
Dchainlib/eth/jsonrpc.py | 16----------------
Dchainlib/eth/nonce.py | 62--------------------------------------------------------------
Dchainlib/eth/pytest/__init__.py | 3---
Dchainlib/eth/pytest/fixtures_chain.py | 17-----------------
Dchainlib/eth/pytest/fixtures_ethtester.py | 105-------------------------------------------------------------------------------
Dchainlib/eth/pytest/fixtures_signer.py | 18------------------
Dchainlib/eth/runnable/__init__.py | 0
Dchainlib/eth/runnable/balance.py | 91-------------------------------------------------------------------------------
Dchainlib/eth/runnable/checksum.py | 15---------------
Dchainlib/eth/runnable/count.py | 60------------------------------------------------------------
Dchainlib/eth/runnable/decode.py | 50--------------------------------------------------
Dchainlib/eth/runnable/gas.py | 163-------------------------------------------------------------------------------
Dchainlib/eth/runnable/get.py | 118-------------------------------------------------------------------------------
Dchainlib/eth/runnable/info.py | 154-------------------------------------------------------------------------------
Dchainlib/eth/runnable/raw.py | 175-------------------------------------------------------------------------------
Dchainlib/eth/runnable/subscribe.py | 21---------------------
Dchainlib/eth/runnable/util.py | 22----------------------
Dchainlib/eth/sign.py | 23-----------------------
Dchainlib/eth/tx.py | 442-------------------------------------------------------------------------------
Dchainlib/eth/unittest/base.py | 218-------------------------------------------------------------------------------
Dchainlib/eth/unittest/ethtester.py | 80-------------------------------------------------------------------------------
Mchainlib/hash.py | 30+++++++++++++++++++++++++-----
Mchainlib/http.py | 13++++++++-----
Achainlib/interface.py | 255+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mchainlib/jsonrpc.py | 157++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------
Mchainlib/stat.py | 16++++++++++++++++
Mchainlib/status.py | 2++
Achainlib/tx.py | 14++++++++++++++
Mrequirements.txt | 6++----
Msetup.cfg | 23++++-------------------
Msetup.py | 14+++-----------
Dtest_requirements.txt | 4----
Dtests/test_abi.py | 29-----------------------------
Dtests/test_address.py | 35-----------------------------------
Atests/test_interface.py | 28++++++++++++++++++++++++++++
Dtests/test_nonce.py | 26--------------------------
Dtests/test_sign.py | 119-------------------------------------------------------------------------------
Dtests/test_stat.py | 49-------------------------------------------------
Dtests/test_tx.py | 30------------------------------
Dtests/testdata/keystore/UTC--2021-01-08T17-18-44.521011372Z--eb3907ecad74a0013c259d5874ae7f22dcbcc95c | 2--
62 files changed, 1301 insertions(+), 2899 deletions(-)

diff --git a/CHANGELOG b/CHANGELOG @@ -1,4 +1,10 @@ -- 0.0.3-pending +- 0.0.5-pending + * Move eth code to separate package +- 0.0.4-unreleased + * Add pack tx from already signed tx struct + * Add http auth handling for jsonrpc connections + * Add customizable jsonrpc id generator (to allow for buggy server id handling) +- 0.0.3-unreleased * Remove erc20 module (to new external package) - 0.0.2-unreleased * diff --git a/MANIFEST.in b/MANIFEST.in @@ -1 +1 @@ -include requirements.txt +include *requirements.txt LICENSE chainlib/data/config/* diff --git a/README.md b/README.md @@ -28,7 +28,7 @@ Chainlib is not compatible with python2, nor is there any reason to expect it wi Any generalizable structures and code can be found in the base module directory `chainlib/` -Currently the only operational code for available targets is for the `evm` and the `Ethereum` network protocol. This code can be found in `chainlib/eth`. +Currently the only operational code for available targets is for the `evm` and the `Ethereum` network protocol. This code can be found in the separate package `chainlib-eth`. Every module will have a subdirectory `runnable` which contains CLI convenience tooling for common operations. Any directory `example` will contain code snippets demonstrating usage. diff --git a/chainlib/auth.py b/chainlib/auth.py @@ -0,0 +1,32 @@ +# standard imports +import base64 + + +class Auth: + + def urllib_header(self): + raise NotImplementedError() + + +class BasicAuth(Auth): + + def __init__(self, username, password): + self.username = username + self.password = password + + + def urllib_header(self): + s = '{}:{}'.format(self.username, self.password) + b = base64.b64encode(s.encode('utf-8')) + return (('Authorization'), ('Basic ' + b.decode('utf-8')),) + + +class CustomHeaderTokenAuth(Auth): + + def __init__(self, header_name, auth_token): + self.header_name = header_name + self.auth_token = auth_token + + + def urllib_header(self): + return (self.header_name, self.auth_token,) diff --git a/chainlib/block.py b/chainlib/block.py @@ -1,7 +1,66 @@ # standard imports import enum +# local imports +from chainlib.tx import Tx + class BlockSpec(enum.IntEnum): + """General-purpose block-height value designators + """ PENDING = -1 LATEST = 0 + + +class Block: + """Base class to extend for implementation specific block object. + """ + + tx_generator = Tx + + + def src(self): + """Return implementation specific block representation. + + :rtype: dict + :returns: Block representation + """ + return self.block_src + + + def tx(self, idx): + """Return transaction object for transaction data at given index. + + :param idx: Transaction index + :type idx: int + :rtype: chainlib.tx.Tx + :returns: Transaction object + """ + return self.tx_generator(self.txs[idx], self) + + + def tx_src(self, idx): + """Return implementation specific transaction representation for transaction data at given index + + :param idx: Transaction index + :type idx: int + :rtype: chainlib.tx.Tx + :returns: Transaction representation + """ + return self.txs[idx] + + + def __str__(self): + return 'block {} {} ({} txs)'.format(self.number, self.hash, len(self.txs)) + + + @classmethod + def from_src(cls, src): + """Instantiate an implementation specific block object from the given block representation. + + :param src: Block representation + :type src: dict + :rtype: chainlib.block.Block + :returns: Block object + """ + return cls(src) diff --git a/chainlib/chain.py b/chainlib/chain.py @@ -3,7 +3,19 @@ import copy class ChainSpec: - + """Encapsulates a 3- to 4-part chain identifier, describing the architecture used and common name of the chain, along with the network id of the connected network. + + The optional fourth field can be used to add a description value, independent of the chain identifier value. + + :param engine: Chain architecture + :type engine: str + :param common_name: Well-known name of chain + :type common_name: str + :param network_id: Chain network identifier + :type network_id: int + :param tag: Descriptive tag + :type tag: str + """ def __init__(self, engine, common_name, network_id, tag=None): self.o = { 'engine': engine, @@ -13,23 +25,56 @@ class ChainSpec: } def network_id(self): + """Returns the network id part of the spec. + + :rtype: int + :returns: network_id + """ return self.o['network_id'] def chain_id(self): + """Alias of network_id + + :rtype: int + :returns: network_id + """ return self.o['network_id'] def engine(self): + """Returns the chain architecture part of the spec + + :rtype: str + :returns: engine + """ return self.o['engine'] def common_name(self): + """Returns the common name part of the spec + + :rtype: str + :returns: common_name + """ return self.o['common_name'] @staticmethod def from_chain_str(chain_str): + """Create a new ChainSpec object from a colon-separated string, as output by the string representation of the ChainSpec object. + + String must be in one of the following formats: + + - <engine>:<common_name>:<network_id> + - <engine>:<common_name>:<network_id>:<tag> + + :param chain_str: Chainspec string + :type chain_str: str + :raises ValueError: Malformed chain string + :rtype: chainlib.chain.ChainSpec + :returns: Resulting chain spec + """ o = chain_str.split(':') if len(o) < 3: raise ValueError('Chain string must have three sections, got {}'.format(len(o))) @@ -41,10 +86,29 @@ class ChainSpec: @staticmethod def from_dict(o): + """Create a new ChainSpec object from a dictionary, as output from the asdict method. + + The chain spec is described by the following keys: + + - engine + - common_name + - network_id + - tag (optional) + + :param o: Chainspec dictionary + :type o: dict + :rtype: chainlib.chain.ChainSpec + :returns: Resulting chain spec + """ return ChainSpec(o['engine'], o['common_name'], o['network_id'], tag=o['tag']) def asdict(self): + """Create a dictionary representation of the chain spec. + + :rtype: dict + :returns: Chain spec dictionary + """ return copy.copy(self.o) diff --git a/chainlib/cli/__init__.py b/chainlib/cli/__init__.py @@ -0,0 +1,10 @@ +from .base import ( + Flag, + argflag_std_read, + argflag_std_write, + argflag_std_base, + ) +from .arg import ArgumentParser +from .config import Config +from .rpc import Rpc +from .wallet import Wallet diff --git a/chainlib/cli/arg.py b/chainlib/cli/arg.py @@ -0,0 +1,101 @@ +# standard imports +import logging +import argparse +import enum +import os +import select +import sys + +# local imports +from .base import ( + default_config_dir, + Flag, + argflag_std_target, + ) + +logg = logging.getLogger(__name__) + + +def stdin_arg(): + h = select.select([sys.stdin], [], [], 0) + if len(h[0]) > 0: + v = h[0][0].read() + return v.rstrip() + return None + + +class ArgumentParser(argparse.ArgumentParser): + + def __init__(self, arg_flags=0x0f, env=os.environ, usage=None, description=None, epilog=None, *args, **kwargs): + super(ArgumentParser, self).__init__(usage=usage, description=description, epilog=epilog) + self.process_flags(arg_flags, env) + self.pos_args = [] + + + def add_positional(self, name, type=str, help=None, required=True): + self.pos_args.append((name, type, help, required,)) + + + def parse_args(self, argv=sys.argv[1:]): + if len(self.pos_args) == 1: + arg = self.pos_args[0] + self.add_argument(arg[0], nargs='?', type=arg[1], default=stdin_arg(), help=arg[2]) + else: + for arg in self.pos_args: + if arg[3]: + self.add_argument(arg[0], type=arg[1], help=arg[2]) + else: + self.add_argument(arg[0], nargs='?', type=arg[1], help=arg[2]) + args = super(ArgumentParser, self).parse_args(args=argv) + + if len(self.pos_args) == 1: + arg = self.pos_args[0] + argname = arg[0] + required = arg[3] + if getattr(args, arg[0], None) == None: + argp = stdin_arg() + if argp == None and required: + self.error('need first positional argument or value from stdin') + setattr(args, arg[0], argp) + + return args + + + def process_flags(self, arg_flags, env): + if arg_flags & Flag.VERBOSE: + self.add_argument('-v', action='store_true', help='Be verbose') + self.add_argument('-vv', action='store_true', help='Be more verbose') + if arg_flags & Flag.CONFIG: + self.add_argument('-c', '--config', type=str, default=env.get('CONFINI_DIR'), help='Configuration directory') + self.add_argument('-n', '--namespace', type=str, help='Configuration namespace') + if arg_flags & Flag.WAIT: + self.add_argument('-w', action='store_true', help='Wait for the last transaction to be confirmed') + self.add_argument('-ww', action='store_true', help='Wait for every transaction to be confirmed') + if arg_flags & Flag.ENV_PREFIX: + self.add_argument('--env-prefix', default=env.get('CONFINI_ENV_PREFIX'), dest='env_prefix', type=str, help='environment prefix for variables to overwrite configuration') + if arg_flags & Flag.PROVIDER: + self.add_argument('-p', '--provider', dest='p', type=str, help='RPC HTTP(S) provider url') + self.add_argument('--height', default='latest', help='Block height to execute against') + if arg_flags & Flag.CHAIN_SPEC: + self.add_argument('-i', '--chain-spec', dest='i', type=str, help='Chain specification string') + if arg_flags & Flag.UNSAFE: + self.add_argument('-u', '--unsafe', dest='u', action='store_true', help='Do not verify address checksums') + if arg_flags & Flag.SEQ: + self.add_argument('--seq', action='store_true', help='Use sequential rpc ids') + if arg_flags & Flag.KEY_FILE: + self.add_argument('-y', '--key-file', dest='y', type=str, help='Keystore file to use for signing or address') + if arg_flags & Flag.SEND: + self.add_argument('-s', '--send', dest='s', action='store_true', help='Send to network') + if arg_flags & Flag.RAW: + self.add_argument('--raw', action='store_true', help='Do not decode output') + if arg_flags & Flag.SIGN: + self.add_argument('--nonce', type=int, help='override nonce') + self.add_argument('--fee-price', dest='fee_price', type=int, help='override fee price') + self.add_argument('--fee-limit', dest='fee_limit', type=int, help='override fee limit') + if arg_flags & argflag_std_target == 0: + arg_flags |= Flag.WALLET + if arg_flags & Flag.EXEC: + self.add_argument('-e', '--exectuable-address', dest='executable_address', type=str, help='contract address') + if arg_flags & Flag.WALLET: + self.add_argument('-a', '--recipient', dest='recipient', type=str, help='recipient address') + diff --git a/chainlib/cli/base.py b/chainlib/cli/base.py @@ -0,0 +1,38 @@ +# standard imports +import enum +import os + + +script_dir = os.path.dirname(os.path.realpath(__file__)) + +default_config_dir = os.path.join(script_dir, '..', 'data', 'config') + + +# powers of two +class Flag(enum.IntEnum): + # read - nibble 1-2 + VERBOSE = 1 + CONFIG = 2 + RAW = 4 + ENV_PREFIX = 8 + PROVIDER = 16 + CHAIN_SPEC = 32 + UNSAFE = 64 + SEQ = 128 + # read/write - nibble 3 + KEY_FILE = 256 + # write - nibble 4 + SIGN = 4096 + NO_TARGET = 8192 + EXEC = 16384 + WALLET = 32768 + # network - nibble 5 + WAIT = 65536 + WAIT_ALL = 131072 + SEND = 262144 + + +argflag_std_read = 0x2fff +argflag_std_write = 0xff3fff +argflag_std_base = 0x200f +argflag_std_target = 0x00e000 diff --git a/chainlib/cli/config.py b/chainlib/cli/config.py @@ -0,0 +1,159 @@ +# standard imports +import logging +import os + +# external imports +import confini + +# local imports +from .base import ( + Flag, + default_config_dir as default_parent_config_dir, + ) + +#logg = logging.getLogger(__name__) +logg = logging.getLogger() + + +def logcallback(config): + logg.debug('config loaded:\n{}'.format(config)) + + +class Config(confini.Config): + + default_base_config_dir = default_parent_config_dir + default_fee_limit = 0 + + @classmethod + def from_args(cls, args, arg_flags, extra_args={}, base_config_dir=None, default_config_dir=None, user_config_dir=None, default_fee_limit=None, logger=None, load_callback=logcallback): + + if logger == None: + logger = logging.getLogger() + + if arg_flags & Flag.CONFIG: + if args.vv: + logger.setLevel(logging.DEBUG) + elif args.v: + logger.setLevel(logging.INFO) + + override_config_dirs = [] + config_dir = [cls.default_base_config_dir] + + if user_config_dir == None: + try: + import xdg.BaseDirectory + user_config_dir = xdg.BaseDirectory.load_first_config('chainlib/eth') + except ModuleNotFoundError: + pass + + # if one or more additional base dirs are defined, add these after the default base dir + # the consecutive dirs cannot include duplicate sections + if base_config_dir != None: + logg.debug('have explicit base config addition {}'.format(base_config_dir)) + if isinstance(base_config_dir, str): + base_config_dir = [base_config_dir] + for d in base_config_dir: + config_dir.append(d) + logg.debug('processing config dir {}'.format(config_dir)) + + # confini dir env var will be used for override configs only in this case + if default_config_dir == None: + default_config_dir = os.environ.get('CONFINI_DIR') + if default_config_dir != None: + if isinstance(default_config_dir, str): + default_config_dir = [default_config_dir] + for d in default_config_dir: + override_config_dirs.append(d) + + # process config command line arguments + if arg_flags & Flag.CONFIG: + + effective_user_config_dir = getattr(args, 'config', None) + if effective_user_config_dir == None: + effective_user_config_dir = user_config_dir + + if effective_user_config_dir != None: + if config_dir == None: + if getattr(args, 'namespace', None) != None: + arg_config_dir = os.path.join(effective_user_config_dir, args.namespace) + config_dir = [cls.default_base_config_dir, effective_user_config_dir] + logg.debug('using config arg as base config addition {}'.format(effective_user_config_dir)) + else: + if getattr(args, 'namespace', None) != None: + arg_config_dir = os.path.join(effective_user_config_dir, args.namespace) + override_config_dirs.append(effective_user_config_dir) + logg.debug('using config arg as config override {}'.format(effective_user_config_dir)) + + + if config_dir == None: + if default_config_dir == None: + default_config_dir = default_parent_config_dir + config_dir = default_config_dir + override_config_dirs = [] + env_prefix = getattr(args, 'env_prefix', None) + + config = confini.Config(config_dir, env_prefix=args.env_prefix, override_dirs=override_config_dirs) + config.process() + + args_override = {} + + if arg_flags & Flag.PROVIDER: + args_override['RPC_HTTP_PROVIDER'] = getattr(args, 'p') + if arg_flags & Flag.CHAIN_SPEC: + args_override['CHAIN_SPEC'] = getattr(args, 'i') + if arg_flags & Flag.KEY_FILE: + args_override['WALLET_KEY_FILE'] = getattr(args, 'y') + + config.dict_override(args_override, 'cli args') + + if arg_flags & Flag.PROVIDER: + config.add(getattr(args, 'height'), '_HEIGHT') + if arg_flags & Flag.UNSAFE: + config.add(getattr(args, 'u'), '_UNSAFE') + if arg_flags & Flag.SEND: + fee_limit = getattr(args, 'fee_limit') + if fee_limit == None: + fee_limit = default_fee_limit + if fee_limit == None: + fee_limit = cls.default_fee_limit + config.add(fee_limit, '_FEE_LIMIT') + config.add(getattr(args, 'fee_price'), '_FEE_PRICE') + config.add(getattr(args, 'nonce'), '_NONCE') + config.add(getattr(args, 's'), '_RPC_SEND') + + # handle wait + wait = 0 + if args.w: + wait |= Flag.WAIT + if args.ww: + wait |= Flag.WAIT_ALL + wait_last = wait & (Flag.WAIT | Flag.WAIT_ALL) + config.add(bool(wait_last), '_WAIT') + wait_all = wait & Flag.WAIT_ALL + config.add(bool(wait_all), '_WAIT_ALL') + if arg_flags & Flag.SEQ: + config.add(getattr(args, 'seq'), '_SEQ') + if arg_flags & Flag.WALLET: + config.add(getattr(args, 'recipient'), '_RECIPIENT') + if arg_flags & Flag.EXEC: + config.add(getattr(args, 'executable_address'), '_EXEC_ADDRESS') + + config.add(getattr(args, 'raw'), '_RAW') + + for k in extra_args.keys(): + v = extra_args[k] + if v == None: + v = '_' + k.upper() + r = getattr(args, k) + existing_r = None + try: + existing_r = config.get(v) + except KeyError: + pass + if existing_r == None or r != None: + config.add(r, v, exists_ok=True) + + if load_callback != None: + load_callback(config) + + return config diff --git a/chainlib/cli/rpc.py b/chainlib/cli/rpc.py @@ -0,0 +1,82 @@ +# standard imports +import logging + +# external imports +from chainlib.chain import ChainSpec +from chainlib.connection import RPCConnection +from chainlib.jsonrpc import IntSequenceGenerator +from chainlib.eth.nonce import ( + RPCNonceOracle, + OverrideNonceOracle, + ) +from chainlib.eth.gas import ( + RPCGasOracle, + OverrideGasOracle, + ) +from chainlib.error import SignerMissingException + +logg = logging.getLogger(__name__) + + +class Rpc: + + def __init__(self, cls, wallet=None): + self.constructor = cls + self.id_generator = None + self.conn = None + self.chain_spec = None + self.wallet = wallet + self.nonce_oracle = None + self.gas_oracle = None + + + def connect_by_config(self, config): + auth = None + if config.get('RPC_HTTP_AUTHENTICATION') == 'basic': + from chainlib.auth import BasicAuth + auth = BasicAuth(config.get('RPC_HTTP_USERNAME'), config.get('RPC_HTTP_PASSWORD')) + logg.debug('using basic http auth') + + if config.get('_SEQ'): + self.id_generator = IntSequenceGenerator() + + self.chain_spec = config.get('CHAIN_SPEC') + self.conn = self.constructor(url=config.get('RPC_HTTP_PROVIDER'), chain_spec=self.chain_spec, auth=auth) + + if self.can_sign(): + nonce = config.get('_NONCE') + if nonce != None: + self.nonce_oracle = OverrideNonceOracle(self.get_sender_address(), nonce, id_generator=self.id_generator) + else: + self.nonce_oracle = RPCNonceOracle(self.get_sender_address(), self.conn, id_generator=self.id_generator) + + fee_price = config.get('_FEE_PRICE') + fee_limit = config.get('_FEE_LIMIT') + if fee_price != None or fee_limit != None: + self.gas_oracle = OverrideGasOracle(price=fee_price, limit=fee_limit, conn=self.conn, id_generator=self.id_generator) + else: + self.gas_oracle = RPCGasOracle(self.conn, id_generator=self.id_generator) + + return self.conn + + + def get_nonce_oracle(self): + return self.nonce_oracle + + + def get_gas_oracle(self): + return self.gas_oracle + + + def can_sign(self): + return self.wallet != None and self.wallet.signer != None + + + def get_signer(self): + if self.wallet.signer == None: + raise SignerMissingException() + return self.wallet.signer + + + def get_sender_address(self): + return self.wallet.signer_address diff --git a/chainlib/cli/wallet.py b/chainlib/cli/wallet.py @@ -0,0 +1,57 @@ +# standard imports +import logging + +# external imports +from crypto_dev_signer.keystore.dict import DictKeystore + +logg = logging.getLogger(__name__) + + +class Wallet: + + def __init__(self, signer_cls, keystore=DictKeystore(), checksummer=None): + self.signer_constructor = signer_cls + self.keystore = keystore + self.signer = None + self.signer_address = None + self.nonce_oracle = None + self.gas_oracle = None + self.checksummer = checksummer + self.use_checksum = False + + + def from_config(self, config): + wallet_keyfile = config.get('WALLET_KEY_FILE') + if wallet_keyfile: + logg.debug('keyfile {}'.format(wallet_keyfile)) + self.from_keyfile(wallet_keyfile, passphrase=config.get('WALLET_PASSPHRASE', '')) + self.use_checksum = not config.true('_UNSAFE') + + + def from_keyfile(self, key_file, passphrase=''): + logg.debug('importing key from keystore file {}'.format(key_file)) + self.signer_address = self.keystore.import_keystore_file(key_file, password=passphrase) + self.signer = self.signer_constructor(self.keystore) + logg.info('key for {} imported from keyfile {}'.format(self.signer_address, key_file)) + return self.signer + + + def from_address(self, address): + self.signer_address = address + if self.use_checksum: + if self.checksummer == None: + raise AttributeError('checksum required but no checksummer assigned') + if not self.checksummer.valid(self.signer_address): + raise ValueError('invalid checksum address {}'.format(self.signer_address)) + elif self.checksummer != None: + self.signer_address = self.checksummer.sum(self.signer_address) + logg.info('sender_address set to {}'.format(self.signer_address)) + return self.signer_address + + + def get_signer(self): + return self.signer + + + def get_signer_address(self): + return self.signer_address diff --git a/chainlib/connection.py b/chainlib/connection.py @@ -5,6 +5,7 @@ import logging import enum import re import json +import base64 from urllib.request import ( Request, urlopen, @@ -13,22 +14,26 @@ from urllib.request import ( build_opener, install_opener, ) +from urllib.error import URLError # local imports from .jsonrpc import ( - jsonrpc_template, + JSONRPCRequest, jsonrpc_result, - DefaultErrorParser, + ErrorParser, ) from .http import PreemptiveBasicAuthHandler +from .error import JSONRPCException +from .auth import Auth -logg = logging.getLogger().getChild(__name__) +logg = logging.getLogger(__name__) -error_parser = DefaultErrorParser() +error_parser = ErrorParser() class ConnType(enum.Enum): - + """Describe the underlying RPC connection type. + """ CUSTOM = 0x00 HTTP = 0x100 HTTP_SSL = 0x101 @@ -41,7 +46,15 @@ re_http = '^http(s)?://' re_ws = '^ws(s)?://' re_unix = '^ipc://' + def str_to_connspec(s): + """Determine the connection type from a connection string. + + :param s: Connection string + :type d: str + :rtype: chainlib.connection.ConnType + :returns: Connection type value + """ if s == 'custom': return ConnType.CUSTOM @@ -57,7 +70,6 @@ def str_to_connspec(s): return ConnType.WEBSOCKET_SSL return ConnType.WEBSOCKET - m = re.match(re_unix, s) if m != None: return ConnType.UNIX @@ -65,7 +77,20 @@ def str_to_connspec(s): raise ValueError('unknown connection type {}'.format(s)) -class RPCConnection(): + +class RPCConnection: + """Base class for defining an RPC connection to a chain node. + + This class may be instantiated directly, or used as an object factory to provide a thread-safe RPC connection mechanism to a single RPC node. + + :param url: A valid URL connection string for the RPC connection + :type url: str + :param chain_spec: The chain spec of + :type chain_spec: chainlib.chain.ChainSpec + :param auth: Authentication settings to use when connecting + :type auth: chainlib.auth.Auth + :todo: basic auth is currently parsed from the connection string, should be auth object instead. auth object effectively not in use. + """ __locations = {} __constructors = { @@ -74,15 +99,20 @@ class RPCConnection(): } __constructors_for_chains = {} - def __init__(self, url=None, chain_spec=None): + def __init__(self, url=None, chain_spec=None, auth=None): self.chain_spec = chain_spec self.location = None self.basic = None if url == None: return + self.auth = auth + if self.auth != None and not isinstance(self.auth, Auth): + raise TypeError('auth parameter needs to be subclass of chainlib.auth.Auth') url_parsed = urlparse(url) logg.debug('creating connection {} -> {}'.format(url, url_parsed)) + + # TODO: temporary basic auth parse basic = url_parsed.netloc.split('@') location = None if len(basic) == 1: @@ -93,6 +123,7 @@ class RPCConnection(): #if url_parsed.port != None: # location += ':' + str(url_parsed.port) + # self.location = os.path.join('{}://'.format(url_parsed.scheme), location) self.location = urljoin(self.location, url_parsed.path) @@ -101,20 +132,50 @@ class RPCConnection(): @staticmethod def from_conntype(t, tag='default'): + """Retrieve a connection constructor from the given tag and connection type. + + :param t: Connection type + :type t: chainlib.connection.ConnType + :param tag: The connection selector tag + :type tag: + """ return RPCConnection.__constructors[tag][t] @staticmethod - def register_constructor(t, c, tag='default'): + def register_constructor(conntype, c, tag='default'): + """Associate a connection constructor for a given tag and connection type. + + The constructor must be a chainlib.connection.RPCConnection object or an object of a subclass thereof. + + :param conntype: Connection type of constructor + :type conntype: chainlib.connection.ConnType + :param c: Constructor + :type c: chainlib.connection.RPCConnection + :param tag: Tag to store the connection constructor under + :type tag: str + """ if RPCConnection.__constructors.get(tag) == None: RPCConnection.__constructors[tag] = {} - RPCConnection.__constructors[tag][t] = c - logg.info('registered RPC connection constructor {} for type {} tag {}'.format(c, t, tag)) + RPCConnection.__constructors[tag][conntype] = c + logg.info('registered RPC connection constructor {} for type {} tag {}'.format(c, conntype, tag)) # TODO: constructor needs to be constructor-factory, that itself can select on url type @staticmethod def register_location(location, chain_spec, tag='default', exist_ok=False): + """Associate a URL for a given tag and chain spec. + + :param location: URL of RPC connection + :type location: str + :param chain_spec: Chain spec describing the chain behind the RPC connection + :type chain_spec: chainlib.chain.ChainSpec + :param tag: Tag to store the connection location under + :type tag: str + :param exist_ok: Overwrite existing record + :type exist_ok: bool + :raises ValueError: Record already exists, and exist_ok is not set + """ chain_str = str(chain_spec) if RPCConnection.__locations.get(chain_str) == None: RPCConnection.__locations[chain_str] = {} @@ -129,6 +190,19 @@ class RPCConnection(): @staticmethod def connect(chain_spec, tag='default'): + """Connect to the location defined by the given tag and chain spec, using the associated constructor. + + Location must first be registered using the RPCConnection.register_location method. + + Constructor must first be registered using the RPCConnection.register_constructor method. + + :param chain_spec: Chain spec part of the location record + :type chain_spec: chainlib.chain.ChainSpec + :param tag: Tag part of the location record + :type tag: str + :rtype: chainlib.connection.RPCConnection + :returns: Instantiation of the matching registered constructor + """ chain_str = str(chain_spec) c = RPCConnection.__locations[chain_str][tag] constructor = RPCConnection.from_conntype(c[0], tag=tag) @@ -136,9 +210,9 @@ class RPCConnection(): return constructor(url=c[1], chain_spec=chain_spec) -class HTTPConnection(RPCConnection): - def disconnect(self): + """Should be overridden to clean up any resources bound by the connect method. + """ pass @@ -146,27 +220,84 @@ class HTTPConnection(RPCConnection): self.disconnect() -class UnixConnection(RPCConnection): - def disconnect(self): - pass +class HTTPConnection(RPCConnection): + """Generic HTTP connection subclass of RPCConnection + """ + pass + - def __del__(self): - self.disconnect() +class UnixConnection(RPCConnection): + """Generic Unix socket connection subclass of RPCConnection + """ + pass + class JSONRPCHTTPConnection(HTTPConnection): + """Generic JSON-RPC specific HTTP connection wrapper. + """ + + def check_rpc(self): + """Check if RPC connection is a valid JSON-RPC endpoint. + + :raises Exception: Invalid connection. + """ + j = JSONRPCRequest() + req = j.template() + req['method'] = 'ping' + try: + self.do(req) + except JSONRPCException: + pass + + + def check(self): + """Check if endpoint is reachable. + + :rtype: bool + :returns: True if reachable + """ + try: + self.check_rpc() + except URLError as e: + logg.error('cannot connect to node {}; {}'.format(self.location, e)) + return False + return True + def do(self, o, error_parser=error_parser): + """Execute a JSON-RPC query, from dict as generated by chainlib.jsonrpc.JSONRPCRequest:finalize. + + If connection was created with an auth object, the auth object will be used to authenticate the query. + + If connection was created with a basic url string, the corresponding basic auth credentials will be used to authenticate the query. + + :param o: JSON-RPC query object + :type o: dict + :param error_parser: Error parser object to process JSON-RPC error response with. + :type error_parser: chainlib.jsonrpc.ErrorParser + :raises ValueError: Invalid response from JSON-RPC endpoint + :raises URLError: Endpoint could not be reached + :rtype: any + :returns: Result value part of JSON RPC response + :todo: Invalid response exception from invalid json response + """ req = Request( self.location, method='POST', ) req.add_header('Content-Type', 'application/json') + + # use specific auth if present + if self.auth != None: + p = self.auth.urllib_header() + req.add_header(p[0], p[1]) data = json.dumps(o) logg.debug('(HTTP) send {}'.format(data)) + # use basic auth if present if self.basic != None: handler = PreemptiveBasicAuthHandler() handler.add_password( @@ -177,8 +308,9 @@ class JSONRPCHTTPConnection(HTTPConnection): ) ho = build_opener(handler) install_opener(ho) - + r = urlopen(req, data=data.encode('utf-8')) + result = json.load(r) logg.debug('(HTTP) recv {}'.format(result)) if o['id'] != result['id']: @@ -187,6 +319,18 @@ class JSONRPCHTTPConnection(HTTPConnection): class JSONRPCUnixConnection(UnixConnection): + """Execute a JSON-RPC query, from dict as generated by chainlib.jsonrpc.JSONRPCRequest:finalize. + + :param o: JSON-RPC query object + :type o: dict + :param error_parser: Error parser object to process JSON-RPC error response with. + :type error_parser: chainlib.jsonrpc.ErrorParser + :raises ValueError: Invalid response from JSON-RPC endpoint + :raises IOError: Endpoint could not be reached + :rtype: any + :returns: Result value part of JSON RPC response + :todo: Invalid response exception from invalid json response + """ def do(self, o, error_parser=error_parser): conn = socket.socket(family=socket.AF_UNIX, type=socket.SOCK_STREAM, proto=0) @@ -217,6 +361,7 @@ class JSONRPCUnixConnection(UnixConnection): return jsonrpc_result(result, error_parser) +# TODO: Automatic creation should be hidden behind symbol, in the spirit of no unsolicited side-effects. (perhaps connection should be module dir, and jsonrpc a submodule) RPCConnection.register_constructor(ConnType.HTTP, JSONRPCHTTPConnection, tag='default') RPCConnection.register_constructor(ConnType.HTTP_SSL, JSONRPCHTTPConnection, tag='default') RPCConnection.register_constructor(ConnType.UNIX, JSONRPCUnixConnection, tag='default') diff --git a/chainlib/data/config/config.ini b/chainlib/data/config/config.ini @@ -0,0 +1,12 @@ +[rpc] +http_provider = +http_authentication = +http_username = +http_password = + +[chain] +spec = + +[wallet] +key_file = +passphrase = diff --git a/chainlib/error.py b/chainlib/error.py @@ -1,7 +1,22 @@ # TODO: use json-rpc module -class JSONRPCException(Exception): +class RPCException(Exception): + """Base RPC connection error + """ + pass + + +class JSONRPCException(RPCException): + """Base JSON-RPC error + """ pass class ExecutionError(Exception): + """Base error for transaction execution failures + """ pass + + +class SignerMissingException(Exception): + """Raised when attempting to retrieve a signer when none has been added + """ diff --git a/chainlib/eth/address.py b/chainlib/eth/address.py @@ -1,13 +0,0 @@ -# third-party imports -import sha3 -from hexathon import ( - strip_0x, - uniform, - ) -from crypto_dev_signer.encoding import ( - is_address, - is_checksum_address, - to_checksum_address, - ) - -to_checksum = to_checksum_address diff --git a/chainlib/eth/block.py b/chainlib/eth/block.py @@ -1,70 +0,0 @@ -# third-party imports -from chainlib.jsonrpc import jsonrpc_template -from chainlib.eth.tx import Tx -from hexathon import ( - add_0x, - strip_0x, - even, - ) - - -def block_latest(): - o = jsonrpc_template() - o['method'] = 'eth_blockNumber' - return o - - -def block_by_hash(hsh, include_tx=True): - o = jsonrpc_template() - o['method'] = 'eth_getBlockByHash' - o['params'].append(hsh) - o['params'].append(include_tx) - return o - - -def block_by_number(n, include_tx=True): - nhx = add_0x(even(hex(n)[2:])) - o = jsonrpc_template() - o['method'] = 'eth_getBlockByNumber' - o['params'].append(nhx) - o['params'].append(include_tx) - return o - - -def transaction_count(block_hash): - o = jsonrpc_template() - o['method'] = 'eth_getBlockTransactionCountByHash' - o['params'].append(block_hash) - return o - - -class Block: - - def __init__(self, src): - self.hash = src['hash'] - try: - self.number = int(strip_0x(src['number']), 16) - except TypeError: - self.number = int(src['number']) - self.txs = src['transactions'] - self.block_src = src - try: - self.timestamp = int(strip_0x(src['timestamp']), 16) - except TypeError: - self.timestamp = int(src['timestamp']) - - - def src(self): - return self.block_src - - - def tx(self, i): - return Tx(self.txs[i], self) - - - def tx_src(self, i): - return self.txs[i] - - - def __str__(self): - return 'block {} {} ({} txs)'.format(self.number, self.hash, len(self.txs)) diff --git a/chainlib/eth/connection.py b/chainlib/eth/connection.py @@ -1,130 +0,0 @@ -# standard imports -import copy -import logging -import json -import datetime -import time -import socket -from urllib.request import ( - Request, - urlopen, - ) - -# third-party imports -from hexathon import ( - add_0x, - strip_0x, - ) - -# local imports -from .error import ( - DefaultErrorParser, - RevertEthException, - ) -from .sign import ( - sign_transaction, - ) -from chainlib.connection import ( - ConnType, - RPCConnection, - JSONRPCHTTPConnection, - JSONRPCUnixConnection, - error_parser, - ) -from chainlib.jsonrpc import ( - jsonrpc_template, - jsonrpc_result, - ) -from chainlib.eth.tx import ( - unpack, - ) - -logg = logging.getLogger(__name__) - - -class EthHTTPConnection(JSONRPCHTTPConnection): - - def wait(self, tx_hash_hex, delay=0.5, timeout=0.0, error_parser=error_parser): - t = datetime.datetime.utcnow() - i = 0 - while True: - o = jsonrpc_template() - o['method'] ='eth_getTransactionReceipt' - o['params'].append(add_0x(tx_hash_hex)) - req = Request( - self.location, - method='POST', - ) - req.add_header('Content-Type', 'application/json') - data = json.dumps(o) - logg.debug('(HTTP) poll receipt attempt {} {}'.format(i, data)) - res = urlopen(req, data=data.encode('utf-8')) - r = json.load(res) - - e = jsonrpc_result(r, error_parser) - if e != None: - logg.debug('(HTTP) poll receipt completed {}'.format(r)) - logg.debug('e {}'.format(strip_0x(e['status']))) - if strip_0x(e['status']) == '00': - raise RevertEthException(tx_hash_hex) - return e - - if timeout > 0.0: - delta = (datetime.datetime.utcnow() - t) + datetime.timedelta(seconds=delay) - if delta.total_seconds() >= timeout: - raise TimeoutError(tx_hash) - - time.sleep(delay) - i += 1 - - -class EthUnixConnection(JSONRPCUnixConnection): - - def wait(self, tx_hash_hex, delay=0.5, timeout=0.0, error_parser=error_parser): - raise NotImplementedError('Not yet implemented for unix socket') - - -def sign_transaction_to_rlp(chain_spec, doer, tx): - txs = tx.serialize() - logg.debug('serializing {}'.format(txs)) - # TODO: because some rpc servers may fail when chainId is included, we are forced to spend cpu here on this - chain_id = txs.get('chainId') or 1 - if chain_spec != None: - chain_id = chain_spec.chain_id() - txs['chainId'] = add_0x(chain_id.to_bytes(2, 'big').hex()) - txs['from'] = add_0x(tx.sender) - o = sign_transaction(txs) - r = doer(o) - logg.debug('sig got {}'.format(r)) - return bytes.fromhex(strip_0x(r)) - - -def sign_message(doer, msg): - o = sign_message(msg) - return doer(o) - - -class EthUnixSignerConnection(EthUnixConnection): - - def sign_transaction_to_rlp(self, tx): - return sign_transaction_to_rlp(self.chain_spec, self.do, tx) - - - def sign_message(self, tx): - return sign_message(self.do, tx) - - -class EthHTTPSignerConnection(EthHTTPConnection): - - def sign_transaction_to_rlp(self, tx): - return sign_transaction_to_rlp(self.chain_spec, self.do, tx) - - - def sign_message(self, tx): - return sign_message(self.do, tx) - - - -RPCConnection.register_constructor(ConnType.HTTP, EthHTTPConnection, tag='eth_default') -RPCConnection.register_constructor(ConnType.HTTP_SSL, EthHTTPConnection, tag='eth_default') -RPCConnection.register_constructor(ConnType.UNIX, EthUnixConnection, tag='eth_default') diff --git a/chainlib/eth/constant.py b/chainlib/eth/constant.py @@ -1,5 +0,0 @@ -ZERO_ADDRESS = '0x{:040x}'.format(0) -ZERO_CONTENT = '0x{:064x}'.format(0) -MINIMUM_FEE_UNITS = 21000 -MINIMUM_FEE_PRICE = 1000000000 -MAX_UINT = int('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16) diff --git a/chainlib/eth/contract.py b/chainlib/eth/contract.py @@ -1,288 +0,0 @@ -# standard imports -import enum -import re -import logging - -# external imports -from hexathon import ( - strip_0x, - pad, - ) - -# local imports -from chainlib.hash import keccak256_string_to_hex -from chainlib.block import BlockSpec -from chainlib.jsonrpc import jsonrpc_template -from .address import to_checksum_address - -#logg = logging.getLogger(__name__) -logg = logging.getLogger() - - -re_method = r'^[a-zA-Z0-9_]+$' - -class ABIContractType(enum.Enum): - - BYTES32 = 'bytes32' - BYTES4 = 'bytes4' - UINT256 = 'uint256' - ADDRESS = 'address' - STRING = 'string' - BOOLEAN = 'bool' - -dynamic_contract_types = [ - ABIContractType.STRING, - ] - -class ABIContractDecoder: - - def __init__(self): - self.types = [] - self.contents = [] - - - def typ(self, v): - if not isinstance(v, ABIContractType): - raise TypeError('method type not valid; expected {}, got {}'.format(type(ABIContractType).__name__, type(v).__name__)) - self.types.append(v.value) - self.__log_typ() - - - def val(self, v): - self.contents.append(v) - logg.debug('content is now {}'.format(self.contents)) - - - def uint256(self, v): - return int(v, 16) - - - def bytes32(self, v): - return v - - - def bool(self, v): - return bool(self.uint256(v)) - - - def boolean(self, v): - return bool(self.uint256(v)) - - - def address(self, v): - a = strip_0x(v)[64-40:] - return to_checksum_address(a) - - - def string(self, v): - s = strip_0x(v) - b = bytes.fromhex(s) - cursor = 0 - offset = int.from_bytes(b[cursor:cursor+32], 'big') - cursor += 32 - length = int.from_bytes(b[cursor:cursor+32], 'big') - cursor += 32 - content = b[cursor:cursor+length] - logg.debug('parsing string offset {} length {} content {}'.format(offset, length, content)) - return content.decode('utf-8') - - - def __log_typ(self): - logg.debug('types set to ({})'.format(','.join(self.types))) - - - def decode(self): - r = [] - for i in range(len(self.types)): - m = getattr(self, self.types[i]) - r.append(m(self.contents[i])) - return r - - - def get(self): - return self.decode() - - - def __str__(self): - return self.decode() - - - -class ABIContractEncoder: - - - def __init__(self): - self.types = [] - self.contents = [] - self.method_name = None - self.method_contents = [] - - - def method(self, m): - if re.match(re_method, m) == None: - raise ValueError('Invalid method {}, must match regular expression {}'.format(re_method)) - self.method_name = m - self.__log_method() - - - def typ(self, v): - if self.method_name == None: - raise AttributeError('method name must be set before adding types') - if not isinstance(v, ABIContractType): - raise TypeError('method type not valid; expected {}, got {}'.format(type(ABIContractType).__name__, type(v).__name__)) - self.method_contents.append(v.value) - self.__log_method() - - - def __log_method(self): - logg.debug('method set to {}'.format(self.get_method())) - - - def __log_latest(self, v): - l = len(self.types) - 1 - logg.debug('Encoder added {} -> {} ({})'.format(v, self.contents[l], self.types[l].value)) - - - def uint256(self, v): - v = int(v) - b = v.to_bytes(32, 'big') - self.contents.append(b.hex()) - self.types.append(ABIContractType.UINT256) - self.__log_latest(v) - - - def bool(self, v): - return self.boolean(v) - - - def boolean(self, v): - if bool(v): - return self.uint256(1) - return self.uint256(0) - - - def address(self, v): - self.bytes_fixed(32, v, 20) - self.types.append(ABIContractType.ADDRESS) - self.__log_latest(v) - - - def bytes32(self, v): - self.bytes_fixed(32, v) - self.types.append(ABIContractType.BYTES32) - self.__log_latest(v) - - - def bytes4(self, v): - self.bytes_fixed(4, v) - self.types.append(ABIContractType.BYTES4) - self.__log_latest(v) - - - - def string(self, v): - b = v.encode('utf-8') - l = len(b) - contents = l.to_bytes(32, 'big') - contents += b - padlen = 32 - (l % 32) - contents += padlen * b'\x00' - self.bytes_fixed(len(contents), contents) - self.types.append(ABIContractType.STRING) - self.__log_latest(v) - return contents - - - def bytes_fixed(self, mx, v, exact=0): - typ = type(v).__name__ - if typ == 'str': - v = strip_0x(v) - l = len(v) - if exact > 0 and l != exact * 2: - raise ValueError('value wrong size; expected {}, got {})'.format(mx, l)) - if l > mx * 2: - raise ValueError('value too long ({})'.format(l)) - v = pad(v, mx) - elif typ == 'bytes': - l = len(v) - if exact > 0 and l != exact: - raise ValueError('value wrong size; expected {}, got {})'.format(mx, l)) - b = bytearray(mx) - b[mx-l:] = v - v = pad(b.hex(), mx) - else: - raise ValueError('invalid input {}'.format(typ)) - self.contents.append(v.ljust(64, '0')) - - - def get_method(self): - if self.method_name == None: - return '' - return '{}({})'.format(self.method_name, ','.join(self.method_contents)) - - - def get_method_signature(self): - s = self.get_method() - if s == '': - return s - return keccak256_string_to_hex(s)[:8] - - - def get_contents(self): - direct_contents = '' - pointer_contents = '' - l = len(self.types) - pointer_cursor = 32 * l - for i in range(l): - if self.types[i] in dynamic_contract_types: - content_length = len(self.contents[i]) - pointer_contents += self.contents[i] - direct_contents += pointer_cursor.to_bytes(32, 'big').hex() - pointer_cursor += int(content_length / 2) - else: - direct_contents += self.contents[i] - s = ''.join(direct_contents + pointer_contents) - for i in range(0, len(s), 64): - l = len(s) - i - if l > 64: - l = 64 - logg.debug('code word {} {}'.format(int(i / 64), s[i:i+64])) - return s - - - def get(self): - return self.encode() - - - def encode(self): - m = self.get_method_signature() - c = self.get_contents() - return m + c - - - def __str__(self): - return self.encode() - - - -def abi_decode_single(typ, v): - d = ABIContractDecoder() - d.typ(typ) - d.val(v) - r = d.decode() - return r[0] - - -def code(address, block_spec=BlockSpec.LATEST): - block_height = None - if block_spec == BlockSpec.LATEST: - block_height = 'latest' - elif block_spec == BlockSpec.PENDING: - block_height = 'pending' - else: - block_height = int(block_spec) - o = jsonrpc_template() - o['method'] = 'eth_getCode' - o['params'].append(address) - o['params'].append(block_height) - return o diff --git a/chainlib/eth/error.py b/chainlib/eth/error.py @@ -1,23 +0,0 @@ -# local imports -from chainlib.error import ExecutionError - -class EthException(Exception): - pass - - -class RevertEthException(EthException, ExecutionError): - pass - - -class NotFoundEthException(EthException): - pass - - -class RequestMismatchException(EthException): - pass - - -class DefaultErrorParser: - - def translate(self, error): - return EthException('default parser code {}'.format(error)) diff --git a/chainlib/eth/gas.py b/chainlib/eth/gas.py @@ -1,138 +0,0 @@ -# standard imports -import logging - -# third-party imports -from hexathon import ( - add_0x, - strip_0x, - ) -from crypto_dev_signer.eth.transaction import EIP155Transaction - -# local imports -from chainlib.hash import keccak256_hex_to_hex -from chainlib.jsonrpc import jsonrpc_template -from chainlib.eth.tx import ( - TxFactory, - TxFormat, - raw, - ) -from chainlib.eth.constant import ( - MINIMUM_FEE_UNITS, - ) - -logg = logging.getLogger(__name__) - - -def price(): - o = jsonrpc_template() - o['method'] = 'eth_gasPrice' - return o - - -def balance(address): - o = jsonrpc_template() - o['method'] = 'eth_getBalance' - o['params'].append(address) - o['params'].append('latest') - return o - - -class Gas(TxFactory): - - def create(self, sender_address, recipient_address, value, tx_format=TxFormat.JSONRPC): - tx = self.template(sender_address, recipient_address, use_nonce=True) - tx['value'] = value - txe = EIP155Transaction(tx, tx['nonce'], tx['chainId']) - tx_raw = self.signer.sign_transaction_to_rlp(txe) - tx_raw_hex = add_0x(tx_raw.hex()) - tx_hash_hex = add_0x(keccak256_hex_to_hex(tx_raw_hex)) - - o = None - if tx_format == TxFormat.JSONRPC: - o = raw(tx_raw_hex) - elif tx_format == TxFormat.RLP_SIGNED: - o = tx_raw_hex - - return (tx_hash_hex, o) - - - -class RPCGasOracle: - - def __init__(self, conn, code_callback=None, min_price=1): - self.conn = conn - self.code_callback = code_callback - self.min_price = min_price - - - def get_gas(self, code=None): - gas_price = 0 - if self.conn != None: - o = price() - r = self.conn.do(o) - n = strip_0x(r) - gas_price = int(n, 16) - fee_units = MINIMUM_FEE_UNITS - if self.code_callback != None: - fee_units = self.code_callback(code) - if gas_price < self.min_price: - logg.debug('adjusting price {} to set minimum {}'.format(gas_price, self.min_price)) - gas_price = self.min_price - return (gas_price, fee_units) - - -class RPCPureGasOracle(RPCGasOracle): - - def __init__(self, conn, code_callback=None): - super(RPCPureGasOracle, self).__init__(conn, code_callback=code_callback, min_price=0) - - -class OverrideGasOracle(RPCGasOracle): - - def __init__(self, price=None, limit=None, conn=None, code_callback=None): - self.conn = None - self.code_callback = None - self.limit = limit - self.price = price - - price_conn = None - - if self.limit == None or self.price == None: - if self.price == None: - price_conn = conn - logg.debug('override gas oracle with rpc fallback; price {} limit {}'.format(self.price, self.limit)) - - super(OverrideGasOracle, self).__init__(price_conn, code_callback) - - - def get_gas(self, code=None): - r = None - fee_units = None - fee_price = None - - rpc_results = super(OverrideGasOracle, self).get_gas(code) - - if self.limit != None: - fee_units = self.limit - if self.price != None: - fee_price = self.price - - if fee_price == None: - if rpc_results != None: - fee_price = rpc_results[0] - logg.debug('override gas oracle without explicit price, setting from rpc {}'.format(fee_price)) - else: - fee_price = MINIMUM_FEE_PRICE - logg.debug('override gas oracle without explicit price, setting default {}'.format(fee_price)) - if fee_units == None: - if rpc_results != None: - fee_units = rpc_results[1] - logg.debug('override gas oracle without explicit limit, setting from rpc {}'.format(fee_units)) - else: - fee_units = MINIMUM_FEE_UNITS - logg.debug('override gas oracle without explicit limit, setting default {}'.format(fee_units)) - - return (fee_price, fee_units) - - -DefaultGasOracle = RPCGasOracle diff --git a/chainlib/eth/jsonrpc.py b/chainlib/eth/jsonrpc.py @@ -1,16 +0,0 @@ -# proposed custom errors -# source: https://eth.wiki/json-rpc/json-rpc-error-codes-improvement-proposal - -#1 Unauthorized Should be used when some action is not authorized, e.g. sending from a locked account. -#2 Action not allowed Should be used when some action is not allowed, e.g. preventing an action, while another depending action is processing on, like sending again when a confirmation popup is shown to the user (?). -#3 Execution error Will contain a subset of custom errors in the data field. See below. - -#100 X doesn’t exist Should be used when something which should be there is not found. (Doesn’t apply to eth_getTransactionBy_ and eth_getBlock_. They return a success with value null) -#101 Requires ether Should be used for actions which require somethin else, e.g. gas or a value. -#102 Gas too low Should be used when a to low value of gas was given. -#103 Gas limit exceeded Should be used when a limit is exceeded, e.g. for the gas limit in a block. -#104 Rejected Should be used when an action was rejected, e.g. because of its content (too long contract code, containing wrong characters ?, should differ from -32602 - Invalid params). -#105 Ether too low Should be used when a to low value of Ether was given. - -#106 Timeout Should be used when an action timedout. -#107 Conflict Should be used when an action conflicts with another (ongoing?) action. diff --git a/chainlib/eth/nonce.py b/chainlib/eth/nonce.py @@ -1,62 +0,0 @@ -# third-party imports -from hexathon import ( - add_0x, - strip_0x, - ) - -# local imports -from chainlib.jsonrpc import jsonrpc_template - - -def nonce(address): - o = jsonrpc_template() - o['method'] = 'eth_getTransactionCount' - o['params'].append(address) - o['params'].append('pending') - return o - - -class NonceOracle: - - def __init__(self, address): - self.address = address - self.nonce = self.get_nonce() - - - def get_nonce(self): - raise NotImplementedError('Class must be extended') - - - def next_nonce(self): - n = self.nonce - self.nonce += 1 - return n - - -class RPCNonceOracle(NonceOracle): - - def __init__(self, address, conn): - self.conn = conn - super(RPCNonceOracle, self).__init__(address) - - - def get_nonce(self): - o = nonce(self.address) - r = self.conn.do(o) - n = strip_0x(r) - return int(n, 16) - - -class OverrideNonceOracle(NonceOracle): - - - def __init__(self, address, nonce): - self.nonce = nonce - super(OverrideNonceOracle, self).__init__(address) - - - def get_nonce(self): - return self.nonce - - -DefaultNonceOracle = RPCNonceOracle diff --git a/chainlib/eth/pytest/__init__.py b/chainlib/eth/pytest/__init__.py @@ -1,3 +0,0 @@ -from .fixtures_ethtester import * -from .fixtures_chain import * -from .fixtures_signer import * diff --git a/chainlib/eth/pytest/fixtures_chain.py b/chainlib/eth/pytest/fixtures_chain.py @@ -1,17 +0,0 @@ -# external imports -import pytest - -# local imports -from chainlib.chain import ChainSpec - - -@pytest.fixture(scope='session') -def default_chain_spec(): - return ChainSpec('evm', 'foo', 42) - - -@pytest.fixture(scope='session') -def default_chain_config(): - return { - 'foo': 42, - } diff --git a/chainlib/eth/pytest/fixtures_ethtester.py b/chainlib/eth/pytest/fixtures_ethtester.py @@ -1,105 +0,0 @@ -# standard imports -import os -import logging - -# external imports -import eth_tester -import pytest -from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer -from crypto_dev_signer.keystore.dict import DictKeystore - -# local imports -from chainlib.eth.unittest.base import * -from chainlib.connection import ( - RPCConnection, - ConnType, - ) -from chainlib.eth.unittest.ethtester import create_tester_signer -from chainlib.eth.address import to_checksum_address - -logg = logging.getLogger() #__name__) - - -@pytest.fixture(scope='function') -def eth_keystore(): - return DictKeystore() - - -@pytest.fixture(scope='function') -def init_eth_tester( - eth_keystore, - ): - return create_tester_signer(eth_keystore) - - -@pytest.fixture(scope='function') -def call_sender( - eth_accounts, - ): - return eth_accounts[0] -# -# -#@pytest.fixture(scope='function') -#def eth_signer( -# init_eth_tester, -# ): -# return init_eth_tester - - -@pytest.fixture(scope='function') -def eth_rpc( - default_chain_spec, - init_eth_rpc, - ): - return RPCConnection.connect(default_chain_spec, 'default') - - -@pytest.fixture(scope='function') -def eth_accounts( - init_eth_tester, - ): - addresses = list(init_eth_tester.get_accounts()) - for address in addresses: - balance = init_eth_tester.get_balance(address) - logg.debug('prefilled account {} balance {}'.format(address, balance)) - return addresses - - -@pytest.fixture(scope='function') -def eth_empty_accounts( - eth_keystore, - init_eth_tester, - ): - a = [] - for i in range(10): - #address = init_eth_tester.new_account() - address = eth_keystore.new() - checksum_address = add_0x(to_checksum_address(address)) - a.append(checksum_address) - logg.info('added address {}'.format(checksum_address)) - return a - - -@pytest.fixture(scope='function') -def eth_signer( - eth_keystore, - ): - return EIP155Signer(eth_keystore) - - -@pytest.fixture(scope='function') -def init_eth_rpc( - default_chain_spec, - init_eth_tester, - eth_signer, - ): - - rpc_conn = TestRPCConnection(None, init_eth_tester, eth_signer) - def rpc_with_tester(url=None, chain_spec=default_chain_spec): - return rpc_conn - - RPCConnection.register_constructor(ConnType.CUSTOM, rpc_with_tester, tag='default') - RPCConnection.register_constructor(ConnType.CUSTOM, rpc_with_tester, tag='signer') - RPCConnection.register_location('custom', default_chain_spec, tag='default', exist_ok=True) - RPCConnection.register_location('custom', default_chain_spec, tag='signer', exist_ok=True) - return None diff --git a/chainlib/eth/pytest/fixtures_signer.py b/chainlib/eth/pytest/fixtures_signer.py @@ -1,18 +0,0 @@ -# standard imports -#import os - -# external imports -import pytest -#from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer - - -@pytest.fixture(scope='function') -def agent_roles( - eth_accounts, - ): - return { - 'ALICE': eth_accounts[20], - 'BOB': eth_accounts[21], - 'CAROL': eth_accounts[23], - 'DAVE': eth_accounts[24], - } diff --git a/chainlib/eth/runnable/__init__.py b/chainlib/eth/runnable/__init__.py diff --git a/chainlib/eth/runnable/balance.py b/chainlib/eth/runnable/balance.py @@ -1,91 +0,0 @@ -#!python3 - -"""Token balance query script - -.. moduleauthor:: Louis Holbrook <dev@holbrook.no> -.. pgp:: 0826EDA1702D1E87C6E2875121D2E7BB88C2A746 - -""" - -# SPDX-License-Identifier: GPL-3.0-or-later - -# standard imports -import os -import json -import argparse -import logging - -# third-party imports -from hexathon import ( - add_0x, - strip_0x, - even, - ) -import sha3 -from eth_abi import encode_single - -# local imports -from chainlib.eth.address import to_checksum -from chainlib.jsonrpc import ( - jsonrpc_template, - jsonrpc_result, - ) -from chainlib.eth.connection import EthHTTPConnection -from chainlib.eth.gas import ( - OverrideGasOracle, - balance, - ) -from chainlib.chain import ChainSpec - -logging.basicConfig(level=logging.WARNING) -logg = logging.getLogger() - -default_abi_dir = os.environ.get('ETH_ABI_DIR', '/usr/share/local/cic/solidity/abi') -default_eth_provider = os.environ.get('ETH_PROVIDER', 'http://localhost:8545') - -argparser = argparse.ArgumentParser() -argparser.add_argument('-p', '--provider', dest='p', default=default_eth_provider, type=str, help='Web3 provider url (http only)') -argparser.add_argument('-i', '--chain-spec', dest='i', type=str, default='evm:ethereum:1', help='Chain specification string') -argparser.add_argument('-u', '--unsafe', dest='u', action='store_true', help='Auto-convert address to checksum adddress') -argparser.add_argument('-v', action='store_true', help='Be verbose') -argparser.add_argument('-vv', action='store_true', help='Be more verbose') -argparser.add_argument('address', type=str, help='Account address') -args = argparser.parse_args() - - -if args.vv: - logg.setLevel(logging.DEBUG) -elif args.v: - logg.setLevel(logging.INFO) - -conn = EthHTTPConnection(args.p) -gas_oracle = OverrideGasOracle(conn) - -address = to_checksum(args.address) -if not args.u and address != add_0x(args.address): - raise ValueError('invalid checksum address') - -chain_spec = ChainSpec.from_chain_str(args.i) - -def main(): - r = None - decimals = 18 - - o = balance(address) - r = conn.do(o) - - hx = strip_0x(r) - balance_value = int(hx, 16) - logg.debug('balance {} = {} decimals {}'.format(even(hx), balance_value, decimals)) - - balance_str = str(balance_value) - balance_len = len(balance_str) - if balance_len < decimals + 1: - print('0.{}'.format(balance_str.zfill(decimals))) - else: - offset = balance_len-decimals - print('{}.{}'.format(balance_str[:offset],balance_str[offset:])) - - -if __name__ == '__main__': - main() diff --git a/chainlib/eth/runnable/checksum.py b/chainlib/eth/runnable/checksum.py @@ -1,15 +0,0 @@ -# standard imports -import sys - -# external imports -from hexathon import strip_0x - -# local imports -from chainlib.eth.address import to_checksum_address - -def main(): - print(to_checksum_address(strip_0x(sys.argv[1]))) - - -if __name__ == '__main__': - main() diff --git a/chainlib/eth/runnable/count.py b/chainlib/eth/runnable/count.py @@ -1,60 +0,0 @@ -# SPDX-License-Identifier: GPL-3.0-or-later - -# standard imports -import sys -import os -import json -import argparse -import logging - -# local imports -from chainlib.eth.address import to_checksum -from chainlib.eth.connection import EthHTTPConnection -from chainlib.eth.tx import count -from chainlib.chain import ChainSpec -from crypto_dev_signer.keystore.dict import DictKeystore -from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer - -logging.basicConfig(level=logging.WARNING) -logg = logging.getLogger() - -default_eth_provider = os.environ.get('ETH_PROVIDER', 'http://localhost:8545') - -argparser = argparse.ArgumentParser() -argparser.add_argument('-p', '--provider', dest='p', default='http://localhost:8545', type=str, help='Web3 provider url (http only)') -argparser.add_argument('-i', '--chain-spec', dest='i', type=str, default='evm:ethereum:1', help='Chain specification string') -argparser.add_argument('-y', '--key-file', dest='y', type=str, help='Ethereum keystore file to use for signing') -argparser.add_argument('--env-prefix', default=os.environ.get('CONFINI_ENV_PREFIX'), dest='env_prefix', type=str, help='environment prefix for variables to overwrite configuration') -argparser.add_argument('-u', '--unsafe', dest='u', action='store_true', help='Auto-convert address to checksum adddress') -argparser.add_argument('-v', action='store_true', help='Be verbose') -argparser.add_argument('-vv', action='store_true', help='Be more verbose') -argparser.add_argument('address', type=str, help='Ethereum address of recipient') -args = argparser.parse_args() - -if args.vv: - logg.setLevel(logging.DEBUG) -elif args.v: - logg.setLevel(logging.INFO) - - -signer_address = None -keystore = DictKeystore() -if args.y != None: - logg.debug('loading keystore file {}'.format(args.y)) - signer_address = keystore.import_keystore_file(args.y, passphrase) - logg.debug('now have key for signer address {}'.format(signer_address)) -signer = EIP155Signer(keystore) - -rpc = EthHTTPConnection(args.p) - -def main(): - recipient = to_checksum(args.address) - if not args.u and recipient != add_0x(args.address): - raise ValueError('invalid checksum address') - - o = count(args.address) - print(rpc.do(o)) - - -if __name__ == '__main__': - main() diff --git a/chainlib/eth/runnable/decode.py b/chainlib/eth/runnable/decode.py @@ -1,50 +0,0 @@ -#!python3 - -"""Decode raw transaction - -.. moduleauthor:: Louis Holbrook <dev@holbrook.no> -.. pgp:: 0826EDA1702D1E87C6E2875121D2E7BB88C2A746 - -""" - -# SPDX-License-Identifier: GPL-3.0-or-later - -# standard imports -import sys -import os -import json -import argparse -import logging - -# third-party imports -from chainlib.eth.tx import unpack -from chainlib.chain import ChainSpec - -# local imports -from chainlib.eth.runnable.util import decode_for_puny_humans - - -logging.basicConfig(level=logging.WARNING) -logg = logging.getLogger() - -default_abi_dir = os.environ.get('ETH_ABI_DIR', '/usr/share/local/cic/solidity/abi') -default_eth_provider = os.environ.get('ETH_PROVIDER', 'http://localhost:8545') - -argparser = argparse.ArgumentParser() -argparser.add_argument('-v', action='store_true', help='Be verbose') -argparser.add_argument('-i', '--chain-id', dest='i', default='evm:ethereum:1', type=str, help='Numeric network id') -argparser.add_argument('tx', type=str, help='hex-encoded signed raw transaction') -args = argparser.parse_args() - -if args.v: - logg.setLevel(logging.DEBUG) - -chain_spec = ChainSpec.from_chain_str(args.i) - - -def main(): - tx_raw = args.tx - decode_for_puny_humans(tx_raw, chain_spec, sys.stdout) - -if __name__ == '__main__': - main() diff --git a/chainlib/eth/runnable/gas.py b/chainlib/eth/runnable/gas.py @@ -1,163 +0,0 @@ -#!python3 - -"""Gas transfer script - -.. moduleauthor:: Louis Holbrook <dev@holbrook.no> -.. pgp:: 0826EDA1702D1E87C6E2875121D2E7BB88C2A746 - -""" - -# SPDX-License-Identifier: GPL-3.0-or-later - -# standard imports -import io -import sys -import os -import json -import argparse -import logging -import urllib - -# external imports -from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer -from crypto_dev_signer.keystore.dict import DictKeystore -from hexathon import ( - add_0x, - strip_0x, - ) - -# local imports -from chainlib.eth.address import to_checksum -from chainlib.eth.connection import EthHTTPConnection -from chainlib.jsonrpc import jsonrpc_template -from chainlib.eth.nonce import ( - RPCNonceOracle, - OverrideNonceOracle, - ) -from chainlib.eth.gas import ( - RPCGasOracle, - OverrideGasOracle, - Gas, - ) -from chainlib.eth.gas import balance as gas_balance -from chainlib.chain import ChainSpec -from chainlib.eth.runnable.util import decode_for_puny_humans - -logging.basicConfig(level=logging.WARNING) -logg = logging.getLogger() - - -default_eth_provider = os.environ.get('ETH_PROVIDER', 'http://localhost:8545') - -argparser = argparse.ArgumentParser() -argparser.add_argument('-p', '--provider', dest='p', default='http://localhost:8545', type=str, help='Web3 provider url (http only)') -argparser.add_argument('-w', action='store_true', help='Wait for the last transaction to be confirmed') -argparser.add_argument('-ww', action='store_true', help='Wait for every transaction to be confirmed') -argparser.add_argument('-i', '--chain-spec', dest='i', type=str, default='evm:ethereum:1', help='Chain specification string') -argparser.add_argument('-y', '--key-file', dest='y', type=str, help='Ethereum keystore file to use for signing') -argparser.add_argument('--env-prefix', default=os.environ.get('CONFINI_ENV_PREFIX'), dest='env_prefix', type=str, help='environment prefix for variables to overwrite configuration') -argparser.add_argument('--nonce', type=int, help='override nonce') -argparser.add_argument('--gas-price', dest='gas_price', type=int, help='override gas price') -argparser.add_argument('--gas-limit', dest='gas_limit', type=int, help='override gas limit') -argparser.add_argument('-u', '--unsafe', dest='u', action='store_true', help='Auto-convert address to checksum adddress') -argparser.add_argument('-v', action='store_true', help='Be verbose') -argparser.add_argument('-vv', action='store_true', help='Be more verbose') -argparser.add_argument('-s', '--send', dest='s', action='store_true', help='Send to network') -argparser.add_argument('recipient', type=str, help='ethereum address of recipient') -argparser.add_argument('amount', type=int, help='gas value in wei') -args = argparser.parse_args() - - -if args.vv: - logg.setLevel(logging.DEBUG) -elif args.v: - logg.setLevel(logging.INFO) - -block_all = args.ww -block_last = args.w or block_all - -passphrase_env = 'ETH_PASSPHRASE' -if args.env_prefix != None: - passphrase_env = args.env_prefix + '_' + passphrase_env -passphrase = os.environ.get(passphrase_env) -if passphrase == None: - logg.warning('no passphrase given') - passphrase='' - -signer_address = None -keystore = DictKeystore() -if args.y != None: - logg.debug('loading keystore file {}'.format(args.y)) - signer_address = keystore.import_keystore_file(args.y, password=passphrase) - logg.debug('now have key for signer address {}'.format(signer_address)) -signer = EIP155Signer(keystore) - -conn = EthHTTPConnection(args.p) - -nonce_oracle = None -if args.nonce != None: - nonce_oracle = OverrideNonceOracle(signer_address, args.nonce) -else: - nonce_oracle = RPCNonceOracle(signer_address, conn) - -gas_oracle = None -if args.gas_price or args.gas_limit != None: - gas_oracle = OverrideGasOracle(price=args.gas_price, limit=args.gas_limit, conn=conn) -else: - gas_oracle = RPCGasOracle(conn) - - -chain_spec = ChainSpec.from_chain_str(args.i) - -value = args.amount - -send = args.s - -g = Gas(chain_spec, signer=signer, gas_oracle=gas_oracle, nonce_oracle=nonce_oracle) - - -def balance(address): - o = gas_balance(address) - r = conn.do(o) - hx = strip_0x(r) - return int(hx, 16) - - -def main(): - recipient = to_checksum(args.recipient) - if not args.u and recipient != add_0x(args.recipient): - raise ValueError('invalid checksum address') - - logg.info('gas transfer from {} to {} value {}'.format(signer_address, recipient, value)) - if logg.isEnabledFor(logging.DEBUG): - try: - logg.debug('sender {} balance before: {}'.format(signer_address, balance(signer_address))) - logg.debug('recipient {} balance before: {}'.format(recipient, balance(recipient))) - except urllib.error.URLError: - pass - - (tx_hash_hex, o) = g.create(signer_address, recipient, value) - - if send: - conn.do(o) - if block_last: - r = conn.wait(tx_hash_hex) - if logg.isEnabledFor(logging.DEBUG): - logg.debug('sender {} balance after: {}'.format(signer_address, balance(signer_address))) - logg.debug('recipient {} balance after: {}'.format(recipient, balance(recipient))) - if r['status'] == 0: - logg.critical('VM revert. Wish I could tell you more') - sys.exit(1) - print(tx_hash_hex) - else: - if logg.isEnabledFor(logging.INFO): - io_str = io.StringIO() - decode_for_puny_humans(o['params'][0], chain_spec, io_str) - print(io_str.getvalue()) - else: - print(o['params'][0]) - - - -if __name__ == '__main__': - main() diff --git a/chainlib/eth/runnable/get.py b/chainlib/eth/runnable/get.py @@ -1,118 +0,0 @@ -#!python3 - -"""Token balance query script - -.. moduleauthor:: Louis Holbrook <dev@holbrook.no> -.. pgp:: 0826EDA1702D1E87C6E2875121D2E7BB88C2A746 - -""" - -# SPDX-License-Identifier: GPL-3.0-or-later - -# standard imports -import sys -import os -import json -import argparse -import logging -import enum - -# external imports -from hexathon import ( - add_0x, - strip_0x, - ) -import sha3 - -# local imports -from chainlib.eth.address import to_checksum -from chainlib.jsonrpc import ( - jsonrpc_template, - jsonrpc_result, - ) -from chainlib.eth.connection import EthHTTPConnection -from chainlib.eth.tx import Tx -from chainlib.eth.address import to_checksum_address -from chainlib.eth.block import Block -from chainlib.chain import ChainSpec -from chainlib.status import Status - -logging.basicConfig(level=logging.WARNING) -logg = logging.getLogger() - -default_abi_dir = os.environ.get('ETH_ABI_DIR', '/usr/share/local/cic/solidity/abi') -default_eth_provider = os.environ.get('ETH_PROVIDER', 'http://localhost:8545') - -argparser = argparse.ArgumentParser() -argparser.add_argument('-p', '--provider', dest='p', default=default_eth_provider, type=str, help='Web3 provider url (http only)') -argparser.add_argument('-i', '--chain-spec', dest='i', type=str, default='evm:ethereum:1', help='Chain specification string') -argparser.add_argument('-t', '--token-address', dest='t', type=str, help='Token address. If not set, will return gas balance') -argparser.add_argument('-u', '--unsafe', dest='u', action='store_true', help='Auto-convert address to checksum adddress') -argparser.add_argument('--abi-dir', dest='abi_dir', type=str, default=default_abi_dir, help='Directory containing bytecode and abi (default {})'.format(default_abi_dir)) -argparser.add_argument('-v', action='store_true', help='Be verbose') -argparser.add_argument('-vv', action='store_true', help='Be more verbose') -argparser.add_argument('item', type=str, help='Item to get information for (address og transaction)') -args = argparser.parse_args() - -if args.vv: - logg.setLevel(logging.DEBUG) -elif args.v: - logg.setLevel(logging.INFO) - -conn = EthHTTPConnection(args.p) - -#tx_hash = add_0x(args.tx_hash) -item = add_0x(args.item) - - -def get_transaction(conn, tx_hash): - o = jsonrpc_template() - o['method'] = 'eth_getTransactionByHash' - o['params'].append(tx_hash) - tx_src = conn.do(o) - if tx_src == None: - logg.error('Transaction {} not found'.format(tx_hash)) - sys.exit(1) - - tx = None - status = -1 - rcpt = None - - o = jsonrpc_template() - o['method'] = 'eth_getTransactionReceipt' - o['params'].append(tx_hash) - rcpt = conn.do(o) - #status = int(strip_0x(rcpt['status']), 16) - - if tx == None: - tx = Tx(tx_src) - if rcpt != None: - tx.apply_receipt(rcpt) - return tx - - -def get_address(conn, address): - o = jsonrpc_template() - o['method'] = 'eth_getCode' - o['params'].append(address) - o['params'].append('latest') - code = conn.do(o) - - content = strip_0x(code, allow_empty=True) - if len(content) == 0: - return None - - return content - - -def main(): - r = None - if len(item) > 42: - r = get_transaction(conn, item) - elif args.u or to_checksum_address(item): - r = get_address(conn, item) - print(r) - - -if __name__ == '__main__': - main() diff --git a/chainlib/eth/runnable/info.py b/chainlib/eth/runnable/info.py @@ -1,154 +0,0 @@ -#!python3 - -"""Token balance query script - -.. moduleauthor:: Louis Holbrook <dev@holbrook.no> -.. pgp:: 0826EDA1702D1E87C6E2875121D2E7BB88C2A746 - -""" - -# SPDX-License-Identifier: GPL-3.0-or-later - -# standard imports -import datetime -import sys -import os -import json -import argparse -import logging - -# third-party imports -from hexathon import ( - add_0x, - strip_0x, - even, - ) -import sha3 -from eth_abi import encode_single - -# local imports -from chainlib.eth.address import ( - to_checksum_address, - is_checksum_address, - ) -from chainlib.jsonrpc import ( - jsonrpc_template, - jsonrpc_result, - ) -from chainlib.eth.block import ( - block_latest, - block_by_number, - Block, - ) -from chainlib.eth.tx import count -from chainlib.eth.connection import EthHTTPConnection -from chainlib.eth.gas import ( - OverrideGasOracle, - balance, - price, - ) -from chainlib.chain import ChainSpec - -BLOCK_SAMPLES = 10 - -logging.basicConfig(level=logging.WARNING) -logg = logging.getLogger() - -default_abi_dir = os.environ.get('ETH_ABI_DIR', '/usr/share/local/cic/solidity/abi') -default_eth_provider = os.environ.get('ETH_PROVIDER', 'http://localhost:8545') - -argparser = argparse.ArgumentParser() -argparser.add_argument('-p', '--provider', dest='p', default=default_eth_provider, type=str, help='Web3 provider url (http only)') -argparser.add_argument('-i', '--chain-spec', dest='i', type=str, default='evm:ethereum:1', help='Chain specification string') -argparser.add_argument('-H', '--human', dest='human', action='store_true', help='Use human-friendly formatting') -argparser.add_argument('-u', '--unsafe', dest='u', action='store_true', help='Auto-convert address to checksum adddress') -argparser.add_argument('-l', '--long', dest='l', action='store_true', help='Calculate averages through sampling of blocks and txs') -argparser.add_argument('-v', action='store_true', help='Be verbose') -argparser.add_argument('-vv', action='store_true', help='Be more verbose') -argparser.add_argument('-y', '--key-file', dest='y', type=str, help='Include summary for keyfile') -argparser.add_argument('address', nargs='?', type=str, help='Include summary for address (conflicts with -y)') -args = argparser.parse_args() - - -if args.vv: - logg.setLevel(logging.DEBUG) -elif args.v: - logg.setLevel(logging.INFO) - -signer = None -holder_address = None -if args.address != None: - if not args.u and not is_checksum_address(args.address): - raise ValueError('invalid checksum address {}'.format(args.address)) - holder_address = add_0x(args.address) -elif args.y != None: - f = open(args.y, 'r') - o = json.load(f) - f.close() - holder_address = add_0x(to_checksum_address(o['address'])) - -conn = EthHTTPConnection(args.p) -gas_oracle = OverrideGasOracle(conn) - -token_symbol = 'eth' - -chain_spec = ChainSpec.from_chain_str(args.i) - -human = args.human - -longmode = args.l - -def main(): - - o = block_latest() - r = conn.do(o) - n = int(r, 16) - first_block_number = n - if human: - n = format(n, ',') - sys.stdout.write('Block: {}\n'.format(n)) - - o = block_by_number(first_block_number, False) - r = conn.do(o) - last_block = Block(r) - last_timestamp = last_block.timestamp - - if longmode: - aggr_time = 0.0 - aggr_gas = 0 - for i in range(BLOCK_SAMPLES): - o = block_by_number(first_block_number-i, False) - r = conn.do(o) - block = Block(r) - aggr_time += last_block.timestamp - block.timestamp - - gas_limit = int(r['gasLimit'], 16) - aggr_gas += gas_limit - - last_block = block - last_timestamp = block.timestamp - - n = int(aggr_gas / BLOCK_SAMPLES) - if human: - n = format(n, ',') - - sys.stdout.write('Gaslimit: {}\n'.format(n)) - sys.stdout.write('Blocktime: {}\n'.format(aggr_time / BLOCK_SAMPLES)) - - o = price() - r = conn.do(o) - n = int(r, 16) - if human: - n = format(n, ',') - sys.stdout.write('Gasprice: {}\n'.format(n)) - - if holder_address != None: - o = count(holder_address) - r = conn.do(o) - n = int(r, 16) - sys.stdout.write('Address: {}\n'.format(holder_address)) - sys.stdout.write('Nonce: {}\n'.format(n)) - - -if __name__ == '__main__': - main() diff --git a/chainlib/eth/runnable/raw.py b/chainlib/eth/runnable/raw.py @@ -1,175 +0,0 @@ -#!python3 - -"""Gas transfer script - -.. moduleauthor:: Louis Holbrook <dev@holbrook.no> -.. pgp:: 0826EDA1702D1E87C6E2875121D2E7BB88C2A746 - -""" - -# SPDX-License-Identifier: GPL-3.0-or-later - -# standard imports -import io -import sys -import os -import json -import argparse -import logging -import urllib - -# external imports -from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer -from crypto_dev_signer.keystore.dict import DictKeystore -from hexathon import ( - add_0x, - strip_0x, - ) - -# local imports -from chainlib.eth.address import to_checksum -from chainlib.eth.connection import EthHTTPConnection -from chainlib.jsonrpc import jsonrpc_template -from chainlib.eth.nonce import ( - RPCNonceOracle, - OverrideNonceOracle, - ) -from chainlib.eth.gas import ( - RPCGasOracle, - OverrideGasOracle, - ) -from chainlib.eth.tx import ( - TxFactory, - raw, - ) -from chainlib.chain import ChainSpec -from chainlib.eth.runnable.util import decode_for_puny_humans - -logging.basicConfig(level=logging.WARNING) -logg = logging.getLogger() - - -default_eth_provider = os.environ.get('ETH_PROVIDER', 'http://localhost:8545') - -argparser = argparse.ArgumentParser() -argparser.add_argument('-p', '--provider', dest='p', default='http://localhost:8545', type=str, help='Web3 provider url (http only)') -argparser.add_argument('-w', action='store_true', help='Wait for the last transaction to be confirmed') -argparser.add_argument('-ww', action='store_true', help='Wait for every transaction to be confirmed') -argparser.add_argument('-i', '--chain-spec', dest='i', type=str, default='evm:ethereum:1', help='Chain specification string') -argparser.add_argument('-y', '--key-file', dest='y', type=str, help='Ethereum keystore file to use for signing') -argparser.add_argument('-u', '--unsafe', dest='u', action='store_true', help='Auto-convert address to checksum adddress') -argparser.add_argument('--env-prefix', default=os.environ.get('CONFINI_ENV_PREFIX'), dest='env_prefix', type=str, help='environment prefix for variables to overwrite configuration') -argparser.add_argument('--nonce', type=int, help='override nonce') -argparser.add_argument('--gas-price', dest='gas_price', type=int, help='override gas price') -argparser.add_argument('--gas-limit', dest='gas_limit', type=int, help='override gas limit') -argparser.add_argument('-a', '--recipient', dest='a', type=str, help='recipient address (None for contract creation)') -argparser.add_argument('-value', type=int, help='gas value of transaction in wei') -argparser.add_argument('-v', action='store_true', help='Be verbose') -argparser.add_argument('-vv', action='store_true', help='Be more verbose') -argparser.add_argument('-s', '--send', dest='s', action='store_true', help='Send to network') -argparser.add_argument('-l', '--local', dest='l', action='store_true', help='Local contract call') -argparser.add_argument('data', nargs='?', type=str, help='Transaction data') -args = argparser.parse_args() - - -if args.vv: - logg.setLevel(logging.DEBUG) -elif args.v: - logg.setLevel(logging.INFO) - -block_all = args.ww -block_last = args.w or block_all - -passphrase_env = 'ETH_PASSPHRASE' -if args.env_prefix != None: - passphrase_env = args.env_prefix + '_' + passphrase_env -passphrase = os.environ.get(passphrase_env) -if passphrase == None: - logg.warning('no passphrase given') - passphrase='' - -signer_address = None -keystore = DictKeystore() -if args.y != None: - logg.debug('loading keystore file {}'.format(args.y)) - signer_address = keystore.import_keystore_file(args.y, password=passphrase) - logg.debug('now have key for signer address {}'.format(signer_address)) -signer = EIP155Signer(keystore) - -conn = EthHTTPConnection(args.p) - -send = args.s - -local = args.l -if local: - send = False - -nonce_oracle = None -gas_oracle = None -if signer_address != None and not local: - if args.nonce != None: - nonce_oracle = OverrideNonceOracle(signer_address, args.nonce) - else: - nonce_oracle = RPCNonceOracle(signer_address, conn) - - if args.gas_price or args.gas_limit != None: - gas_oracle = OverrideGasOracle(price=args.gas_price, limit=args.gas_limit, conn=conn) - else: - gas_oracle = RPCGasOracle(conn) - - -chain_spec = ChainSpec.from_chain_str(args.i) - -value = args.value - - -g = TxFactory(chain_spec, signer=signer, gas_oracle=gas_oracle, nonce_oracle=nonce_oracle) - -def main(): - recipient = None - if args.a != None: - recipient = add_0x(to_checksum(args.a)) - if not args.u and recipient != add_0x(recipient): - raise ValueError('invalid checksum address') - - if local: - o = jsonrpc_template() - o['method'] = 'eth_call' - o['params'].append({ - 'to': recipient, - 'from': signer_address, - 'value': '0x00', - 'gas': add_0x(int.to_bytes(8000000, 8, byteorder='big').hex()), # TODO: better get of network gas limit - 'gasPrice': '0x01', - 'data': add_0x(args.data), - }) - o['params'].append('latest') - r = conn.do(o) - print(strip_0x(r)) - return - - elif signer_address != None: - tx = g.template(signer_address, recipient, use_nonce=True) - if args.data != None: - tx = g.set_code(tx, add_0x(args.data)) - - (tx_hash_hex, o) = g.finalize(tx) - - if send: - r = conn.do(o) - print(r) - else: - print(o) - print(tx_hash_hex) - - else: - o = raw(args.data) - if send: - r = conn.do(o) - print(r) - else: - print(o) - - -if __name__ == '__main__': - main() diff --git a/chainlib/eth/runnable/subscribe.py b/chainlib/eth/runnable/subscribe.py @@ -1,21 +0,0 @@ -import json - -import websocket - -ws = websocket.create_connection('ws://localhost:8545') - -o = { - "jsonrpc": "2.0", - "method": "eth_subscribe", - "params": [ - "newHeads", - ], - "id": 0, - } - -ws.send(json.dumps(o).encode('utf-8')) - -while True: - print(ws.recv()) - -ws.close() diff --git a/chainlib/eth/runnable/util.py b/chainlib/eth/runnable/util.py @@ -1,22 +0,0 @@ -# local imports -from chainlib.eth.tx import unpack -from hexathon import ( - strip_0x, - add_0x, - ) - -def decode_for_puny_humans(tx_raw, chain_spec, writer): - tx_raw = strip_0x(tx_raw) - tx_raw_bytes = bytes.fromhex(tx_raw) - tx = unpack(tx_raw_bytes, chain_spec) - for k in tx.keys(): - x = None - if k == 'value': - x = '{:.18f} eth'.format(tx[k] / (10**18)) - elif k == 'gasPrice': - x = '{} gwei'.format(int(tx[k] / (10**9))) - if x != None: - writer.write('{}: {} ({})\n'.format(k, tx[k], x)) - else: - writer.write('{}: {}\n'.format(k, tx[k])) - writer.write('src: {}\n'.format(add_0x(tx_raw))) diff --git a/chainlib/eth/sign.py b/chainlib/eth/sign.py @@ -1,23 +0,0 @@ -# local imports -from chainlib.jsonrpc import jsonrpc_template - - -def new_account(passphrase=''): - o = jsonrpc_template() - o['method'] = 'personal_newAccount' - o['params'] = [passphrase] - return o - - -def sign_transaction(payload): - o = jsonrpc_template() - o['method'] = 'eth_signTransaction' - o['params'] = [payload] - return o - - -def sign_message(address, payload): - o = jsonrpc_template() - o['method'] = 'eth_sign' - o['params'] = [address, payload] - return o diff --git a/chainlib/eth/tx.py b/chainlib/eth/tx.py @@ -1,442 +0,0 @@ -# standard imports -import logging -import enum -import re - -# external imports -import coincurve -import sha3 -from hexathon import ( - strip_0x, - add_0x, - ) -from rlp import decode as rlp_decode -from rlp import encode as rlp_encode -from crypto_dev_signer.eth.transaction import EIP155Transaction -from crypto_dev_signer.encoding import public_key_to_address -from potaahto.symbols import snake_and_camel - - -# local imports -from chainlib.hash import keccak256_hex_to_hex -from chainlib.status import Status -from .address import to_checksum -from .constant import ( - MINIMUM_FEE_UNITS, - MINIMUM_FEE_PRICE, - ZERO_ADDRESS, - ) -from .contract import ABIContractEncoder -from chainlib.jsonrpc import jsonrpc_template - -logg = logging.getLogger().getChild(__name__) - - - -class TxFormat(enum.IntEnum): - DICT = 0x00 - RAW = 0x01 - RAW_SIGNED = 0x02 - RAW_ARGS = 0x03 - RLP = 0x10 - RLP_SIGNED = 0x11 - JSONRPC = 0x10 - - -field_debugs = [ - 'nonce', - 'gasPrice', - 'gas', - 'to', - 'value', - 'data', - 'v', - 'r', - 's', - ] - -def count(address, confirmed=False): - o = jsonrpc_template() - o['method'] = 'eth_getTransactionCount' - o['params'].append(address) - if confirmed: - o['params'].append('latest') - else: - o['params'].append('pending') - return o - -count_pending = count - -def count_confirmed(address): - return count(address, True) - - -def unpack(tx_raw_bytes, chain_spec): - chain_id = chain_spec.chain_id() - tx = __unpack_raw(tx_raw_bytes, chain_id) - tx['nonce'] = int.from_bytes(tx['nonce'], 'big') - tx['gasPrice'] = int.from_bytes(tx['gasPrice'], 'big') - tx['gas'] = int.from_bytes(tx['gas'], 'big') - tx['value'] = int.from_bytes(tx['value'], 'big') - return tx - - -def unpack_hex(tx_raw_bytes, chain_spec): - chain_id = chain_spec.chain_id() - tx = __unpack_raw(tx_raw_bytes, chain_id) - tx['nonce'] = add_0x(hex(tx['nonce'])) - tx['gasPrice'] = add_0x(hex(tx['gasPrice'])) - tx['gas'] = add_0x(hex(tx['gas'])) - tx['value'] = add_0x(hex(tx['value'])) - tx['chainId'] = add_0x(hex(tx['chainId'])) - return tx - - -def __unpack_raw(tx_raw_bytes, chain_id=1): - d = rlp_decode(tx_raw_bytes) - - logg.debug('decoding using chain id {}'.format(str(chain_id))) - - j = 0 - for i in d: - v = i.hex() - if j != 3 and v == '': - v = '00' - logg.debug('decoded {}: {}'.format(field_debugs[j], v)) - j += 1 - vb = chain_id - if chain_id != 0: - v = int.from_bytes(d[6], 'big') - vb = v - (chain_id * 2) - 35 - r = bytearray(32) - r[32-len(d[7]):] = d[7] - s = bytearray(32) - s[32-len(d[8]):] = d[8] - sig = b''.join([r, s, bytes([vb])]) - #so = KeyAPI.Signature(signature_bytes=sig) - - h = sha3.keccak_256() - h.update(rlp_encode(d)) - signed_hash = h.digest() - - d[6] = chain_id - d[7] = b'' - d[8] = b'' - - h = sha3.keccak_256() - h.update(rlp_encode(d)) - unsigned_hash = h.digest() - - #p = so.recover_public_key_from_msg_hash(unsigned_hash) - #a = p.to_checksum_address() - pubk = coincurve.PublicKey.from_signature_and_message(sig, unsigned_hash, hasher=None) - a = public_key_to_address(pubk) - logg.debug('decoded recovery byte {}'.format(vb)) - logg.debug('decoded address {}'.format(a)) - logg.debug('decoded signed hash {}'.format(signed_hash.hex())) - logg.debug('decoded unsigned hash {}'.format(unsigned_hash.hex())) - - to = d[3].hex() or None - if to != None: - to = to_checksum(to) - - data = d[5].hex() - try: - data = add_0x(data) - except: - data = '0x' - - return { - 'from': a, - 'to': to, - 'nonce': d[0], - 'gasPrice': d[1], - 'gas': d[2], - 'value': d[4], - 'data': data, - 'v': chain_id, - 'r': add_0x(sig[:32].hex()), - 's': add_0x(sig[32:64].hex()), - 'chainId': chain_id, - 'hash': add_0x(signed_hash.hex()), - 'hash_unsigned': add_0x(unsigned_hash.hex()), - } - - -def transaction(hsh): - o = jsonrpc_template() - o['method'] = 'eth_getTransactionByHash' - o['params'].append(add_0x(hsh)) - return o - - -def transaction_by_block(hsh, idx): - o = jsonrpc_template() - o['method'] = 'eth_getTransactionByBlockHashAndIndex' - o['params'].append(add_0x(hsh)) - o['params'].append(hex(idx)) - return o - - -def receipt(hsh): - o = jsonrpc_template() - o['method'] = 'eth_getTransactionReceipt' - o['params'].append(add_0x(hsh)) - return o - - -def raw(tx_raw_hex): - o = jsonrpc_template() - o['method'] = 'eth_sendRawTransaction' - o['params'].append(add_0x(tx_raw_hex)) - return o - - -class TxFactory: - - fee = 8000000 - - def __init__(self, chain_spec, signer=None, gas_oracle=None, nonce_oracle=None): - self.gas_oracle = gas_oracle - self.nonce_oracle = nonce_oracle - self.chain_spec = chain_spec - self.signer = signer - - - def build_raw(self, tx): - if tx['to'] == None or tx['to'] == '': - tx['to'] = '0x' - txe = EIP155Transaction(tx, tx['nonce'], tx['chainId']) - tx_raw = self.signer.sign_transaction_to_rlp(txe) - tx_raw_hex = add_0x(tx_raw.hex()) - tx_hash_hex = add_0x(keccak256_hex_to_hex(tx_raw_hex)) - return (tx_hash_hex, tx_raw_hex) - - - def build(self, tx): - (tx_hash_hex, tx_raw_hex) = self.build_raw(tx) - o = raw(tx_raw_hex) - return (tx_hash_hex, o) - - - def template(self, sender, recipient, use_nonce=False): - gas_price = MINIMUM_FEE_PRICE - gas_limit = MINIMUM_FEE_UNITS - if self.gas_oracle != None: - (gas_price, gas_limit) = self.gas_oracle.get_gas() - logg.debug('using gas price {} limit {}'.format(gas_price, gas_limit)) - nonce = 0 - o = { - 'from': sender, - 'to': recipient, - 'value': 0, - 'data': '0x', - 'gasPrice': gas_price, - 'gas': gas_limit, - 'chainId': self.chain_spec.chain_id(), - } - if self.nonce_oracle != None and use_nonce: - nonce = self.nonce_oracle.next_nonce() - logg.debug('using nonce {} for address {}'.format(nonce, sender)) - o['nonce'] = nonce - return o - - - def normalize(self, tx): - txe = EIP155Transaction(tx, tx['nonce'], tx['chainId']) - txes = txe.serialize() - return { - 'from': tx['from'], - 'to': txes['to'], - 'gasPrice': txes['gasPrice'], - 'gas': txes['gas'], - 'data': txes['data'], - } - - - def finalize(self, tx, tx_format=TxFormat.JSONRPC): - if tx_format == TxFormat.JSONRPC: - return self.build(tx) - elif tx_format == TxFormat.RLP_SIGNED: - return self.build_raw(tx) - raise NotImplementedError('tx formatting {} not implemented'.format(tx_format)) - - - def set_code(self, tx, data, update_fee=True): - tx['data'] = data - if update_fee: - tx['gas'] = TxFactory.fee - if self.gas_oracle != None: - (price, tx['gas']) = self.gas_oracle.get_gas(code=data) - else: - logg.debug('using hardcoded gas limit of 8000000 until we have reliable vm executor') - return tx - - - def transact_noarg(self, method, contract_address, sender_address, tx_format=TxFormat.JSONRPC): - enc = ABIContractEncoder() - enc.method(method) - data = enc.get() - tx = self.template(sender_address, contract_address, use_nonce=True) - tx = self.set_code(tx, data) - tx = self.finalize(tx, tx_format) - return tx - - - def call_noarg(self, method, contract_address, sender_address=ZERO_ADDRESS): - o = jsonrpc_template() - o['method'] = 'eth_call' - enc = ABIContractEncoder() - enc.method(method) - data = add_0x(enc.get()) - tx = self.template(sender_address, contract_address) - tx = self.set_code(tx, data) - o['params'].append(self.normalize(tx)) - o['params'].append('latest') - return o - - -class Tx: - - # TODO: force tx type schema parser (whether expect hex or int etc) - def __init__(self, src, block=None, rcpt=None): - logg.debug('src {}'.format(src)) - self.src = self.src_normalize(src) - self.index = -1 - tx_hash = add_0x(src['hash']) - if block != None: - i = 0 - for tx in block.txs: - tx_hash_block = None - try: - tx_hash_block = tx['hash'] - except TypeError: - tx_hash_block = add_0x(tx) - logg.debug('tx {} cmp {}'.format(tx, tx_hash)) - if tx_hash_block == tx_hash: - self.index = i - break - i += 1 - if self.index == -1: - raise AttributeError('tx {} not found in block {}'.format(tx_hash, block.hash)) - self.block = block - self.hash = strip_0x(tx_hash) - try: - self.value = int(strip_0x(src['value']), 16) - except TypeError: - self.value = int(src['value']) - try: - self.nonce = int(strip_0x(src['nonce']), 16) - except TypeError: - self.nonce = int(src['nonce']) - address_from = strip_0x(src['from']) - try: - self.gas_price = int(strip_0x(src['gasPrice']), 16) - except TypeError: - self.gas_price = int(src['gasPrice']) - try: - self.gas_limit = int(strip_0x(src['gas']), 16) - except TypeError: - self.gas_limit = int(src['gas']) - self.outputs = [to_checksum(address_from)] - self.contract = None - - try: - inpt = src['input'] - except KeyError: - inpt = src['data'] - - if inpt != '0x': - inpt = strip_0x(inpt) - else: - inpt = '' - self.payload = inpt - - to = src['to'] - if to == None: - to = ZERO_ADDRESS - self.inputs = [to_checksum(strip_0x(to))] - - self.block = block - try: - self.wire = src['raw'] - except KeyError: - logg.warning('no inline raw tx src, and no raw rendering implemented, field will be "None"') - - self.src = src - - self.status = Status.PENDING - self.logs = None - - if rcpt != None: - self.apply_receipt(rcpt) - - - @classmethod - def src_normalize(self, src): - return snake_and_camel(src) - - - def apply_receipt(self, rcpt): - rcpt = self.src_normalize(rcpt) - logg.debug('rcpt {}'.format(rcpt)) - try: - status_number = int(rcpt['status'], 16) - except TypeError: - status_number = int(rcpt['status']) - if status_number == 1: - self.status = Status.SUCCESS - elif status_number == 0: - self.status = Status.ERROR - # TODO: replace with rpc receipt/transaction translator when available - contract_address = rcpt.get('contractAddress') - if contract_address == None: - contract_address = rcpt.get('contract_address') - if contract_address != None: - self.contract = contract_address - self.logs = rcpt['logs'] - try: - self.gas_used = int(rcpt['gasUsed'], 16) - except TypeError: - self.gas_used = int(rcpt['gasUsed']) - - - def __repr__(self): - return 'block {} tx {} {}'.format(self.block.number, self.index, self.hash) - - - def __str__(self): - s = """hash {} -from {} -to {} -value {} -nonce {} -gasPrice {} -gasLimit {} -input {} -""".format( - self.hash, - self.outputs[0], - self.inputs[0], - self.value, - self.nonce, - self.gas_price, - self.gas_limit, - self.payload, - ) - - if self.status != Status.PENDING: - s += """gasUsed {} -""".format( - self.gas_used, - ) - - s += 'status ' + self.status.name + '\n' - - if self.contract != None: - s += """contract {} -""".format( - self.contract, - ) - return s - diff --git a/chainlib/eth/unittest/base.py b/chainlib/eth/unittest/base.py @@ -1,218 +0,0 @@ -# standard imports -import os -import logging - -# external imports -import eth_tester -import coincurve -from chainlib.connection import ( - RPCConnection, - error_parser, - ) -from chainlib.eth.address import ( - to_checksum_address, - ) -from chainlib.jsonrpc import ( - jsonrpc_response, - jsonrpc_error, - jsonrpc_result, - ) -from hexathon import ( - unpad, - add_0x, - strip_0x, - ) - -from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer -from crypto_dev_signer.encoding import private_key_to_address - - -logg = logging.getLogger().getChild(__name__) - -test_pk = bytes.fromhex('5087503f0a9cc35b38665955eb830c63f778453dd11b8fa5bd04bc41fd2cc6d6') - - -class EthTesterSigner(eth_tester.EthereumTester): - - def __init__(self, backend, keystore): - super(EthTesterSigner, self).__init__(backend) - logg.debug('accounts {}'.format(self.get_accounts())) - - self.keystore = keystore - self.backend = backend - self.backend.add_account(test_pk) - for pk in self.backend.account_keys: - pubk = pk.public_key - address = pubk.to_checksum_address() - logg.debug('test keystore have pk {} pubk {} addr {}'.format(pk, pk.public_key, address)) - self.keystore.import_raw_key(pk._raw_key) - - - def new_account(self): - pk = os.urandom(32) - address = self.keystore.import_raw_key(pk) - checksum_address = add_0x(to_checksum_address(address)) - self.backend.add_account(pk) - return checksum_address - - -class TestRPCConnection(RPCConnection): - - def __init__(self, location, backend, signer): - super(TestRPCConnection, self).__init__(location) - self.backend = backend - self.signer = signer - - - def do(self, o, error_parser=error_parser): - logg.debug('testrpc do {}'.format(o)) - m = getattr(self, o['method']) - if m == None: - raise ValueError('unhandled method {}'.format(o['method'])) - r = None - try: - result = m(o['params']) - logg.debug('result {}'.format(result)) - r = jsonrpc_response(o['id'], result) - except Exception as e: - logg.exception(e) - r = jsonrpc_error(o['id'], message=str(e)) - return jsonrpc_result(r, error_parser) - - - def eth_blockNumber(self, p): - block = self.backend.get_block_by_number('latest') - return block['number'] - - - def eth_getBlockByNumber(self, p): - b = bytes.fromhex(strip_0x(p[0])) - n = int.from_bytes(b, 'big') - block = self.backend.get_block_by_number(n) - return block - - - def eth_getBlockByHash(self, p): - block = self.backend.get_block_by_hash(p[0]) - return block - - - def eth_getTransactionByBlock(self, p): - block = self.eth_getBlockByHash(p) - try: - tx_index = int(p[1], 16) - except TypeError: - tx_index = int(p[1]) - tx_hash = block['transactions'][tx_index] - tx = self.eth_getTransactionByHash([tx_hash]) - return tx - - def eth_getBalance(self, p): - balance = self.backend.get_balance(p[0]) - hx = balance.to_bytes(32, 'big').hex() - return add_0x(unpad(hx)) - - - def eth_getTransactionCount(self, p): - nonce = self.backend.get_nonce(p[0]) - hx = nonce.to_bytes(4, 'big').hex() - return add_0x(unpad(hx)) - - - def eth_getTransactionByHash(self, p): - tx = self.backend.get_transaction_by_hash(p[0]) - return tx - - - def eth_getTransactionByBlockHashAndIndex(self, p): - #logg.debug('p {}'.format(p)) - #block = self.eth_getBlockByHash(p[0]) - #tx = block.transactions[p[1]] - #return eth_getTransactionByHash(tx[0]) - return self.eth_getTransactionByBlock(p) - - - def eth_getTransactionReceipt(self, p): - rcpt = self.backend.get_transaction_receipt(p[0]) - if rcpt.get('block_number') == None: - rcpt['block_number'] = rcpt['blockNumber'] - else: - rcpt['blockNumber'] = rcpt['block_number'] - return rcpt - - - def eth_getCode(self, p): - r = self.backend.get_code(p[0]) - return r - - - def eth_call(self, p): - tx_ethtester = to_ethtester_call(p[0]) - r = self.backend.call(tx_ethtester) - return r - - - def eth_gasPrice(self, p): - return hex(1000000000) - - - def personal_newAccount(self, passphrase): - a = self.backend.new_account() - return a - - - def eth_sign(self, p): - r = self.signer.sign_ethereum_message(strip_0x(p[0]), strip_0x(p[1])) - return r - - - def eth_sendRawTransaction(self, p): - r = self.backend.send_raw_transaction(p[0]) - return r - - - def eth_signTransaction(self, p): - raise NotImplementedError('needs transaction deserializer for EIP155Transaction') - tx_dict = p[0] - tx = EIP155Transaction(tx_dict, tx_dict['nonce'], tx_dict['chainId']) - passphrase = p[1] - r = self.signer.sign_transaction_to_rlp(tx, passphrase) - return r - - - def __verify_signer(self, tx, passphrase=''): - pk_bytes = self.backend.keystore.get(tx.sender) - pk = coincurve.PrivateKey(secret=pk_bytes) - result_address = private_key_to_address(pk) - assert strip_0x(result_address) == strip_0x(tx.sender) - - - def sign_transaction(self, tx, passphrase=''): - self.__verify_signer(tx, passphrase) - return self.signer.sign_transaction(tx, passphrase) - - - def sign_transaction_to_rlp(self, tx, passphrase=''): - self.__verify_signer(tx, passphrase) - return self.signer.sign_transaction_to_rlp(tx, passphrase) - - - def disconnect(self): - pass - - -def to_ethtester_call(tx): - if tx['gas'] == '': - tx['gas'] = '0x00' - - if tx['gasPrice'] == '': - tx['gasPrice'] = '0x00' - - tx = { - 'to': tx['to'], - 'from': tx['from'], - 'gas': int(tx['gas'], 16), - 'gas_price': int(tx['gasPrice'], 16), - 'data': tx['data'], - } - return tx diff --git a/chainlib/eth/unittest/ethtester.py b/chainlib/eth/unittest/ethtester.py @@ -1,80 +0,0 @@ -# standard imports -import os -import unittest -import logging - -# external imports -import eth_tester -from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer -from crypto_dev_signer.keystore.dict import DictKeystore -from hexathon import ( - strip_0x, - add_0x, - ) -from eth import constants -from eth.vm.forks.byzantium import ByzantiumVM - -# local imports -from .base import ( - EthTesterSigner, - TestRPCConnection, - ) -from chainlib.connection import ( - RPCConnection, - ConnType, - ) -from chainlib.eth.address import to_checksum_address -from chainlib.chain import ChainSpec - -logg = logging.getLogger(__name__) - -test_address = bytes.fromhex('Eb3907eCad74a0013c259D5874AE7f22DcBcC95C') - - -def create_tester_signer(keystore): - genesis_params = eth_tester.backends.pyevm.main.get_default_genesis_params({ - 'gas_limit': 8000000, - 'coinbase': test_address, # doesn't seem to work - }) - vm_configuration = ( - (constants.GENESIS_BLOCK_NUMBER, ByzantiumVM), - ) - genesis_state = eth_tester.PyEVMBackend._generate_genesis_state(num_accounts=30) - eth_backend = eth_tester.PyEVMBackend( - genesis_state=genesis_state, - genesis_parameters=genesis_params, - vm_configuration=vm_configuration, - ) - return EthTesterSigner(eth_backend, keystore) - - -class EthTesterCase(unittest.TestCase): - - def __init__(self, foo): - super(EthTesterCase, self).__init__(foo) - self.accounts = [] - - - def setUp(self): - self.chain_spec = ChainSpec('evm', 'foochain', 42) - self.keystore = DictKeystore() - eth_tester_instance = create_tester_signer(self.keystore) - self.signer = EIP155Signer(self.keystore) - self.helper = eth_tester_instance - self.backend = self.helper.backend - self.rpc = TestRPCConnection(None, eth_tester_instance, self.signer) - for a in self.keystore.list(): - self.accounts.append(add_0x(to_checksum_address(a))) - - def rpc_with_tester(chain_spec=self.chain_spec, url=None): - return self.rpc - - RPCConnection.register_constructor(ConnType.CUSTOM, rpc_with_tester, tag='default') - RPCConnection.register_constructor(ConnType.CUSTOM, rpc_with_tester, tag='signer') - RPCConnection.register_location('custom', self.chain_spec, tag='default', exist_ok=True) - RPCConnection.register_location('custom', self.chain_spec, tag='signer', exist_ok=True) - - - - def tearDown(self): - pass diff --git a/chainlib/hash.py b/chainlib/hash.py @@ -1,28 +1,48 @@ -# third-party imports +# external imports import sha3 -from hexathon import ( - add_0x, - strip_0x, - ) +from hexathon import strip_0x def keccak256_hex(s): + """Hex representation of Keccak256 hash of utf-8 string content. + + :param s: utf-8 string to hash + :type s: str + :rtype: str + :returns: Hex-value of keccak256 hash + """ h = sha3.keccak_256() h.update(s.encode('utf-8')) return h.digest().hex() def keccak256_string_to_hex(s): + """Alias of keccak256_hex + """ return keccak256_hex(s) def keecak256_bytes_to_hex(b): + """Hex representation of Keccak256 hash of literal byte content. + + :param b: bytes to hash + :type b: bytes + :rtype: str + :returns: Hex-value of keccak256 hash + """ h = sha3.keccak_256() h.update(b) return h.digest().hex() def keccak256_hex_to_hex(hx): + """Hex representation of Keccak256 hash of byte value of hex content. + + :param hx: Hex-value of bytes to hash + :type hx: str + :rtype: str + :returns: Hex-value of keccak256 hash + """ h = sha3.keccak_256() b = bytes.fromhex(strip_0x(hx)) h.update(b) diff --git a/chainlib/http.py b/chainlib/http.py @@ -1,3 +1,4 @@ +# standard imports import urllib import base64 import logging @@ -8,14 +9,16 @@ logg = logging.getLogger(__name__) # THANKS to https://stackoverflow.com/questions/2407126/python-urllib2-basic-auth-problem class PreemptiveBasicAuthHandler(urllib.request.HTTPBasicAuthHandler): """Handler for basic auth urllib callback. - - :param req: Request payload - :type req: str - :return: Request payload - :rtype: str """ def http_request(self, req): + """Handler for basic auth urllib callback. + + :param req: Request payload + :type req: str + :return: Request payload + :rtype: str + """ url = req.get_full_url() realm = None user, pw = self.passwd.find_user_password(realm, url) diff --git a/chainlib/interface.py b/chainlib/interface.py @@ -0,0 +1,255 @@ +# standard imports +import logging + +logg = logging.getLogger(__name__) + + +class ChainInterface: + """Common interface for all chain RPC query generators. + + This class should be overridden for every implementation of chain architecture RPC. + + It is up to the implementer which of the symbols to implement code for. Any implemented symbols should be associated using the ChainInterface.set method. + + All implemented methods must generate RPC queries ready to submit using an implementation of chainlib.connection.RPCConnection + """ + + interface_name = 'custom' + + def __unimplemented(*args, **kwargs): + raise NotImplementedError() + + + def __init__(self): + self._block_latest = self.__unimplemented + self._block_by_hash = self.__unimplemented + self._block_by_number = self.__unimplemented + self._block_from_src = self.__unimplemented + self._block_to_src = self.__unimplemented + self._tx_by_hash = self.__unimplemented + self._tx_by_block = self.__unimplemented + self._tx_receipt = self.__unimplemented + self._tx_raw = self.__unimplemented + self._tx_pack = self.__unimplemented + self._tx_unpack = self.__unimplemented + self._tx_from_src = self.__unimplemented + self._tx_to_src = self.__unimplemented + self._address_safe = self.__unimplemented + self._address_normal = self.__unimplemented + self._src_normalize = self.__unimplemented + + + def block_latest(self, *args, **kwargs): + """Retrieve the last block known to the node. + + :rtype: dict + :returns: rpc query object + """ + return self._block_latest(*args, **kwargs) + + + def block_by_hash(self, hsh, *args, **kwargs): + """Retrieve the block representation from the given block hash + + :param hsh: Block hash, as hex + :type hsh: str + :param id_generator: JSONRPC id generator + :type id_generator: JSONRPCIdGenerator + :rtype: dict + :returns: rpc query object + """ + return self._block_by_hash(hsh, *args, **kwargs) + + + def block_by_number(self, idx, *args, **kwargs): + """Retrieve the block representation from the given block height index + + :param idx: Block index number + :type idx: int + :param id_generator: JSONRPC id generator + :type id_generator: JSONRPCIdGenerator + :rtype: dict + :returns: rpc query object + """ + return self._block_by_number(idx, *args, **kwargs) + + + def block_from_src(self, src): + """Instantiate an implementation specific block object from the block representation returned from an RPC result + + :param src: Block source + :type src: dict + :param id_generator: JSONRPC id generator + :type id_generator: JSONRPCIdGenerator + :rtype: chainlib.block.Block + :returns: Block object + """ + return self._block_from_src(src) + + + def block_to_src(self, block): + """Implementation specific serialization of a block object + + :param block: Block object + :type block: chainlib.block.Block + :param id_generator: JSONRPC id generator + :type id_generator: JSONRPCIdGenerator + :rtype: dict + :returns: Serialized block object + """ + return self._block_to_src() + + + def tx_by_hash(self, hsh, *args, **kwargs): + """Retrieve the transaction representation by the given transaction hash + + :param hsh: Transaction hash, as hex + :type hsh: str + :param id_generator: JSONRPC id generator + :type id_generator: JSONRPCIdGenerator + :rtype: dict + :returns: rpc query object + """ + return self._tx_by_hash(hsh, *args, **kwargs) + + + def tx_by_block(self, hsh, idx, *args, **kwargs): + """Retrieve the transaction representation by the given block hash and transaction index + + :param hsh: Block hash, as hex + :type hsh: str + :param idx: Transaction index + :type idx: int + :param id_generator: JSONRPC id generator + :type id_generator: JSONRPCIdGenerator + :rtype: dict + :returns: rpc query object + + """ + return self._tx_by_block(hsh, idx, *args, **kwargs) + + + def tx_receipt(self, hsh, *args, **kwargs): + """Retrieve representation of confirmed transaction result for given transaction hash + + :param hsh: Transaction hash, as hex + :type hsh: str + :param id_generator: JSONRPC id generator + :type id_generator: JSONRPCIdGenerator + :rtype: dict + :returns: rpc query object + """ + return self._tx_receipt(hsh, *args, **kwargs) + + + def tx_raw(self, data, *args, **kwargs): + """Create a raw transaction query from the given wire format + + :param data: Transaction wire format, in hex + :type data: str + :param id_generator: JSONRPC id generator + :type id_generator: JSONRPCIdGenerator + :rtype: dict + :returns: rpc query object + + """ + return self._tx_raw(data, *args, **kwargs) + + + def tx_pack(self, tx, chain_spec): + """Generate wire format for transaction + + :param tx: Transaction object + :type tx: dict + :param chain_spec: Chain spec to generate wire format for + :type chain_spec: chainlib.chain.ChainSpec + :rtype: bytes + :returns: Wire format, in bytes + """ + return self._tx_pack(tx, chain_spec) + + + def tx_unpack(self, data, chain_spec): + """Generate transaction representation from wire format. + + :param data: Wire format, in bytes + :type data: bytes + :param chain_spec: Chain spec to parse wire format with + :type chain_spec: chainlib.chain.ChainSpec + :rtype: dict + :returns: Transaction representation + """ + return self._tx_unpack(data, chain_spec) + + + def tx_from_src(self, src, block=None): + """Instantiate transaction object from implementation specific transaction representation. + + :param src: Transaction representation + :type src: dict + :param block: Block object which transaction has been included in + :type block: chainlib.block.Block + :rtype: chainlib.tx.Tx + :returns: Transaction object + """ + return self._tx_from_src(src, block) + + + def tx_to_src(self, tx): + """Generate implementation specific transaction representation from transaction object. + + :param tx: Transaction object + :type tx: chainlib.tx.Tx + :rtype: dict + :returns: Transaction representation + """ + return self._tx_to_src(tx) + + + def address_safe(self, address): + """Generate implementation specific checksummed version of a crypto address. + + :param address: Potentially unsafe address + :type address: str + :rtype: str + :returns: Checksummed address + """ + return self._address_safe(address) + + + def address_normal(self, address): + """Generate normalized version of a crypto address. + + :param address: Crypto address + :type address: str + :rtype: str + :returns: Normalized address + """ + return self._address_normal(address) + + + def src_normalize(self, src): + """Generate a normalized source of an object representation. + + :param src: Object representation source + :type src: dict + :rtype: dict + :returns: Normalized representation + """ + return self._src_normalize(src) + + + def set(self, method, target): + """Associate object with method symbol. + + :param method: Method string + :type method: str + :param target: Target method + :type target: object + :raises AttributeError: Invalid method + """ + imethod = '_' + method + if not hasattr(self, imethod): + raise AttributeError('invalid method {}'.format(imethod)) + setattr(self, imethod, target) + logg.debug('set method {} on interface {}'.format(method, self.interface_name)) diff --git a/chainlib/jsonrpc.py b/chainlib/jsonrpc.py @@ -4,35 +4,140 @@ import uuid # local imports from .error import JSONRPCException +# TODO: Move all contents in this file to independent package -class DefaultErrorParser: + +class JSONRPCIdGenerator: + + def next(self): + raise NotImplementedError + + +class UUIDGenerator(JSONRPCIdGenerator): + """Create uuid ids for JSON-RPC queries. + """ + + def next(self): + """Create a new id + + :rtype: str + :returns: uuid string + """ + return str(uuid.uuid4()) + + +class IntSequenceGenerator(JSONRPCIdGenerator): + """Create sequential numeric ids for JSON-RPC queries. + + :param start: Start at the specificed numeric id + :type start: int + """ + def __init__(self, start=0): + self.id = start + + + def next(self): + """Get the next id in the sequence. + + :rtype: int + :returns: numeric id + """ + next_id = self.id + self.id += 1 + return next_id + + +default_id_generator = UUIDGenerator() + + +class ErrorParser: + """Base class for parsing JSON-RPC error repsonses + """ def translate(self, error): + """Interface method called by jsonrpc_result when encountering an error + + This class method may be overriden to provide more fine-grained context for both general and implementation specific errors. + + :param error: JSON-RPC error response object + :type error: dict + :rtype: chainlib.error.JSONRPCException + :returns: Descriptiv JSONRPCException + """ return JSONRPCException('default parser code {}'.format(error)) -def jsonrpc_template(): - return { - 'jsonrpc': '2.0', - 'id': str(uuid.uuid4()), - 'method': None, - 'params': [], - } +# deprecated symbol, provided for backward compatibility +DefaultErrorParser = ErrorParser -def jsonrpc_result(o, ep): - if o.get('error') != None: - raise ep.translate(o) - return o['result'] + +class JSONRPCRequest: + """JSON-RPC request builder class. + + :param id_generator: Generator to use to define the id of the request. + :type id_generator: chainlib.jsonrpc.JSONRPCIdGenerator + """ + def __init__(self, id_generator=default_id_generator): + if id_generator == None: + id_generator = default_id_generator + self.id_generator = id_generator + + + def template(self): + """Return a empty json-rpc 2.0 dictionary query object + + :rtype: dict + :returns: json-rpc query object + """ + return { + 'jsonrpc': '2.0', + 'id': None, + 'method': None, + 'params': [], + } + + + def finalize(self, request): + """Apply next json-rpc id to json-rpc dictionary query object + + :param request: json-rpc query + :type request: dict + :rtype: dict + :returns: json-rpc query with id added + """ + request['id'] = self.id_generator.next() + return request def jsonrpc_response(request_id, result): - return { - 'jsonrpc': '2.0', - 'id': request_id, - 'result': result, - } + """Create a json-rpc dictionary response object from the given id an result value. + + :param request_id: json-rpc query id + :type request_id: str or int + :param result: result value + :type result: any json-serializable value + :rtype: dict + :result: json-rpc response object + """ + return { + 'jsonrpc': '2.0', + 'id': request_id, + 'result': result, + } + def jsonrpc_error(request_id, code=-32000, message='Server error'): + """Create a json-rpc dictionary error object for the given id with error code and message. + + :param request_id: json-rpc query id + :type request_id: str or int + :param code: json-rpc error code + :type code: int + :param message: Error message + :type message: str + :rtype: dict + :returns: json-rpc error object + """ return { 'jsonrpc': '2.0', 'id': request_id, @@ -41,3 +146,21 @@ def jsonrpc_error(request_id, code=-32000, message='Server error'): 'message': message, }, } + + +def jsonrpc_result(o, ep): + """Retrieve the result from a json-rpc response object. + + If the result object is an error, the provided error parser will be used to generate the corresponding exception. + + :param o: json-rpc response object + :type o: dict + :param ep: Error parser + :type ep: chainlib.jsonrpc.ErrorParser + :raises JSONRPCException: exception encapsulating the error value of the response + :rtype: any json-deserializable value + :returns: The result value of the response + """ + if o.get('error') != None: + raise ep.translate(o) + return o['result'] diff --git a/chainlib/stat.py b/chainlib/stat.py @@ -1,6 +1,11 @@ +# standard imports import datetime + + class ChainStat: + """Block time aggregator. + """ def __init__(self): self.block_timestamp_last = None @@ -9,6 +14,11 @@ class ChainStat: def block_apply(self, block): + """Add data from block to aggregate. + + :param block: Block to add + :type block: chainlib.block.Block + """ if self.block_timestamp_last == None: self.block_timestamp_last = block.timestamp @@ -25,5 +35,11 @@ class ChainStat: self.block_timestamp_last = block.timestamp + def block_average(self): + """Get current aggregated average. + + :rtype: float + :returns: Aggregate average block time, in seconds + """ return self.block_avg_aggregate diff --git a/chainlib/status.py b/chainlib/status.py @@ -2,6 +2,8 @@ import enum class Status(enum.Enum): + """Representation of transaction status in network. + """ PENDING = 0 SUCCESS = 1 ERROR = 2 diff --git a/chainlib/tx.py b/chainlib/tx.py @@ -0,0 +1,14 @@ +class Tx: + """Base class to extend for implementation specific transaction objects. + + :param src: Transaction representation source + :type src: dict + :param block: Block in which transaction has been included + :type block: chainlib.block.Block + """ + + def __init__(self, src, block=None): + self.txs = [] + self.src = src + self.block = block + self.block_src = None diff --git a/requirements.txt b/requirements.txt @@ -1,5 +1,3 @@ -crypto-dev-signer~=0.4.14b3 +crypto-dev-signer>=0.4.14b7,<=0.4.14 pysha3==1.0.2 -hexathon~=0.0.1a7 -websocket-client==0.57.0 -potaahto~=0.0.1a1 +hexathon~=0.0.1a8 diff --git a/setup.cfg b/setup.cfg @@ -1,6 +1,5 @@ [metadata] -name = chainlib -version = 0.0.3rc3 +version = 0.0.8a2 description = Generic blockchain access library and tooling author = Louis Holbrook author_email = dev@holbrook.no @@ -9,7 +8,6 @@ keywords = dlt blockchain cryptocurrency - ethereum classifiers = Programming Language :: Python :: 3 Operating System :: OS Independent @@ -18,27 +16,14 @@ classifiers = Intended Audience :: Developers License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+) Topic :: Internet -# Topic :: Blockchain :: EVM license = GPL3 licence_files = LICENSE.txt + [options] python_requires = >= 3.6 +include_package_data = True packages = chainlib - chainlib.eth - chainlib.eth.runnable - chainlib.eth.pytest - chainlib.eth.unittest - -[options.entry_points] -console_scripts = - eth-balance = chainlib.eth.runnable.balance:main - eth-checksum = chainlib.eth.runnable.checksum:main - eth-gas = chainlib.eth.runnable.gas:main - eth-raw = chainlib.eth.runnable.raw:main - eth-get = chainlib.eth.runnable.get:main - eth-decode = chainlib.eth.runnable.decode:main - eth-info = chainlib.eth.runnable.info:main - eth = chainlib.eth.runnable.info:main + chainlib.cli diff --git a/setup.py b/setup.py @@ -12,17 +12,9 @@ while True: requirements.append(l.rstrip()) f.close() -test_requirements = [] -f = open('test_requirements.txt', 'r') -while True: - l = f.readline() - if l == '': - break - test_requirements.append(l.rstrip()) -f.close() - - setup( install_requires=requirements, - tests_require=test_requirements, + extras_require={ + 'xdg': "pyxdg~=0.27", + } ) diff --git a/test_requirements.txt b/test_requirements.txt @@ -1,4 +0,0 @@ -eth_tester==0.5.0b3 -py-evm==0.3.0a20 -rlp==2.0.1 -pytest==6.0.1 diff --git a/tests/test_abi.py b/tests/test_abi.py @@ -1,29 +0,0 @@ -from chainlib.eth.contract import ( - ABIContractEncoder, - ABIContractType, - ) - - -def test_abi_param(): - - e = ABIContractEncoder() - e.uint256(42) - e.bytes32('0x666f6f') - e.address('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef') - e.method('foo') - e.typ(ABIContractType.UINT256) - e.typ(ABIContractType.BYTES32) - e.typ(ABIContractType.ADDRESS) - - assert e.types[0] == ABIContractType.UINT256 - assert e.types[1] == ABIContractType.BYTES32 - assert e.types[2] == ABIContractType.ADDRESS - assert e.contents[0] == '000000000000000000000000000000000000000000000000000000000000002a' - assert e.contents[1] == '0000000000000000000000000000000000000000000000000000000000666f6f' - assert e.contents[2] == '000000000000000000000000deadbeefdeadbeefdeadbeefdeadbeefdeadbeef' - - assert e.get() == 'a08f54bb000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000666f6f000000000000000000000000deadbeefdeadbeefdeadbeefdeadbeefdeadbeef' - - -if __name__ == '__main__': - test_abi_param() diff --git a/tests/test_address.py b/tests/test_address.py @@ -1,35 +0,0 @@ -import unittest - -from chainlib.eth.address import ( - is_address, - is_checksum_address, - to_checksum, - ) - -from tests.base import TestBase - - -class TestChain(TestBase): - - def test_chain_spec(self): - checksum_address = '0xEb3907eCad74a0013c259D5874AE7f22DcBcC95C' - plain_address = checksum_address.lower() - - self.assertEqual(checksum_address, to_checksum(checksum_address)) - - self.assertTrue(is_address(plain_address)) - self.assertFalse(is_checksum_address(plain_address)) - self.assertTrue(is_checksum_address(checksum_address)) - - self.assertFalse(is_address(plain_address + "00")) - self.assertFalse(is_address(plain_address[:len(plain_address)-2])) - - with self.assertRaises(ValueError): - to_checksum(plain_address + "00") - - with self.assertRaises(ValueError): - to_checksum(plain_address[:len(plain_address)-2]) - - -if __name__ == '__main__': - unittest.main() diff --git a/tests/test_interface.py b/tests/test_interface.py @@ -0,0 +1,28 @@ +# standard imports +import unittest +from unittest.mock import Mock +import logging + +# local imports +from chainlib.interface import ChainInterface + +logg = logging.getLogger() + + +# replace with mocker +def block_from_src(src): + logg.debug('from src called with ' + src) + + +class TestInterface(unittest.TestCase): + + def test_interface_set(self): + ifc = ChainInterface() + block_from_src = Mock() + ifc.set('block_from_src', block_from_src) + ifc.block_from_src('foo') + block_from_src.assert_called() + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_nonce.py b/tests/test_nonce.py @@ -1,26 +0,0 @@ -# standard imports -import os -import unittest - -# local imports -from chainlib.eth.address import to_checksum_address -from chainlib.eth.nonce import OverrideNonceOracle -from hexathon import add_0x - -# test imports -from tests.base import TestBase - - -class TestNonce(TestBase): - - def test_nonce(self): - addr_bytes = os.urandom(20) - addr = add_0x(to_checksum_address(addr_bytes.hex())) - n = OverrideNonceOracle(addr, 42) - self.assertEqual(n.get_nonce(), 42) - self.assertEqual(n.next_nonce(), 42) - self.assertEqual(n.next_nonce(), 43) - - -if __name__ == '__main__': - unittest.main() diff --git a/tests/test_sign.py b/tests/test_sign.py @@ -1,119 +0,0 @@ -# standard imports -import os -import socket -import unittest -import unittest.mock -import logging -import json - -# external imports -from crypto_dev_signer.eth.transaction import EIP155Transaction -from crypto_dev_signer.eth.signer.defaultsigner import ReferenceSigner -from crypto_dev_signer.keystore.dict import DictKeystore - -# local imports -import chainlib -from chainlib.eth.connection import EthUnixSignerConnection -from chainlib.eth.sign import sign_transaction -from chainlib.eth.tx import TxFactory -from chainlib.eth.address import to_checksum_address -from chainlib.jsonrpc import ( - jsonrpc_response, - jsonrpc_error, - ) -from hexathon import ( - add_0x, - ) -from chainlib.chain import ChainSpec - -from tests.base import TestBase - -logging.basicConfig(level=logging.DEBUG) -logg = logging.getLogger() - -keystore = DictKeystore() -alice = keystore.new() -bob = keystore.new() - - -class Mocket(socket.socket): - - req_id = None - error = False - tx = None - signer = None - - def connect(self, v): - return self - - - def send(self, v): - o = json.loads(v) - logg.debug('mocket received {}'.format(v)) - Mocket.req_id = o['id'] - params = o['params'][0] - if to_checksum_address(params.get('from')) != alice: - logg.error('from does not match alice {}'.format(params)) - Mocket.error = True - if to_checksum_address(params.get('to')) != bob: - logg.error('to does not match bob {}'.format(params)) - Mocket.error = True - if not Mocket.error: - Mocket.tx = EIP155Transaction(params, params['nonce'], params['chainId']) - logg.debug('mocket {}'.format(Mocket.tx)) - return len(v) - - - def recv(self, c): - if Mocket.req_id != None: - - o = None - if Mocket.error: - o = jsonrpc_error(Mocket.req_id) - else: - tx = Mocket.tx - r = Mocket.signer.sign_transaction_to_rlp(tx) - Mocket.tx = None - o = jsonrpc_response(Mocket.req_id, add_0x(r.hex())) - Mocket.req_id = None - return json.dumps(o).encode('utf-8') - - return b'' - - -class TestSign(TestBase): - - - def setUp(self): - super(TestSign, self).__init__() - self.chain_spec = ChainSpec('evm', 'foo', 42) - - - logg.debug('alice {}'.format(alice)) - logg.debug('bob {}'.format(bob)) - - self.signer = ReferenceSigner(keystore) - - Mocket.signer = self.signer - - - def test_sign_build(self): - with unittest.mock.patch('chainlib.connection.socket.socket', Mocket) as m: - rpc = EthUnixSignerConnection('foo', chain_spec=self.chain_spec) - f = TxFactory(self.chain_spec, signer=rpc) - tx = f.template(alice, bob, use_nonce=True) - tx = f.build(tx) - logg.debug('tx result {}'.format(tx)) - - - def test_sign_rpc(self): - with unittest.mock.patch('chainlib.connection.socket.socket', Mocket) as m: - rpc = EthUnixSignerConnection('foo') - f = TxFactory(self.chain_spec, signer=rpc) - tx = f.template(alice, bob, use_nonce=True) - tx_o = sign_transaction(tx) - rpc.do(tx_o) - - -if __name__ == '__main__': - unittest.main() diff --git a/tests/test_stat.py b/tests/test_stat.py @@ -1,49 +0,0 @@ -# standard imports -import unittest -import datetime - -# external imports -from chainlib.stat import ChainStat -from chainlib.eth.block import Block - - -class TestStat(unittest.TestCase): - - def test_block(self): - - s = ChainStat() - - d = datetime.datetime.utcnow() - datetime.timedelta(seconds=30) - block_a = Block({ - 'timestamp': d.timestamp(), - 'hash': None, - 'transactions': [], - 'number': 41, - }) - - d = datetime.datetime.utcnow() - block_b = Block({ - 'timestamp': d.timestamp(), - 'hash': None, - 'transactions': [], - 'number': 42, - }) - - s.block_apply(block_a) - s.block_apply(block_b) - self.assertEqual(s.block_average(), 30.0) - - d = datetime.datetime.utcnow() + datetime.timedelta(seconds=10) - block_c = Block({ - 'timestamp': d.timestamp(), - 'hash': None, - 'transactions': [], - 'number': 43, - }) - - s.block_apply(block_c) - self.assertEqual(s.block_average(), 20.0) - - -if __name__ == '__main__': - unittest.main() diff --git a/tests/test_tx.py b/tests/test_tx.py @@ -1,30 +0,0 @@ -# standard imports -import unittest - -# local imports -from chainlib.eth.unittest.ethtester import EthTesterCase -from chainlib.eth.nonce import RPCNonceOracle -from chainlib.eth.gas import ( - RPCGasOracle, - Gas, - ) -from chainlib.eth.tx import ( - unpack, - TxFormat, - ) -from hexathon import strip_0x - -class TxTestCase(EthTesterCase): - - def test_tx_reciprocal(self): - nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc) - gas_oracle = RPCGasOracle(self.rpc) - c = Gas(signer=self.signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle, chain_spec=self.chain_spec) - (tx_hash_hex, o) = c.create(self.accounts[0], self.accounts[1], 1024, tx_format=TxFormat.RLP_SIGNED) - tx = unpack(bytes.fromhex(strip_0x(o)), self.chain_spec) - self.assertEqual(tx['from'], self.accounts[0]) - self.assertEqual(tx['to'], self.accounts[1]) - - -if __name__ == '__main__': - unittest.main() diff --git a/tests/testdata/keystore/UTC--2021-01-08T17-18-44.521011372Z--eb3907ecad74a0013c259d5874ae7f22dcbcc95c b/tests/testdata/keystore/UTC--2021-01-08T17-18-44.521011372Z--eb3907ecad74a0013c259d5874ae7f22dcbcc95c @@ -1 +0,0 @@ -{"address":"eb3907ecad74a0013c259d5874ae7f22dcbcc95c","crypto":{"cipher":"aes-128-ctr","ciphertext":"b0f70a8af4071faff2267374e2423cbc7a71012096fd2215866d8de7445cc215","cipherparams":{"iv":"9ac89383a7793226446dcb7e1b45cdf3"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"299f7b5df1d08a0a7b7f9c9eb44fe4798683b78da3513fcf9603fd913ab3336f"},"mac":"6f4ed36c11345a9a48353cd2f93f1f92958c96df15f3112a192bc994250e8d03"},"id":"61a9dd88-24a9-495c-9a51-152bd1bfaa5b","version":3} -\ No newline at end of file