Correct erc20 extension req

chaind/eth/chain.py

@@ -2,6 +2,7 @@
 from chainlib.interface import ChainInterface
 from chainlib.eth.block import (
         block_by_number,
+        block_latest,
         Block,
         )
 from chainlib.eth.tx import (
@@ -16,3 +17,4 @@ class EthChainInterface(ChainInterface):
         self._block_from_src = Block.from_src
         self._tx_receipt = receipt
         self._src_normalize = Tx.src_normalize
+        self._block_latest = block_latest

chaind/eth/data/config/config.ini

@@ -4,13 +4,3 @@ runtime_dir =
 id =
 data_dir =
 dispatch_delay = 0.01
-
-[database]
-engine =
-name = chaind
-driver =
-user =
-password =
-host =
-port =
-debug = 0

chaind/eth/runnable/queuer.py

@@ -5,6 +5,8 @@ import signal
 
 # external imports
 import chainlib.eth.cli
+import chaind.cli
+import chainqueue.cli
 from chaind.session import SessionController
 from chaind.setup import Environment
 from chaind.error import (
@@ -30,6 +32,7 @@ from chaind.adapters.fs import ChaindFsAdapter
 # local imports
 from chaind.eth.dispatch import EthDispatcher
 from chaind.eth.cache import EthCacheTx
+from chaind.eth.settings import ChaindEthSettings
 
 logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
@@ -41,36 +44,49 @@ env = Environment(domain='eth', env=os.environ)
 
 arg_flags = chainlib.eth.cli.argflag_std_read
 argparser = chainlib.eth.cli.ArgumentParser(arg_flags)
-argparser.add_argument('--data-dir', type=str, help='data directory')
-argparser.add_argument('--runtime-dir', type=str, help='runtime directory')
-argparser.add_argument('--session-id', dest='session_id', type=str, help='session identifier')
-argparser.add_argument('--dispatch-delay', dest='dispatch_delay', type=float, help='socket timeout before processing queue')
+
+queue_arg_flags = 0
+chainqueue.cli.process_flags(argparser, queue_arg_flags)
+
+local_arg_flags = chaind.cli.argflag_local_base | chaind.cli.ChaindFlag.DISPATCH | chaind.cli.ChaindFlag.SOCKET
+chaind.cli.process_flags(argparser, local_arg_flags)
+
 args = argparser.parse_args()
-extra_args = {
-    'runtime_dir': 'SESSION_RUNTIME_DIR',
-    'data_dir': 'SESSION_DATA_DIR',
-    'session_id': 'SESSION_ID', 
-    'dispatch_delay': 'SESSION_DISPATCH_DELAY',
-        }
-config = chainlib.eth.cli.Config.from_args(args, arg_flags, extra_args=extra_args, base_config_dir=config_dir)
-
-logg.debug('session id {} {}'.format(type(config.get('SESSION_ID')), config.get('SESSION_ID')))
-if config.get('SESSION_ID') == None:
-    config.add(env.session, 'SESSION_ID', exists_ok=True)
-if config.get('SESSION_RUNTIME_DIR') == None:
-    config.add(env.runtime_dir, 'SESSION_RUNTIME_DIR', exists_ok=True)
-if config.get('SESSION_DATA_DIR') == None:
-    config.add(env.data_dir, 'SESSION_DATA_DIR', exists_ok=True)
-if not config.get('SESSION_SOCKET_PATH'):
-    socket_path = os.path.join(config.get('SESSION_RUNTIME_DIR'), config.get('SESSION_ID'), 'chaind.sock')
-    config.add(socket_path, 'SESSION_SOCKET_PATH', True)
 
+base_config_dir = [chainqueue.cli.config_dir, chaind.cli.config_dir]
+config = chainlib.eth.cli.Config.from_args(args, arg_flags, base_config_dir=base_config_dir)
+config = chaind.cli.process_config(config, args, local_arg_flags)
+config = chainqueue.cli.process_config(config, args, queue_arg_flags)
+config.add('eth', 'CHAIND_ENGINE', False)
+config.add('queue', 'CHAIND_COMPONENT', False)
 logg.debug('config loaded:\n{}'.format(config))
 
-def process_outgoing(chain_spec, adapter, rpc, limit=100):
-    upcoming = adapter.upcoming()
-    logg.info('process {} {} {}'.format(chain_spec, adapter, rpc))
-    logg.info('upcoming {}'.format(upcoming))
+settings = ChaindEthSettings(include_queue=True)
+settings.process(config)
+
+logg.debug('settings:\n{}'.format(settings))
+
+
+def process_outgoing(chain_spec, adapter, rpc, limit=50):
+    adapter = None
+    process_err = None
+    for i in range(2):
+        try:
+            adapter = ChaindFsAdapter(
+                settings.get('CHAIN_SPEC'),
+                settings.dir_for('queue'),
+                EthCacheTx,
+                dispatcher,
+                )
+        except BackendIntegrityError as e:
+            process_err = e
+            continue
+
+    if adapter == None:
+        raise BackendIntegrityError(process_err)
+    
+    upcoming = adapter.upcoming(limit=limit)
+    logg.info('processor has {} candidates for {}, processing with limit {} adapter {} rpc {}'.format(len(upcoming), chain_spec, limit, adapter, rpc))
     i = 0
     for tx_hash in upcoming:
         if adapter.dispatch(tx_hash):
@@ -86,16 +102,18 @@ tx_normalizer = TxHexNormalizer().tx_hash
 token_cache_store = CacheTokenTx(chain_spec, normalizer=tx_normalizer)
 dispatcher = EthDispatcher(conn)
 queue_adapter = ChaindFsAdapter(
-        chain_spec,
-        config.get('SESSION_DATA_DIR'),
+        settings.get('CHAIN_SPEC'),
+        settings.dir_for('queue'),
         EthCacheTx,
         dispatcher,
         )
 
-ctrl = SessionController(config, queue_adapter, process_outgoing)
+ctrl = SessionController(settings, queue_adapter, process_outgoing)
 signal.signal(signal.SIGINT, ctrl.shutdown)
 signal.signal(signal.SIGTERM, ctrl.shutdown)
 
+logg.info('session id is ' + settings.get('SESSION_ID'))
+logg.info('session socket path is ' + settings.get('SESSION_SOCKET_PATH'))
 
 def main():
     while True:

chaind/eth/runnable/send.py

@@ -10,6 +10,8 @@ import socket
 
 # external imports
 import chainlib.eth.cli
+import chainqueue.cli
+import chaind.cli
 from chaind.setup import Environment
 from chainlib.eth.gas import price
 from chainlib.chain import ChainSpec
@@ -24,32 +26,41 @@ from chaind.eth.cli.output import (
         Outputter,
         OpMode,
         )
+from chaind.eth.settings import ChaindEthSettings
 
 logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
 
-script_dir = os.path.dirname(os.path.realpath(__file__)) 
-config_dir = os.path.join(script_dir, '..', 'data', 'config')
-
-
 arg_flags = chainlib.eth.cli.argflag_std_write
-argparser = chainlib.eth.cli.ArgumentParser(arg_flags)
-argparser.add_argument('--socket', dest='socket', type=str, help='Socket to send transactions to')
-argparser.add_argument('--token-module', dest='token_module', type=str, help='Python module path to resolve tokens from identifiers')
+argparser = chainlib.eth.cli.ArgumentParser(arg_flags, arg_long={'-s': '--send-rpc'})
 argparser.add_positional('source', required=False, type=str, help='Transaction source file')
+
+local_arg_flags = chaind.cli.argflag_local_socket_client | chaind.cli.ChaindFlag.TOKEN
+chaind.cli.process_flags(argparser, local_arg_flags)
+
+chainqueue.cli.process_flags(argparser, 0)
+
 args = argparser.parse_args()
 
-extra_args = {
-        'socket': None,
-        'source': None,
-        }
 env = Environment(domain='eth', env=os.environ)
-config = chainlib.eth.cli.Config.from_args(args, arg_flags, extra_args=extra_args, base_config_dir=config_dir)
-config.add(args.token_module, 'TOKEN_MODULE', True)
+
+base_config_dir = [chaind.cli.config_dir, chainqueue.cli.config_dir]
+config = chainlib.eth.cli.Config.from_args(args, arg_flags, base_config_dir=base_config_dir)
+config = chainqueue.cli.process_config(config, args, 0)
+config = chaind.cli.process_config(config, args, local_arg_flags)
+config.add(args.source, '_SOURCE', False)
+config.add('eth', 'CHAIND_ENGINE', False)
+config.add('queue', 'CHAIND_COMPONENT', False)
+logg.debug('config loaded:\n{}'.format(config))
 
 wallet = chainlib.eth.cli.Wallet()
 wallet.from_config(config)
 
+settings = ChaindEthSettings(include_queue=True)
+settings.process(config)
+
+logg.debug('settings:\n{}'.format(settings))
+
 rpc = chainlib.eth.cli.Rpc(wallet=wallet)
 conn = rpc.connect_by_config(config)
 
@@ -58,19 +69,19 @@ chain_spec = ChainSpec.from_chain_str(config.get('CHAIN_SPEC'))
 mode = OpMode.STDOUT
 
 re_unix = r'^ipc://(/.+)'
-m = re.match(re_unix, config.get('_SOCKET', ''))
+m = re.match(re_unix, config.get('SESSION_SOCKET_PATH', ''))
 if m != None:
-    config.add(m.group(1), '_SOCKET', exists_ok=True)
+    config.add(m.group(1), 'SESSION_SOCKET_PATH', exists_ok=True)
     r = 0
     try:
-        stat_info = os.stat(config.get('_SOCKET'))
+        stat_info = os.stat(config.get('SESSION_SOCKET_PATH'))
         if not stat.S_ISSOCK(stat_info.st_mode):
             r = 1
     except FileNotFoundError:
         r = 1
 
     if r > 0:
-        sys.stderr.write('{} is not a socket\n'.format(config.get('_SOCKET')))
+        sys.stderr.write('{} is not a socket\n'.format(config.get('SESSION_SOCKET_PATH')))
         sys.exit(1)
     
     mode = OpMode.UNIX
@@ -82,11 +93,25 @@ if config.get('_SOURCE') == None:
     sys.exit(1)
 
 
+class SocketSender:
+
+    def __init__(self, settings):
+        self.path = settings.get('SESSION_SOCKET_PATH')
+
+    def send(self, tx):
+        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        s.connect(self.path)
+        s.sendall(tx.encode('utf-8'))
+        r = s.recv(68)
+        s.close()
+        return r
+
+
 def main():
     token_resolver = None
-    if config.get('TOKEN_MODULE') != None:
+    if settings.get('TOKEN_MODULE') != None:
         import importlib
-        m = importlib.import_module(config.get('TOKEN_MODULE'))
+        m = importlib.import_module(settings.get('TOKEN_MODULE'))
         m = m.TokenResolver
     else:
         from chaind.eth.token.gas import GasTokenResolver
@@ -103,6 +128,11 @@ def main():
         sys.stderr.write('processing error: {}. processors: {}\n'.format(str(e), str(processor)))
         sys.exit(1)
 
+    sender = None
+    if config.true('_SOCKET_SEND'):
+        if settings.get('SESSION_SOCKET_PATH') != None:
+            sender = SocketSender(settings)
+
     tx_iter = iter(processor)
     out = Outputter(mode)
     while True:
@@ -112,6 +142,9 @@ def main():
         except StopIteration:
             break
         tx_hex = tx_bytes.hex()
+        if sender != None:
+            r = sender.send(tx_hex)
+            logg.info('sent {} result {}'.format(tx_hex, r))
         print(out.do(tx_hex))
 
 

chaind/eth/runnable/syncer.py

@@ -3,20 +3,23 @@ import os
 import logging
 
 # external imports
-import chainlib.eth.cli
+import chainlib.cli
+import chainsyncer.cli
+import chaind.cli
 from chaind.setup import Environment
 from chaind.filter import StateFilter
-from chaind.adapters.fs import ChaindFsAdapter
 from chainlib.eth.block import block_latest
-from chainlib.eth.connection import EthHTTPConnection
-from chainlib.chain import ChainSpec
 from hexathon import strip_0x
 from chainsyncer.store.fs import SyncFsStore
 from chainsyncer.driver.chain_interface import ChainInterfaceDriver
+from chainsyncer.error import SyncDone
+
+# local imports
+from chaind.eth.settings import ChaindEthSettings
+
 
 # local imports
 from chaind.eth.cache import EthCacheTx
-from chaind.eth.chain import EthChainInterface
 
 logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
@@ -26,91 +29,46 @@ config_dir = os.path.join(script_dir, '..', 'data', 'config')
 
 env = Environment(domain='eth', env=os.environ)
 
-arg_flags = chainlib.eth.cli.argflag_std_read
-argparser = chainlib.eth.cli.ArgumentParser(arg_flags)
-argparser.add_argument('--data-dir', type=str, help='data directory')
-argparser.add_argument('--runtime-dir', type=str, help='runtime directory')
-argparser.add_argument('--session-id', dest='session_id', type=str, help='session identifier')
-argparser.add_argument('--dispatch-delay', dest='dispatch_delay', type=float, help='socket timeout before processing queue')
-argparser.add_argument('--offset', type=int, default=0, help='Start sync on this block')
-argparser.add_argument('--until', type=int, default=0, help='Terminate sync on this block')
-argparser.add_argument('--head', action='store_true', help='Start at current block height (overrides --offset, assumes --keep-alive)')
-argparser.add_argument('--keep-alive', action='store_true', dest='keep_alive', help='Continue to sync head after history sync complete')
+arg_flags = chainlib.cli.argflag_std_base | chainlib.cli.Flag.CHAIN_SPEC
+argparser = chainlib.cli.ArgumentParser(arg_flags)
+
+local_arg_flags = chaind.cli.argflag_local_base
+chaind.cli.process_flags(argparser, local_arg_flags)
+
+sync_flags = chainsyncer.cli.SyncFlag.RANGE | chainsyncer.cli.SyncFlag.HEAD
+chainsyncer.cli.process_flags(argparser, sync_flags)
+
 args = argparser.parse_args()
-extra_args = {
-    'runtime_dir': 'SESSION_RUNTIME_DIR',
-    'data_dir': 'SESSION_DATA_DIR',
-    'session_id': 'SESSION_ID', 
-    'dispatch_delay': 'SESSION_DISPATCH_DELAY',
-        }
-config = chainlib.eth.cli.Config.from_args(args, arg_flags, extra_args=extra_args, base_config_dir=config_dir)
-
-logg.debug('session id {} {}'.format(type(config.get('SESSION_ID')), config.get('SESSION_ID')))
-if config.get('SESSION_ID') == None:
-    config.add(env.session, 'SESSION_ID', exists_ok=True)
-if config.get('SESSION_RUNTIME_DIR') == None:
-    config.add(env.runtime_dir, 'SESSION_RUNTIME_DIR', exists_ok=True)
-if config.get('SESSION_DATA_DIR') == None:
-    config.add(env.data_dir, 'SESSION_DATA_DIR', exists_ok=True)
-if not config.get('SESSION_SOCKET_PATH'):
-    socket_path = os.path.join(config.get('SESSION_RUNTIME_DIR'), config.get('SESSION_ID'), 'chaind.sock')
-    config.add(socket_path, 'SESSION_SOCKET_PATH', True)
-config.add(args.keep_alive, '_KEEP_ALIVE', True)
-config.add(args.head, '_HEAD', True)
-config.add(args.offset, '_SYNC_OFFSET', True)
 
+base_config_dir = [
+    chainsyncer.cli.config_dir,
+    chaind.cli.config_dir,
+        ]
+config = chainlib.cli.Config.from_args(args, arg_flags, base_config_dir=base_config_dir)
+config = chainsyncer.cli.process_config(config, args, sync_flags)
+config = chaind.cli.process_config(config, args, local_arg_flags)
+config.add('eth', 'CHAIND_ENGINE', False)
+config.add('sync', 'CHAIND_COMPONENT', False)
 logg.debug('config loaded:\n{}'.format(config))
 
-chain_spec = ChainSpec.from_chain_str(config.get('CHAIN_SPEC'))
+settings = ChaindEthSettings(include_sync=True)
+settings.process(config)
 
-conn = EthHTTPConnection(url=config.get('RPC_PROVIDER'), chain_spec=chain_spec)
+logg.debug('settings:\n{}'.format(settings))
 
 
 def main():
-    o = block_latest()
-    r = conn.do(o)
-    block_offset = int(strip_0x(r), 16) + 1
-    logg.info('network block height is {}'.format(block_offset))
-
-    keep_alive = False
-    session_block_offset = 0
-    block_limit = 0
-    if args.head:
-        session_block_offset = block_offset
-        block_limit = -1
-        keep_alive = True
-    else:
-        session_block_offset = args.offset
-
-    if args.until > 0:
-        if not args.head and args.until <= session_block_offset:
-            raise ValueError('sync termination block number must be later than offset ({} >= {})'.format(session_block_offset, args.until))
-        block_limit = args.until
-    elif config.true('_KEEP_ALIVE'):
-        keep_alive=True
-        block_limit = -1
-
-    if session_block_offset == -1:
-        session_block_offset = block_offset
-    elif not config.true('_KEEP_ALIVE'):
-        if block_limit == 0:
-            block_limit = block_offset
-
-    queue_adapter = ChaindFsAdapter(
-        chain_spec,
-        config.get('SESSION_DATA_DIR'),
-        EthCacheTx,
-        None,
-        )
-    fltr = StateFilter(queue_adapter)
-    sync_store = SyncFsStore(config.get('SESSION_RUNTIME_DIR'), session_id=config.get('SESSION_ID'))
+    fltr = StateFilter(settings.get('CHAIN_SPEC'), settings.dir_for('queue'), EthCacheTx)
+    sync_store = SyncFsStore(settings.get('SESSION_DATA_DIR'), session_id=settings.get('SESSION_ID'))
     sync_store.register(fltr)
 
-    logg.debug('session block ofset {}'.format(session_block_offset))
+    logg.debug('session block offset {}'.format(settings.get('SYNCER_OFFSET')))
 
-    chain_interface = EthChainInterface()
-    drv = ChainInterfaceDriver(sync_store, chain_interface, offset=session_block_offset, target=block_limit)
-    drv.run(conn)
+    drv = ChainInterfaceDriver(sync_store, settings.get('SYNCER_INTERFACE'), offset=settings.get('SYNCER_OFFSET'), target=settings.get('SYNCER_LIMIT'))
+    try:
+        drv.run(settings.get('RPC'))
+    except SyncDone as e:
+        logg.info('sync done: {}'.format(e))
    
 
 if __name__ == '__main__':

chaind/eth/settings.py

@@ -0,0 +1,18 @@
+# external imports
+from chainlib.eth.connection import EthHTTPConnection
+from chaind.settings import ChaindSettings
+from chaind.eth.chain import EthChainInterface
+
+
+class ChaindEthSettings(ChaindSettings):
+
+    def process_sync_interface(self, config):
+        self.o['SYNCER_INTERFACE'] = EthChainInterface()
+
+
+    def process_common(self, config):
+        super(ChaindEthSettings, self).process_common(config)
+        rpc_provider = config.get('RPC_PROVIDER')
+        if rpc_provider == None:
+            rpc_provider = 'http://localhost:8545'
+        self.o['RPC'] = EthHTTPConnection(url=rpc_provider, chain_spec=self.o['CHAIN_SPEC'])

chaind/eth/token/base.py

@@ -9,7 +9,7 @@ logg = logging.getLogger(__name__)
 
 class BaseTokenResolver:
 
-    def __init__(self, chain_spec, sender, signer, gas_oracle, nonce_oracle):
+    def __init__(self, chain_spec, sender, signer, gas_oracle, nonce_oracle, advance_nonce=False):
         self.chain_spec = chain_spec
         self.chain_id = chain_spec.chain_id()
         self.signer = signer
@@ -19,6 +19,10 @@ class BaseTokenResolver:
         self.factory = None
         self.gas_limit_start = None
         self.gas_price_start = None
+        if advance_nonce:
+            self.nonce_getter = self.nonce_oracle.next_nonce
+        else:
+            self.nonce_getter = self.nonce_oracle.get_nonce
 
     
     def reset(self):
@@ -28,7 +32,7 @@ class BaseTokenResolver:
 
 
     def get_values(self, gas_value, value, executable_address=None):
-        nonce = self.nonce_oracle.next_nonce()
+        nonce = self.nonce_getter()
 
         if executable_address == None:
             return (value, 0, nonce)

chaind/eth/token/gas.py

@@ -9,7 +9,7 @@ from chaind.eth.token import BaseTokenResolver
 class GasTokenResolver(BaseTokenResolver):
 
     def __init__(self, chain_spec, sender, signer, gas_oracle, nonce_oracle):
-        super(GasTokenResolver, self).__init__(chain_spec, sender, signer, gas_oracle, nonce_oracle)
+        super(GasTokenResolver, self).__init__(chain_spec, sender, signer, gas_oracle, nonce_oracle, advance_nonce=True)
         self.factory = Gas(self.chain_spec, signer=self.signer, gas_oracle=self.gas_oracle, nonce_oracle=self.nonce_oracle)
 
 

requirements.txt

@@ -1,6 +1,6 @@
-chaind~=0.1.0
+chaind~=0.2.0
 hexathon~=0.1.5
-chainlib-eth~=0.1.0
+chainlib-eth~=0.1.1
 pyxdg~=0.27
 shep~=0.2.3
 funga-eth~=0.6.0

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = chaind-eth
-version = 0.1.0
+version = 0.2.0
 description = Queue server for ethereum
 author = Louis Holbrook
 author_email = dev@holbrook.no
@@ -31,10 +31,11 @@ packages =
 	chaind.eth 
 	chaind.eth.runnable
 	chaind.eth.cli
+	chaind.eth.token
 
 [options.entry_points]
 console_scripts =
-	chaind-eth-tasker = chaind.eth.runnable.tasker:main
+	chaind-eth-queuer = chaind.eth.runnable.queuer:main
 	chaind-eth-syncer = chaind.eth.runnable.syncer:main
 	chaind-eth-send = chaind.eth.runnable.send:main
 	#chaind-eth-resend = chaind_eth.runnable.resend:main

setup.py

@@ -27,7 +27,7 @@ while True:
     l = f.readline()
     if l == '':
         break
-    test_requirements.append(l.rstrip())
+    erc20_requirements.append(l.rstrip())
 f.close()
 
 

systemd/chaind-eth-queue@.service

@@ -1,7 +1,7 @@
 [Unit]
 Description=Chainqueue transaction dispatch interface
-Requires=chaind-eth-sync@.service
-After=chaind-eth-sync@.service
+#Requires=chaind-eth-sync@.service
+#After=chaind-eth-sync@.service
 
 [Service]
 Environment="SESSION_ID=%i"