eth-monitor

Monitor and cache ethereum transactions with match filters
git clone git://git.defalsify.org/eth-monitor.git
Info | Log | Files | Refs | README | LICENSE

out.py (2121B)


      1 # standard imports
      2 import sys
      3 import logging
      4 import datetime
      5 
      6 # external imports
      7 from hexathon import (
      8         strip_0x,
      9         )
     10 
     11 # local imports
     12 from .base import RuledFilter
     13 
     14 logg = logging.getLogger(__name__)
     15 
     16 
     17 # Interface defining the signature for renderer in OutFilter
     18 # return string after local transformation
     19 def apply_interface(c, s, chain_str, conn, block, tx, **kwargs):
     20     pass
     21 
     22 
     23 class OutResult:
     24 
     25     def __init__(self):
     26         self.content = ''
     27 
     28 
     29     def set(self, v):
     30         self.content = v 
     31 
     32 
     33     def get(self):
     34         return self.content
     35 
     36 
     37     def __str__(self):
     38         return self.content
     39 
     40 
     41 class OutFilter(RuledFilter):
     42 
     43     def __init__(self, chain_spec, writer=sys.stdout, renderers=[], rules_filter=None):
     44         super(OutFilter, self).__init__(rules_filter=rules_filter)
     45         self.w = writer
     46         self.renderers = renderers
     47         self.c = 0
     48         self.chain_spec = chain_spec
     49         self.result = OutResult()
     50 
     51 
     52     def filter(self, conn, block, tx, **kwargs):
     53         r = super(OutFilter, self).filter(conn, block, tx, **kwargs)
     54         if r == True:
     55             return True
     56 
     57         for renderer in self.renderers:
     58             r = renderer.apply(self.c, self.result, self.chain_spec, conn, block, tx)
     59             if not r:
     60                 break
     61 
     62         s = str(self.result)
     63 
     64         if s == '':
     65             data = tx.payload
     66             if len(data) > 8:
     67                 data = data[:8] + '...'
     68             if len(data) > 0:
     69                 data = 'data {}'.format(data)
     70             #s = '{} {} {} {}'.format(self.c, block, tx, data)
     71             tx_count = len(block.txs)
     72             s = '{} {} block {} {} tx {}/{} {} {} {}'.format(
     73                     self.c,
     74                     datetime.datetime.fromtimestamp(block.timestamp),
     75                     block.number,
     76                     strip_0x(block.hash),
     77                     tx.index + 1,
     78                     tx_count,
     79                     strip_0x(tx.hash),
     80                     tx.status.name,
     81                     data,
     82                     )
     83 
     84         self.w.write(s + '\n')
     85         self.c += 1
     86         return False