Initial commit; receive all eth code from chainlib package

.gitignore

@@ -0,0 +1,6 @@
+__pycache__
+gmon.out
+*.pyc
+dist/
+build/
+*.egg-info

CHANGELOG

@@ -0,0 +1,2 @@
+- 0.0.5-pending
+	* Receive all ethereum components from chainlib package

LICENSE.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

MANIFEST.in

@@ -0,0 +1 @@
+include *requirements.txt LICENSE

README.md

@@ -0,0 +1,5 @@
+# chainlib-eth
+
+Ethereum implementation of the chainlib blockchain interface tooling
+
+See https://gitlab.com/chaintool/chainlib for more information

chainlib/eth/address.py

@@ -0,0 +1,13 @@
+# 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

chainlib/eth/block.py

@@ -0,0 +1,79 @@
+# third-party imports
+from chainlib.jsonrpc import JSONRPCRequest
+from chainlib.eth.tx import Tx
+from hexathon import (
+        add_0x,
+        strip_0x,
+        even,
+        )
+
+
+def block_latest(id_generator=None):
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_blockNumber'
+    return j.finalize(o)
+
+
+def block_by_hash(hsh, include_tx=True, id_generator=None):
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_getBlockByHash'
+    o['params'].append(hsh)
+    o['params'].append(include_tx)
+    return j.finalize(o)
+
+
+def block_by_number(n, include_tx=True, id_generator=None):
+    nhx = add_0x(even(hex(n)[2:]))
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_getBlockByNumber'
+    o['params'].append(nhx)
+    o['params'].append(include_tx)
+    return j.finalize(o)
+
+
+def transaction_count(block_hash, id_generator=None):
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_getBlockTransactionCountByHash'
+    o['params'].append(block_hash)
+    return j.finalize(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))
+
+
+    @staticmethod
+    def from_src(src):
+        return Block(src)

chainlib/eth/chain.py

@@ -0,0 +1,8 @@
+from chainlib.jsonrpc import JSONRPCRequest
+
+
+def network_id(id_generator=None):
+    j = JSONRPCRequest(id_generator=id_generator)
+    o = j.template()
+    o['method'] = 'net_version'
+    return j.finalize(o)

chainlib/eth/connection.py

@@ -0,0 +1,140 @@
+# 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 (
+        JSONRPCRequest,
+        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, id_generator=None):
+        t = datetime.datetime.utcnow()
+        i = 0
+        while True:
+            j = JSONRPCRequest(id_generator)
+            o = j.template()
+            o['method'] ='eth_getTransactionReceipt'
+            o['params'].append(add_0x(tx_hash_hex))
+            o = j.finalize(o)
+            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
+
+
+    def check_rpc(self, id_generator=None):
+        j = JSONRPCRequest(id_generator)
+        req = j.template()
+        req['method'] = 'net_version'
+        req = j.finalize(req)
+        r = self.do(req)
+ 
+
+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')

chainlib/eth/constant.py

@@ -0,0 +1,5 @@
+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)

chainlib/eth/contract.py

@@ -0,0 +1,328 @@
+# 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 JSONRPCRequest
+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 ABIContract:
+
+    def __init__(self):
+        self.types = []
+        self.contents = []
+
+
+class ABIMethodEncoder(ABIContract):
+
+    def __init__(self):
+        super(ABIMethodEncoder, self).__init__()
+        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 get_method(self):
+        if self.method_name == None:
+            return ''
+        return '{}({})'.format(self.method_name, ','.join(self.method_contents))
+
+
+    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()))
+
+
+
+class ABIContractDecoder:
+
+    
+    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 = []
+        logg.debug('contents {}'.format(self.contents))
+        for i in range(len(self.types)):
+            m = getattr(self, self.types[i])
+            s = self.contents[i]
+            logg.debug('{} {} {} {} {}'.format(i, m, self.types[i], self.contents[i], s))
+            r.append(m(s.hex()))
+        return r
+
+
+    def get(self):
+        return self.decode()
+
+
+    def __str__(self):
+        return self.decode()
+
+
+class ABIContractLogDecoder(ABIMethodEncoder, ABIContractDecoder):
+    
+    def __init__(self):
+        super(ABIContractLogDecoder, self).__init__()
+        self.method_name = None
+        self.indexed_content = []
+
+
+    def topic(self, event):
+        self.method(event)
+
+
+    def get_method_signature(self):
+        s = self.get_method()
+        return keccak256_string_to_hex(s)
+
+
+    def typ(self, v):
+        super(ABIContractLogDecoder, self).typ(v)
+        self.types.append(v.value)
+
+
+    def apply(self, topics, data):
+        t = self.get_method_signature()
+        if topics[0] != t:
+            raise ValueError('topic mismatch')
+        for i in range(len(topics) - 1):
+            self.contents.append(topics[i+1])
+        self.contents += data
+              
+
+class ABIContractEncoder(ABIMethodEncoder):
+
+    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_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, id_generator=None):
+    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)
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_getCode'
+    o['params'].append(address)
+    o['params'].append(block_height)
+    return j.finalize(o)

chainlib/eth/error.py

@@ -0,0 +1,23 @@
+# 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))

chainlib/eth/gas.py

@@ -0,0 +1,149 @@
+# 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 JSONRPCRequest
+from chainlib.eth.tx import (
+        TxFactory,
+        TxFormat,
+        raw,
+        )
+from chainlib.eth.constant import (
+        MINIMUM_FEE_UNITS,
+    )
+
+logg = logging.getLogger(__name__)
+
+
+def price(id_generator=None):
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_gasPrice'
+    return j.finalize(o)
+
+
+def balance(address, id_generator=None):
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_getBalance'
+    o['params'].append(address)
+    o['params'].append('latest')
+    return j.finalize(o)
+
+
+def parse_balance(balance):
+    try:
+        r = int(balance, 10)
+    except ValueError:
+        r = int(balance, 16)
+    return r
+
+
+class Gas(TxFactory):
+
+    def create(self, sender_address, recipient_address, value, tx_format=TxFormat.JSONRPC, id_generator=None):
+        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, id_generator=id_generator)
+        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, id_generator=None):
+        self.conn = conn
+        self.code_callback = code_callback
+        self.min_price = min_price
+        self.id_generator = id_generator
+
+
+    def get_gas(self, code=None):
+        gas_price = 0
+        if self.conn != None:
+            o = price(id_generator=self.id_generator)
+            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, id_generator=None):
+        super(RPCPureGasOracle, self).__init__(conn, code_callback=code_callback, min_price=0, id_generator=id_generator)
+
+
+class OverrideGasOracle(RPCGasOracle):
+
+    def __init__(self, price=None, limit=None, conn=None, code_callback=None, id_generator=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, id_generator=id_generator)
+        
+
+    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

chainlib/eth/jsonrpc.py

@@ -0,0 +1,16 @@
+# 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.

chainlib/eth/log.py

@@ -0,0 +1,24 @@
+# external imports
+import sha3
+
+
+class LogBloom:
+
+    def __init__(self):
+        self.content = bytearray(256)
+
+
+    def add(self, element):
+        if not isinstance(element, bytes):
+            raise ValueError('element must be bytes')
+        h = sha3.keccak_256()
+        h.update(element)
+        z = h.digest()
+
+        for j in range(3):
+            c = j * 2
+            v = int.from_bytes(z[c:c+2], byteorder='big')
+            v &= 0x07ff
+            m = 255 - int(v / 8)
+            n = v % 8
+            self.content[m] |= (1 << n)

chainlib/eth/nonce.py

@@ -0,0 +1,63 @@
+# third-party imports
+from hexathon import (
+        add_0x,
+        strip_0x,
+        )
+
+# local imports
+from chainlib.jsonrpc import JSONRPCRequest
+
+
+def nonce(address, id_generator=None):
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_getTransactionCount'
+    o['params'].append(address)
+    o['params'].append('pending')
+    return j.finalize(o)
+
+
+class NonceOracle:
+
+    def __init__(self, address, id_generator=None):
+        self.address = address
+        self.id_generator = id_generator
+        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, id_generator=None):
+        self.conn = conn
+        super(RPCNonceOracle, self).__init__(address, id_generator=id_generator)
+
+
+    def get_nonce(self):
+        o = nonce(self.address, id_generator=self.id_generator)
+        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

chainlib/eth/pytest/__init__.py

@@ -0,0 +1,3 @@
+from .fixtures_ethtester import *
+from .fixtures_chain import *
+from .fixtures_signer import *

chainlib/eth/pytest/fixtures_chain.py

@@ -0,0 +1,17 @@
+# 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,
+            }

chainlib/eth/pytest/fixtures_ethtester.py

@@ -0,0 +1,105 @@
+# 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

chainlib/eth/pytest/fixtures_signer.py

@@ -0,0 +1,18 @@
+# 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],
+        }

chainlib/eth/runnable/balance.py

@@ -0,0 +1,102 @@
+#!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_result,
+        IntSequenceGenerator,
+        )
+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_eth_provider = os.environ.get('RPC_PROVIDER')
+if default_eth_provider == None:
+    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('--seq', action='store_true', help='Use sequential rpc ids')
+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)
+
+rpc_id_generator = None
+if args.seq:
+    rpc_id_generator = IntSequenceGenerator()
+
+auth = None
+if os.environ.get('RPC_AUTHENTICATION') == 'basic':
+    from chainlib.auth import BasicAuth
+    auth = BasicAuth(os.environ['RPC_USERNAME'], os.environ['RPC_PASSWORD'])
+conn = EthHTTPConnection(args.p, auth=auth)
+
+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, id_generator=rpc_id_generator)
+    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()

chainlib/eth/runnable/checksum.py

@@ -0,0 +1,33 @@
+# standard imports
+import sys
+import select
+
+# external imports
+from hexathon import strip_0x
+
+# local imports
+from chainlib.eth.address import to_checksum_address
+
+v = None
+if len(sys.argv) > 1:
+    v = sys.argv[1]
+else:
+    h = select.select([sys.stdin], [], [], 0)
+    if len(h[0]) > 0:
+        v = h[0][0].read()
+        v = v.rstrip()
+
+if v == None:
+    sys.stderr.write('input missing\n')
+    sys.exit(1)
+
+def main():
+    try:
+        print(to_checksum_address(strip_0x(v)))
+    except ValueError as e:
+        sys.stderr.write('invalid input: {}\n'.format(e))
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

chainlib/eth/runnable/count.py

@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# standard imports
+import sys
+import os
+import json
+import argparse
+import logging
+import select
+
+# 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 chainlib.jsonrpc import IntSequenceGenerator
+from crypto_dev_signer.keystore.dict import DictKeystore
+from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer
+from hexathon import add_0x
+
+logging.basicConfig(level=logging.WARNING)
+logg = logging.getLogger()
+
+default_eth_provider = os.environ.get('RPC_PROVIDER')
+if default_eth_provider == None:
+    default_eth_provider = os.environ.get('ETH_PROVIDER', 'http://localhost:8545')
+
+def stdin_arg():
+    h = select.select([sys.stdin], [], [], 0)
+    if len(h[0]) > 0:
+        v = h[0][0].read()
+        return v.rstrip()
+    return None
+
+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('-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('--seq', action='store_true', help='Use sequential rpc ids')
+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', nargs='?', type=str, default=stdin_arg(), help='Ethereum address of recipient')
+args = argparser.parse_args()
+
+if args.address == None:
+    argparser.error('need first positional argument or value from stdin')
+
+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_id_generator = None
+if args.seq:
+    rpc_id_generator = IntSequenceGenerator()
+
+auth = None
+if os.environ.get('RPC_AUTHENTICATION') == 'basic':
+    from chainlib.auth import BasicAuth
+    auth = BasicAuth(os.environ['RPC_USERNAME'], os.environ['RPC_PASSWORD'])
+rpc = EthHTTPConnection(args.p, auth=auth)
+
+def main():
+    recipient = to_checksum(args.address)
+    if not args.u and recipient != add_0x(args.address):
+        raise ValueError('invalid checksum address')
+
+    o = count(recipient, id_generator=rpc_id_generator)
+    r = rpc.do(o)
+    count_result = None
+    try:
+        count_result = int(r, 16)
+    except ValueError:
+        count_result = int(r, 10)
+    print(count_result)
+
+
+if __name__ == '__main__':
+    main()

chainlib/eth/runnable/decode.py

@@ -0,0 +1,65 @@
+#!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
+import select
+
+# external 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()
+
+def stdin_arg(t=0):
+    h = select.select([sys.stdin], [], [], t)
+    if len(h[0]) > 0:
+        v = h[0][0].read()
+        return v.rstrip()
+    return None
+
+argparser = argparse.ArgumentParser()
+argparser.add_argument('-i', '--chain-id', dest='i', default='evm:ethereum:1', type=str, help='Numeric network id')
+argparser.add_argument('-v', action='store_true', help='Be verbose')
+argparser.add_argument('-vv', action='store_true', help='Be more verbose')
+argparser.add_argument('tx', type=str, nargs='?', default=stdin_arg(), help='hex-encoded signed raw transaction')
+args = argparser.parse_args()
+
+if args.vv:
+    logg.setLevel(logging.DEBUG)
+elif args.v:
+    logg.setLevel(logging.INFO)
+
+argp = args.tx
+logg.debug('txxxx {}'.format(args.tx))
+if argp == None:
+    argp = stdin_arg(t=3)
+    if argp == None:
+        argparser.error('need first positional argument or value from stdin')
+
+chain_spec = ChainSpec.from_chain_str(args.i)
+
+
+def main():
+    tx_raw = argp
+    decode_for_puny_humans(tx_raw, chain_spec, sys.stdout)
+
+if __name__ == '__main__':
+    main()

chainlib/eth/runnable/gas.py

@@ -0,0 +1,180 @@
+#!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 (
+        JSONRPCRequest,
+        IntSequenceGenerator,
+        )
+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('RPC_PROVIDER')
+if default_eth_provider == None:
+    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('-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('--seq', action='store_true', help='Use sequential rpc ids')
+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)
+
+rpc_id_generator = None
+if args.seq:
+    rpc_id_generator = IntSequenceGenerator()
+
+auth = None
+if os.environ.get('RPC_AUTHENTICATION') == 'basic':
+    from chainlib.auth import BasicAuth
+    auth = BasicAuth(os.environ['RPC_USERNAME'], os.environ['RPC_PASSWORD'])
+conn = EthHTTPConnection(args.p, auth=auth)
+
+nonce_oracle = None
+if args.nonce != None:
+    nonce_oracle = OverrideNonceOracle(signer_address, args.nonce, id_generator=rpc_id_generator)
+else:
+    nonce_oracle = RPCNonceOracle(signer_address, conn, id_generator=rpc_id_generator)
+
+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, id_generator=rpc_id_generator)
+else:
+    gas_oracle = RPCGasOracle(conn, id_generator=rpc_id_generator)
+
+
+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, id_generator):
+    o = gas_balance(address, id_generator=id_generator)
+    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:
+            sender_balance = balance(signer_address, rpc_id_generator)
+            recipient_balance = balance(recipient, rpc_id_generator)
+            logg.debug('sender {} balance before: {}'.format(signer_address, sender_balance))
+            logg.debug('recipient {} balance before: {}'.format(recipient, recipient_balance))
+        except urllib.error.URLError:
+            pass
+     
+    (tx_hash_hex, o) = g.create(signer_address, recipient, value, id_generator=rpc_id_generator)
+
+    if send:
+        conn.do(o)
+        if block_last:
+            r = conn.wait(tx_hash_hex)
+            if logg.isEnabledFor(logging.DEBUG):
+                sender_balance = balance(signer_address, rpc_id_generator)
+                recipient_balance = balance(recipient, rpc_id_generator)
+                logg.debug('sender {} balance after: {}'.format(signer_address, sender_balance))
+                logg.debug('recipient {} balance after: {}'.format(recipient, recipient_balance))
+            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()

chainlib/eth/runnable/get.py

@@ -0,0 +1,158 @@
+#!python3
+
+"""Data retrieval 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
+import select
+
+# external imports
+from hexathon import (
+        add_0x,
+        strip_0x,
+        )
+import sha3
+
+# local imports
+from chainlib.eth.address import to_checksum
+from chainlib.jsonrpc import (
+        JSONRPCRequest,
+        jsonrpc_result,
+        IntSequenceGenerator,
+        )
+from chainlib.eth.connection import EthHTTPConnection
+from chainlib.eth.tx import (
+        Tx,
+        pack,
+        )
+from chainlib.eth.address import to_checksum_address
+from chainlib.eth.block import Block
+from chainlib.chain import ChainSpec
+from chainlib.status import Status
+from chainlib.eth.runnable.util import decode_for_puny_humans
+
+logging.basicConfig(level=logging.WARNING, format='%(asctime)s %(levelname)s %(filename)s:%(lineno)d %(message)s')
+logg = logging.getLogger()
+
+default_eth_provider = os.environ.get('RPC_PROVIDER')
+if default_eth_provider == None:
+    default_eth_provider = os.environ.get('ETH_PROVIDER', 'http://localhost:8545')
+
+def stdin_arg(t=0):
+    h = select.select([sys.stdin], [], [], t)
+    if len(h[0]) > 0:
+        v = h[0][0].read()
+        return v.rstrip()
+    return None
+
+argparser = argparse.ArgumentParser('eth-get', description='display information about an Ethereum address or transaction', epilog='address/transaction can be provided as an argument or from standard input')
+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('--rlp', action='store_true', help='Display transaction as raw rlp')
+argparser.add_argument('--seq', action='store_true', help='Use sequential rpc ids')
+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('item', nargs='?', default=stdin_arg(), 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)
+
+argp = args.item
+if argp == None:
+    argp = stdin_arg(None)
+    if argsp == None:
+        argparser.error('need first positional argument or value from stdin')
+
+rpc_id_generator = None
+if args.seq:
+    rpc_id_generator = IntSequenceGenerator()
+
+auth = None
+if os.environ.get('RPC_AUTHENTICATION') == 'basic':
+    from chainlib.auth import BasicAuth
+    auth = BasicAuth(os.environ['RPC_USERNAME'], os.environ['RPC_PASSWORD'])
+conn = EthHTTPConnection(args.p, auth=auth)
+
+chain_spec = ChainSpec.from_chain_str(args.i)
+
+item = add_0x(args.item)
+as_rlp = bool(args.rlp)
+
+
+def get_transaction(conn, tx_hash, id_generator):
+    j = JSONRPCRequest(id_generator=id_generator)
+    o = j.template()
+    o['method'] = 'eth_getTransactionByHash'
+    o['params'].append(tx_hash)
+    o = j.finalize(o)
+    tx_src = conn.do(o)
+    if tx_src == None:
+        logg.error('Transaction {} not found'.format(tx_hash))
+        sys.exit(1)
+
+    if as_rlp:
+        tx_src = Tx.src_normalize(tx_src)
+        return pack(tx_src, chain_spec).hex()
+
+    tx = None
+    status = -1
+    rcpt = None
+
+    o = j.template()
+    o['method'] = 'eth_getTransactionReceipt'
+    o['params'].append(tx_hash)
+    o = j.finalize(o)
+    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)
+    tx.generate_wire(chain_spec)
+    return tx
+
+
+def get_address(conn, address, id_generator):
+    j = JSONRPCRequest(id_generator=id_generator)
+    o = j.template()
+    o['method'] = 'eth_getCode'
+    o['params'].append(address)
+    o['params'].append('latest')
+    o = j.finalize(o)
+    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, rpc_id_generator).to_human()
+    elif args.u or to_checksum_address(item):
+        r = get_address(conn, item, rpc_id_generator)
+    print(r)
+
+
+if __name__ == '__main__':
+    main()

chainlib/eth/runnable/info.py

@@ -0,0 +1,170 @@
+#!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.eth.chain import network_id
+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.jsonrpc import (
+        IntSequenceGenerator,
+        )
+from chainlib.chain import ChainSpec
+
+BLOCK_SAMPLES = 10
+
+logging.basicConfig(level=logging.WARNING)
+logg = logging.getLogger()
+
+default_eth_provider = os.environ.get('RPC_PROVIDER')
+if default_eth_provider == None:
+    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('--seq', action='store_true', help='Use sequential rpc ids')
+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']))
+
+rpc_id_generator = None
+if args.seq:
+    rpc_id_generator = IntSequenceGenerator()
+
+auth = None
+if os.environ.get('RPC_AUTHENTICATION') == 'basic':
+    from chainlib.auth import BasicAuth
+    auth = BasicAuth(os.environ['RPC_USERNAME'], os.environ['RPC_PASSWORD'])
+conn = EthHTTPConnection(args.p, auth=auth)
+
+gas_oracle = OverrideGasOracle(conn)
+
+token_symbol = 'eth'
+
+chain_spec = ChainSpec.from_chain_str(args.i)
+
+human = args.human
+
+longmode = args.l
+
+def main():
+    o = network_id(id_generator=rpc_id_generator)
+    r = conn.do(o)
+    #if human:
+    #    n = format(n, ',')
+    sys.stdout.write('Network id: {}\n'.format(r))
+
+    o = block_latest(id_generator=rpc_id_generator)
+    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, id_generator=rpc_id_generator)
+    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, id_generator=rpc_id_generator)
+            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(id_generator=rpc_id_generator)
+    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()

chainlib/eth/runnable/raw.py

@@ -0,0 +1,189 @@
+#!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 (
+        JSONRPCRequest,
+        IntSequenceGenerator,
+        )
+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('RPC_PROVIDER')
+if default_eth_provider == None:
+    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('-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('--seq', action='store_true', help='Use sequential rpc ids')
+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)
+
+rpc_id_generator = None
+if args.seq:
+    rpc_id_generator = IntSequenceGenerator()
+
+auth = None
+if os.environ.get('RPC_AUTHENTICATION') == 'basic':
+    from chainlib.auth import BasicAuth
+    auth = BasicAuth(os.environ['RPC_USERNAME'], os.environ['RPC_PASSWORD'])
+conn = EthHTTPConnection(args.p, auth=auth)
+
+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, id_generator=rpc_id_generator)
+    else:
+        gas_oracle = RPCGasOracle(conn, id_generator=rpc_id_generator)
+
+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:
+        j = JSONRPCRequest(id_generator=rpc_id_generator)
+        o = j.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')
+        o = j.finalize(o)
+        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, id_generator=rpc_id_generator)
+   
+        if send:
+            r = conn.do(o)
+            print(r)
+        else:
+            print(o)
+            print(tx_hash_hex)
+
+    else:
+        o = raw(args.data, id_generator=rpc_id_generator)
+        if send:
+            r = conn.do(o)
+            print(r)
+        else:
+            print(o)
+
+
+if __name__ == '__main__':
+    main()

chainlib/eth/runnable/subscribe.py

@@ -0,0 +1,21 @@
+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()

chainlib/eth/runnable/util.py

@@ -0,0 +1,31 @@
+# local imports
+from chainlib.eth.tx import unpack
+from hexathon import (
+        strip_0x,
+        add_0x,
+        )
+
+def decode_out(tx, writer, skip_keys=[]):
+    for k in tx.keys():
+        if k in skip_keys:
+            continue
+        x = None
+        if k == 'value':
+            x = '{:.18f} eth'.format(tx[k] / (10**18))
+        elif k == 'gasPrice':
+            x = '{} gwei'.format(int(tx[k] / (10**9)))
+        elif k == 'value':
+            k = 'gas-value'
+        if x != None:
+            writer.write('{}: {} ({})\n'.format(k, tx[k], x))
+        else:
+            writer.write('{}: {}\n'.format(k, tx[k]))
+
+
+def decode_for_puny_humans(tx_raw, chain_spec, writer, skip_keys=[]):
+    tx_raw = strip_0x(tx_raw)
+    tx_raw_bytes = bytes.fromhex(tx_raw)
+    tx = unpack(tx_raw_bytes, chain_spec)
+    decode_out(tx, writer, skip_keys=skip_keys)
+    writer.write('src: {}\n'.format(add_0x(tx_raw)))
+

chainlib/eth/sign.py

@@ -0,0 +1,26 @@
+# local imports
+from chainlib.jsonrpc import JSONRPCRequest
+
+
+def new_account(passphrase='', id_generator=None):
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'personal_newAccount'
+    o['params'] = [passphrase]
+    return j.finalize(o)
+
+
+def sign_transaction(payload, id_generator=None):
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_signTransaction'
+    o['params'] = [payload]
+    return j.finalize(o)
+
+
+def sign_message(address, payload, id_generator=None):
+    j = JSONRPCRequest(id_generator)
+    o = j.template()
+    o['method'] = 'eth_sign'
+    o['params'] = [address, payload]
+    return j.finalize(o)

chainlib/eth/tx.py

@@ -0,0 +1,520 @@
+# 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 crypto_dev_signer.eth.encoding import chain_id_to_v
+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 JSONRPCRequest
+
+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, id_generator=None):
+    j = JSONRPCRequest(id_generator=id_generator)
+    o = j.template()
+    o['method'] = 'eth_getTransactionCount'
+    o['params'].append(address)
+    if confirmed:
+        o['params'].append('latest')
+    else:
+        o['params'].append('pending')
+    return j.finalize(o)
+
+count_pending = count
+
+def count_confirmed(address):
+    return count(address, True)
+
+
+def pack(tx_src, chain_spec):
+    if isinstance(tx_src, Tx):
+        tx_src = tx_src.as_dict()
+    tx_src = Tx.src_normalize(tx_src)
+    tx = EIP155Transaction(tx_src, tx_src['nonce'], chain_spec.chain_id())
+
+    signature = bytearray(65)
+    cursor = 0
+    for a in [
+            tx_src['r'],
+            tx_src['s'],
+            ]:
+        for b in bytes.fromhex(strip_0x(a)):
+            signature[cursor] = b
+            cursor += 1
+
+    #signature[cursor] = chainv_to_v(chain_spec.chain_id(), tx_src['v'])
+    tx.apply_signature(chain_spec.chain_id(), signature, v=tx_src['v'])
+    logg.debug('tx {}'.format(tx.serialize()))
+    return tx.rlp_serialize()
+
+
+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]
+    logg.debug('vb {}'.format(vb))
+    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': v,
+        'recovery_byte': vb,
+        '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, id_generator=None):
+    j = JSONRPCRequest(id_generator=id_generator)
+    o = j.template()
+    o['method'] = 'eth_getTransactionByHash'
+    o['params'].append(add_0x(hsh))
+    return j.finalize(o)
+
+
+def transaction_by_block(hsh, idx, id_generator=None):
+    j = JSONRPCRequest(id_generator=id_generator)
+    o = j.template()
+    o['method'] = 'eth_getTransactionByBlockHashAndIndex'
+    o['params'].append(add_0x(hsh))
+    o['params'].append(hex(idx))
+    return j.finalize(o)
+
+
+def receipt(hsh, id_generator=None):
+    j = JSONRPCRequest(id_generator=id_generator)
+    o = j.template()
+    o['method'] = 'eth_getTransactionReceipt'
+    o['params'].append(add_0x(hsh))
+    return j.finalize(o)
+
+
+def raw(tx_raw_hex, id_generator=None):
+    j = JSONRPCRequest(id_generator=id_generator)
+    o = j.template()
+    o['method'] = 'eth_sendRawTransaction'
+    o['params'].append(add_0x(tx_raw_hex))
+    return j.finalize(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, id_generator=None):
+        (tx_hash_hex, tx_raw_hex) = self.build_raw(tx) 
+        o = raw(tx_raw_hex, id_generator=id_generator)
+        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, id_generator=None):
+        if tx_format == TxFormat.JSONRPC:
+            return self.build(tx, id_generator=id_generator)
+        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, id_generator=None):
+        j = JSONRPCRequest(id_generator)
+        o = j.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')
+        o = j.finalize(o)
+        return o
+
+
+class Tx:
+
+    # TODO: force tx type schema parser (whether expect hex or int etc)
+    def __init__(self, src, block=None, rcpt=None):
+        self.tx_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)
+                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.status = Status.PENDING
+        self.logs = None
+
+        if rcpt != None:
+            self.apply_receipt(rcpt)
+
+        self.v = src.get('v')
+        self.r = src.get('r')
+        self.s = src.get('s')
+
+        self.wire = None
+ 
+
+    def src(self):
+        return self.tx_src
+   
+
+    @classmethod
+    def src_normalize(self, src):
+        src = snake_and_camel(src)
+
+        if isinstance(src.get('v'), str):
+            try:
+                src['v'] = int(src['v'])
+            except ValueError:
+                src['v'] = int(src['v'], 16)
+        return src
+
+
+    def as_dict(self):
+        return self.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 apply_block(self, block):
+        #block_src = self.src_normalize(block_src)
+        self.block = block
+
+
+    def generate_wire(self, chain_spec):
+        b = pack(self.src(), chain_spec)
+        self.wire = add_0x(b.hex())
+
+
+    @staticmethod
+    def from_src(src, block=None):
+        return Tx(src, block=block)
+
+
+    def __str__(self):
+        if self.block != None:
+            return 'tx {} status {} block {} index {}'.format(add_0x(self.hash), self.status.name, self.block.number, self.index)
+        else:
+            return 'tx {} status {}'.format(add_0x(self.hash), self.status.name)
+
+
+    def __repr__(self):
+        return self.__str__()
+
+
+    def to_human(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,
+        )
+
+        if self.wire != None:
+            s += """src {}
+""".format(
+        self.wire,
+        )
+
+        return s
+

chainlib/eth/unittest/base.py

@@ -0,0 +1,218 @@
+# 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

chainlib/eth/unittest/ethtester.py

@@ -0,0 +1,80 @@
+# 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

example/call_balance.py

@@ -0,0 +1,25 @@
+# standard imports
+import os
+
+# external imports
+from hexathon import strip_0x, add_0x
+
+# local imports
+from chainlib.eth.gas import balance, parse_balance
+from chainlib.eth.connection import EthHTTPConnection
+
+
+# create a random address to check
+address_bytes = os.urandom(20)
+address = add_0x(address_bytes.hex())
+
+# connect to rpc node and send request for balance 
+rpc_provider = os.environ.get('RPC_PROVIDER', 'http://localhost:8545')
+rpc = EthHTTPConnection(rpc_provider)
+o = balance(address)
+r = rpc.do(o)
+
+clean_address = strip_0x(address)
+clean_balance = parse_balance(r)
+    
+print('address {} has balance {}'.format(clean_address, clean_balance))

example/contract_transaction.py

@@ -0,0 +1,75 @@
+# standard imports
+import os
+
+# external imports
+from crypto_dev_signer.keystore.dict import DictKeystore
+from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer
+from hexathon import (
+        add_0x,
+        strip_0x,
+        )
+
+# local imports
+from chainlib.chain import ChainSpec
+from chainlib.eth.nonce import OverrideNonceOracle
+from chainlib.eth.gas import OverrideGasOracle
+from chainlib.eth.tx import (
+        TxFactory,
+        TxFormat,
+        unpack,
+        pack,
+        raw,
+        )
+from chainlib.eth.contract import (
+        ABIContractEncoder,
+        ABIContractDecoder,
+        ABIContractType,
+        )
+
+# eth transactions need an explicit chain parameter as part of their signature
+chain_spec = ChainSpec.from_chain_str('evm:ethereum:1')
+
+# create keystore and signer
+keystore = DictKeystore()
+signer = EIP155Signer(keystore)
+sender_address = keystore.new()
+recipient_address = keystore.new()
+
+# explicitly set nonce and gas parameters on this transaction
+nonce_oracle = OverrideNonceOracle(sender_address, 0)
+gas_oracle = OverrideGasOracle(price=1000000000, limit=21000)
+
+# encode the contract parameters
+enc = ABIContractEncoder()
+enc.method('fooBar')
+enc.typ(ABIContractType.ADDRESS)
+enc.typ(ABIContractType.UINT256)
+enc.address(recipient_address)
+enc.uint256(42)
+data = enc.get()
+
+# create a new transaction, but output in raw rlp format 
+tx_factory = TxFactory(chain_spec, signer=signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle)
+tx = tx_factory.template(sender_address, recipient_address, use_nonce=True)
+tx = tx_factory.set_code(tx, data)
+(tx_hash, tx_signed_raw) = tx_factory.finalize(tx, tx_format=TxFormat.RLP_SIGNED)
+
+print('contract transaction: {}'.format(tx))
+
+# retrieve the input data from the transaction
+tx_src = unpack(bytes.fromhex(strip_0x(tx_signed_raw)), chain_spec)
+data_recovered = strip_0x(tx_src['data'])
+
+# decode the contract parameters 
+dec = ABIContractDecoder()
+dec.typ(ABIContractType.ADDRESS)
+dec.typ(ABIContractType.UINT256)
+# (yes, this interface needs to be vastly improved, it should take the whole buffer and advance with cursor itself)
+cursor = 8 # the method signature is 8 characters long. input data to the solidity function starts after that
+dec.val(data_recovered[cursor:cursor+64])
+cursor += 64
+dec.val(data_recovered[cursor:cursor+64])
+r = dec.decode()
+
+print('contract param 1 {}'.format(r[0]))
+print('contract param 2 {}'.format(r[1]))

example/jsonrpc.py

@@ -0,0 +1,29 @@
+# standard imports
+import os
+import sys
+
+# local imports
+from chainlib.jsonrpc import jsonrpc_template
+from chainlib.eth.connection import EthHTTPConnection
+
+# set up node connection and execute rpc call
+rpc_provider = os.environ.get('RPC_PROVIDER', 'http://localhost:8545')
+rpc = EthHTTPConnection(rpc_provider)
+
+# check the connection
+if not rpc.check():
+    sys.stderr.write('node {} not usable\n'.format(rpc_provider))
+    sys.exit(1)
+
+# build and send rpc call
+o = jsonrpc_template()
+o['method'] = 'eth_blockNumber'
+r = rpc.do(o)
+
+# interpret result for humans
+try:
+    block_number = int(r, 10)
+except ValueError:
+    block_number = int(r, 16)
+
+print('block number {}'.format(block_number))

example/online_transaction.py

@@ -0,0 +1,57 @@
+# standard imports
+import sys
+import os
+
+# external imports
+from crypto_dev_signer.keystore.dict import DictKeystore
+from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer
+from hexathon import (
+        add_0x,
+        strip_0x,
+        )
+
+# local imports
+from chainlib.chain import ChainSpec
+from chainlib.eth.connection import EthHTTPConnection
+from chainlib.eth.nonce import RPCNonceOracle
+from chainlib.eth.gas import RPCGasOracle
+from chainlib.eth.tx import (
+        TxFactory,
+        TxFormat,
+        )
+from chainlib.error import JSONRPCException
+
+# eth transactions need an explicit chain parameter as part of their signature
+chain_spec = ChainSpec.from_chain_str('evm:ethereum:1')
+
+# create keystore and signer
+keystore = DictKeystore()
+signer = EIP155Signer(keystore)
+sender_address = keystore.new()
+recipient_address = keystore.new()
+
+# set up node connection
+rpc_provider = os.environ.get('RPC_PROVIDER', 'http://localhost:8545')
+rpc = EthHTTPConnection(rpc_provider)
+
+# check the connection
+if not rpc.check():
+    sys.stderr.write('node {} not usable\n'.format(rpc_provider))
+    sys.exit(1)
+
+# nonce will now be retrieved from network
+nonce_oracle = RPCNonceOracle(sender_address, rpc)
+
+# gas price retrieved from network, and limit from callback
+def calculate_gas(code=None):
+    return 21000
+gas_oracle = RPCGasOracle(rpc, code_callback=calculate_gas)
+
+# create a new transaction
+tx_factory = TxFactory(chain_spec, signer=signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle)
+tx = tx_factory.template(sender_address, recipient_address, use_nonce=True)
+tx['value'] = 1024
+(tx_hash, tx_rpc) = tx_factory.finalize(tx)
+
+print('transaction hash: ' + tx_hash)
+print('jsonrpc payload: ' + str(tx_rpc))

example/transaction.py

@@ -0,0 +1,65 @@
+# standard imports
+import os
+
+# external imports
+from crypto_dev_signer.keystore.dict import DictKeystore
+from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer
+from hexathon import (
+        add_0x,
+        strip_0x,
+        )
+
+# local imports
+from chainlib.chain import ChainSpec
+from chainlib.eth.nonce import OverrideNonceOracle
+from chainlib.eth.gas import OverrideGasOracle
+from chainlib.eth.tx import (
+        TxFactory,
+        TxFormat,
+        unpack,
+        pack,
+        raw,
+        )
+
+# eth transactions need an explicit chain parameter as part of their signature
+chain_spec = ChainSpec.from_chain_str('evm:ethereum:1')
+
+# create keystore and signer
+keystore = DictKeystore()
+signer = EIP155Signer(keystore)
+sender_address = keystore.new()
+recipient_address = keystore.new()
+
+# explicitly set nonce and gas parameters on this transaction
+nonce_oracle = OverrideNonceOracle(sender_address, 0)
+gas_oracle = OverrideGasOracle(price=1000000000, limit=21000)
+
+# create a new transaction
+tx_factory = TxFactory(chain_spec, signer=signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle)
+tx = tx_factory.template(sender_address, recipient_address, use_nonce=True)
+tx['value'] = 1024
+(tx_hash, tx_rpc) = tx_factory.finalize(tx)
+
+print('transaction hash: ' + tx_hash)
+print('jsonrpc payload: ' + str(tx_rpc))
+
+# create a new transaction, but output in raw rlp format 
+tx = tx_factory.template(sender_address, recipient_address, use_nonce=True) # will now have increased nonce by 1
+tx['value'] = 1024
+(tx_hash, tx_signed_raw) = tx_factory.finalize(tx, tx_format=TxFormat.RLP_SIGNED) 
+print('transaction hash: ' + tx_hash)
+print('raw rlp payload: ' + tx_signed_raw)
+
+# convert tx from raw RLP 
+tx_signed_raw_bytes = bytes.fromhex(strip_0x(tx_signed_raw))
+tx_src = unpack(tx_signed_raw_bytes, chain_spec)
+print('tx parsed from rlp payload: ' + str(tx_src))
+
+# .. and back
+tx_signed_raw_bytes_recovered = pack(tx_src, chain_spec)
+tx_signed_raw_recovered = add_0x(tx_signed_raw_bytes_recovered.hex())
+print('raw rlp payload re-parsed: ' + tx_signed_raw_recovered)
+
+# create a raw send jsonrpc payload from the raw RLP
+o = raw(tx_signed_raw_recovered)
+print('jsonrpc payload: ' + str(o))

example/tx_object.py

@@ -0,0 +1,51 @@
+# standard imports
+import os
+
+# external imports
+from crypto_dev_signer.keystore.dict import DictKeystore
+from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer
+from crypto_dev_signer.eth.transaction import EIP155Transaction
+from hexathon import (
+        add_0x,
+        strip_0x,
+        )
+
+# local imports
+from chainlib.chain import ChainSpec
+from chainlib.eth.tx import (
+        unpack,
+        Tx,
+        )
+
+# eth transactions need an explicit chain parameter as part of their signature
+chain_spec = ChainSpec.from_chain_str('evm:ethereum:1')
+chain_id = chain_spec.chain_id()
+
+# create keystore and signer
+keystore = DictKeystore()
+signer = EIP155Signer(keystore)
+sender_address = keystore.new()
+recipient_address = keystore.new()
+
+
+# set up a transaction dict source
+tx_src = {
+    'from': sender_address,
+    'to': recipient_address,
+    'gas': 21000,
+    'gasPrice': 1000000000,
+    'value': 1024,
+    'data': '0xdeadbeef',
+        }
+sender_nonce = 0
+tx = EIP155Transaction(tx_src, sender_nonce, chain_id)
+signature = signer.sign_transaction(tx)
+print('signature: {}'.format(signature.hex()))
+
+tx.apply_signature(chain_id, signature)
+print('tx with signature: {}'.format(tx.serialize()))
+
+tx_signed_raw_bytes = tx.rlp_serialize()
+tx_src = unpack(tx_signed_raw_bytes, chain_spec)
+tx_parsed = Tx(tx_src)
+print('parsed signed tx: {}'.format(tx_parsed.to_human()))

requirements.txt

@@ -0,0 +1,5 @@
+crypto-dev-signer~=0.4.14b6
+pysha3==1.0.2
+hexathon~=0.0.1a7
+websocket-client==0.57.0
+potaahto~=0.0.1a1

run_tests.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+set -x
+#export PYTHONPATH=${PYTHONPATH:.}
+for f in `ls tests/*.py`; do
+	python $f
+done
+set +x
+set +e

setup.cfg

@@ -0,0 +1,43 @@
+[metadata]
+name = chainlib-eth
+version = 0.0.5a1
+description = Ethereum implementation of the chainlib interface
+author = Louis Holbrook
+author_email = dev@holbrook.no
+url = https://gitlab.com/chaintools/chainlib
+keywords =
+	dlt
+	blockchain
+	cryptocurrency
+	ethereum
+classifiers =
+	Programming Language :: Python :: 3
+	Operating System :: OS Independent
+	Development Status :: 3 - Alpha
+	Environment :: Console
+	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
+packages = 
+	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

setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup
+import configparser
+import os
+
+
+requirements = []
+f = open('requirements.txt', 'r')
+while True:
+    l = f.readline()
+    if l == '':
+        break
+    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,
+    )

test_requirements.txt

@@ -0,0 +1,4 @@
+eth_tester==0.5.0b3
+py-evm==0.3.0a20
+rlp==2.0.1
+pytest==6.0.1

tests/Makefile

@@ -0,0 +1,5 @@
+SOLC = /usr/bin/solc
+
+all:
+	$(SOLC) --bin TestContract.sol --evm-version byzantium | awk 'NR>3' > TestContract.bin
+	truncate -s -1 TestContract.bin

tests/TestContract.bin

@@ -0,0 +1 @@
+608060405234801561001057600080fd5b50610260806100206000396000f3fe608060405234801561001057600080fd5b5060043610610048576000357c01000000000000000000000000000000000000000000000000000000009004806333aa24121461004d575b600080fd5b61006760048036038101906100629190610122565b61007d565b604051610074919061018b565b60405180910390f35b6000827fa8ed44a382304c8db2c9059e4de342080401fb8e9a71986396d595c869fa3792836040516100af91906101a6565b60405180910390a27f33c4ea6ccc21f1a14e9de7326edcc52c2b8a302ac875ae6b8fee2560eadd75ad836040516100e691906101c1565b60405180910390a16001905092915050565b600081359050610107816101fc565b92915050565b60008135905061011c81610213565b92915050565b6000806040838503121561013557600080fd5b60006101438582860161010d565b9250506020610154858286016100f8565b9150509250929050565b610167816101dc565b82525050565b610176816101e8565b82525050565b610185816101f2565b82525050565b60006020820190506101a0600083018461015e565b92915050565b60006020820190506101bb600083018461016d565b92915050565b60006020820190506101d6600083018461017c565b92915050565b60008115159050919050565b6000819050919050565b6000819050919050565b610205816101e8565b811461021057600080fd5b50565b61021c816101f2565b811461022757600080fd5b5056fea26469706673582212205c428504ca5a53a9250d76b287bec8ee4b13d5c7cb386a0f67cbf77ecb96a9ea64736f6c63430008040033

tests/TestContract.sol

@@ -0,0 +1,13 @@
+pragma solidity ^0.8.0;
+
+contract TestEventContract {
+
+	event TestEventOne(uint256 indexed _foo, bytes32 _bar);
+	event TestEventTwo(uint256 _foo);
+
+	function foo(uint256 _foo, bytes32 _bar) public returns (bool) {
+		emit TestEventOne(_foo, _bar);
+		emit TestEventTwo(_foo);
+		return true;
+	}
+}

tests/contract.py

@@ -0,0 +1,66 @@
+# standard imports
+import os
+
+# external iports
+from chainlib.eth.tx import (
+        TxFactory,
+        TxFormat,
+        receipt,
+        )
+from chainlib.eth.contract import (
+        ABIContractEncoder,
+        #ABIContractDecoder,
+        ABIContractType,
+        )
+from hexathon import add_0x
+
+script_dir = os.path.realpath(os.path.dirname(__file__))
+data_dir = script_dir
+
+class TestContract(TxFactory):
+
+    __abi = None
+    __bytecode = None
+
+    @staticmethod
+    def gas(code=None):
+        return 1000000
+
+
+    @staticmethod
+    def abi():
+        if TestContract.__abi == None:
+            f = open(os.path.join(data_dir, 'TestContract.json'), 'r')
+            TestContract.__abi = json.load(f)
+            f.close()
+        return TestContract.__abi
+
+
+    @staticmethod
+    def bytecode():
+        if TestContract.__bytecode == None:
+            f = open(os.path.join(data_dir, 'TestContract.bin'))
+            TestContract.__bytecode = f.read()
+            f.close()
+        return TestContract.__bytecode
+
+
+    def constructor(self, sender_address, tx_format=TxFormat.JSONRPC, id_generator=None):
+        code = TestContract.bytecode()
+        tx = self.template(sender_address, None, use_nonce=True)
+        tx = self.set_code(tx, code)
+        return self.finalize(tx, tx_format, id_generator=id_generator)
+
+
+    def foo(self, contract_address, sender_address, x, y, tx_format=TxFormat.JSONRPC, id_generator=None):
+        enc = ABIContractEncoder()
+        enc.method('foo')
+        enc.typ(ABIContractType.UINT256)
+        enc.typ(ABIContractType.BYTES32)
+        enc.uint256(x)
+        enc.bytes32(y)
+        data = add_0x(enc.get())
+        tx = self.template(sender_address, contract_address, use_nonce=True)
+        tx = self.set_code(tx, data)
+        tx = self.finalize(tx, tx_format, id_generator=id_generator)
+        return tx

tests/test_abi.py

@@ -0,0 +1,29 @@
+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()

tests/test_address.py

@@ -0,0 +1,35 @@
+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()

tests/test_bloom.py

@@ -0,0 +1,120 @@
+# standard imports
+import os
+import unittest
+import logging
+
+# local imports
+from chainlib.eth.unittest.ethtester import EthTesterCase
+from chainlib.eth.nonce import RPCNonceOracle
+from chainlib.eth.gas import OverrideGasOracle
+from chainlib.eth.tx import receipt
+from chainlib.eth.block import block_by_number
+from chainlib.eth.log import LogBloom
+from hexathon import (
+        strip_0x,
+        add_0x,
+        )
+
+# test imports
+from tests.contract import TestContract
+
+script_dir = os.path.realpath(os.path.dirname(__file__))
+
+logging.basicConfig(level=logging.DEBUG)
+logg = logging.getLogger()
+
+#{'blockHash': '0xe657e31045be85cfff8c28af6b4fd6417cace7150c4ebbeb736e638313d8e66d', 'block_hash': '0xe657e31045be85cfff8c28af6b4fd6417cace7150c4ebbeb736e638313d8e66d', 'blockNumber': '0xc1ee5a', 'block_number': '0xc1ee5a', 'contractAddress': None, 'contract_address': None, 'cumulativeGasUsed': '0xbc659', 'cumulative_gas_used': '0xbc659', 'from': '0xf6025e63cee5e436a5f1486e040aeead7e97b745', 'gasUsed': '0x1dddb', 'gas_used': '0x1dddb', 'logs': [
+
+#{'address': '0x4e58ab12d2051ea2068e78e4fcee7ddee6785848', 'blockHash': '0xe657e31045be85cfff8c28af6b4fd6417cace7150c4ebbeb736e638313d8e66d', 'blockNumber': '0xc1ee5a', 'data': '0x', 'logIndex': '0xd', 'removed': False, 'topics': ['0x92e98423f8adac6e64d0608e519fd1cefb861498385c6dee70d58fc926ddc68c', '0x0000000000000000000000000000000000000000000000000000000005f6aa5a', '0x00000000000000000000000000000000000000000000000000000000000000d6', '0x000000000000000000000000f6025e63cee5e436a5f1486e040aeead7e97b745'], 'transactionHash': '0xd0f039591953d277d55f628694248cb442590fab95ac53fcfb69e9dbba7db97a', 'transactionIndex': '0xe'},
+
+#{'address': '0x4e58ab12d2051ea2068e78e4fcee7ddee6785848', 'blockHash': '0xe657e31045be85cfff8c28af6b4fd6417cace7150c4ebbeb736e638313d8e66d', 'blockNumber': '0xc1ee5a', 'data': '0x0000000000000000000000000000000000000000000000000000000060d7119f', 'logIndex': '0xe', 'removed': False, 'topics': ['0x0559884fd3a460db3073b7fc896cc77986f16e378210ded43186175bf646fc5f', '0x0000000000000000000000000000000000000000000000000000000005f6aa5a', '0x00000000000000000000000000000000000000000000000000000000000000d6'], 'transactionHash': '0xd0f039591953d277d55f628694248cb442590fab95ac53fcfb69e9dbba7db97a', 'transactionIndex': '0xe'},
+
+#{'address': '0x4e58ab12d2051ea2068e78e4fcee7ddee6785848', 'blockHash': '0xe657e31045be85cfff8c28af6b4fd6417cace7150c4ebbeb736e638313d8e66d', 'blockNumber': '0xc1ee5a', 'data': '0x', 'logIndex': '0xf', 'removed': False, 'topics': ['0xfe25c73e3b9089fac37d55c4c7efcba6f04af04cebd2fc4d6d7dbb07e1e5234f', '0x0000000000000000000000000000000000000000000000813b65aa80e5770000'], 'transactionHash': '0xd0f039591953d277d55f628694248cb442590fab95ac53fcfb69e9dbba7db97a', 'transactionIndex': '0xe'}]
+
+#, 'logsBloom': '0x0000000000000000000000000000000000000080000000000000000000c000000000000000408000000000000000000000000000000200080000000000000000100000000000000000000000000000000000000000000200000020000000000000000000000000800000400000000000400000000400000000000400100000000000000000000000000000000000000000000480000000000000000000000000000000000000000000000000008000000000080000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000002008000000000000000', 'logs_bloom': '0x0000000000000000000000000000000000000080000000000000000000c000000000000000408000000000000000000000000000000200080000000000000000100000000000000000000000000000000000000000000200000020000000000000000000000000800000400000000000400000000400000000000400100000000000000000000000000000000000000000000480000000000000000000000000000000000000000000000000008000000000080000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000002008000000000000000', 'status': '0x1', 'to': '0x4e58ab12d2051ea2068e78e4fcee7ddee6785848', 'transactionHash': '0xd0f039591953d277d55f628694248cb442590fab95ac53fcfb69e9dbba7db97a', 'transaction_hash': '0xd0f039591953d277d55f628694248cb442590fab95ac53fcfb69e9dbba7db97a', 'transactionIndex': '0xe', 'transaction_index': '0xe', 'type': '0x0'}
+
+
+class BloomTestCase(EthTesterCase):
+
+    def setUp(self):
+        super(BloomTestCase, self).setUp()
+
+        nonce_oracle = RPCNonceOracle(self.accounts[0], conn=self.rpc)
+        c = TestContract(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        (tx_hash, o) = c.constructor(self.accounts[0])
+        r = self.rpc.do(o)
+        o = receipt(tx_hash)
+        r = self.rpc.do(o)
+        self.assertEqual(r['status'], 1)
+
+        self.address = r['contract_address']
+        logg.info('deployed contract on {}'.format(self.address))
+       
+
+    def test_log_proof(self):
+        bloom = LogBloom()
+
+        address = bytes.fromhex(strip_0x('0x4e58ab12d2051ea2068e78e4fcee7ddee6785848'))
+        logs = [
+            ['0x92e98423f8adac6e64d0608e519fd1cefb861498385c6dee70d58fc926ddc68c', '0x0000000000000000000000000000000000000000000000000000000005f6aa5a', '0x00000000000000000000000000000000000000000000000000000000000000d6', '0x000000000000000000000000f6025e63cee5e436a5f1486e040aeead7e97b745'],
+            ['0x0559884fd3a460db3073b7fc896cc77986f16e378210ded43186175bf646fc5f', '0x0000000000000000000000000000000000000000000000000000000005f6aa5a', '0x00000000000000000000000000000000000000000000000000000000000000d6'],
+            ['0xfe25c73e3b9089fac37d55c4c7efcba6f04af04cebd2fc4d6d7dbb07e1e5234f', '0x0000000000000000000000000000000000000000000000813b65aa80e5770000'],
+                ]
+   
+        bloom.add(address)
+        for topics in logs:
+            topics_bytes = []
+            for topic in topics:
+                topic_bytes = bytes.fromhex(strip_0x(topic))
+                bloom.add(topic_bytes)
+
+        log_proof_hex = '0x0000000000000000000000000000000000000080000000000000000000c000000000000000408000000000000000000000000000000200080000000000000000100000000000000000000000000000000000000000000200000020000000000000000000000000800000400000000000400000000400000000000400100000000000000000000000000000000000000000000480000000000000000000000000000000000000000000000000008000000000080000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000002008000000000000000'
+        log_proof = bytes.fromhex(strip_0x(log_proof_hex))
+
+        log_proof_bitcount = 0
+        for b in log_proof:
+            for i in range(8):
+                if b & (1 << (7 - i)) > 0:
+                    log_proof_bitcount += 1
+        logg.debug('proof log has {} bits set'.format(log_proof_bitcount))
+
+        log_created_bitcount = 0
+        for b in bloom.content:
+            for i in range(8):
+                if b & (1 << (7 - i)) > 0:
+                    log_created_bitcount += 1
+        logg.debug('created log has {} bits set'.format(log_created_bitcount))
+
+        logg.debug('log_proof:\n{}'.format(log_proof_hex))
+        logg.debug('log_created:\n{}'.format(add_0x(bloom.content.hex())))
+        for i in range(len(bloom.content)):
+            chk = bloom.content[i] & log_proof[i]
+            if chk != bloom.content[i]:
+                self.fail('mismatch at {}: {} != {}'.format(i, chk, bloom.content[i]))
+
+        
+
+    @unittest.skip('pyevm tester produces bogus log blooms')
+    def test_log(self):
+        nonce_oracle = RPCNonceOracle(self.accounts[0], conn=self.rpc)
+        gas_oracle = OverrideGasOracle(limit=50000, conn=self.rpc)
+        c = TestContract(self.chain_spec, signer=self.signer, nonce_oracle=nonce_oracle)
+        b = b'\xee' * 32
+        (tx_hash, o) = c.foo(self.address, self.accounts[0], 42, b.hex())
+        r = self.rpc.do(o)
+        o = receipt(tx_hash)
+        rcpt = self.rpc.do(o)
+        self.assertEqual(rcpt['status'], 1)
+
+        bloom = LogBloom()
+        topic = rcpt['logs'][0]['topics'][0]
+        topic = bytes.fromhex(strip_0x(topic))
+        address = bytes.fromhex(strip_0x(self.address))
+        bloom.add(topic, address)
+
+        o = block_by_number(rcpt['block_number'])
+        r = self.rpc.do(o)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_event.py

@@ -0,0 +1,38 @@
+# standard imports
+import unittest
+import logging
+
+# local imports
+from chainlib.eth.unittest.ethtester import EthTesterCase
+from chainlib.eth.contract import (
+        ABIContractLogDecoder,
+        ABIContractType,
+        )
+
+logging.basicConfig(level=logging.DEBUG)
+
+
+class TestContractLog(EthTesterCase):
+
+    def test_log(self):
+        dec = ABIContractLogDecoder()
+        dec.topic('TestEventOne')
+        dec.typ(ABIContractType.UINT256)
+        dec.typ(ABIContractType.BYTES32)
+        s = dec.get_method_signature()
+        n = 42
+        topics = [
+                s,
+                n.to_bytes(32, byteorder='big'),
+                ]
+        data = [
+            (b'\xee' * 32),
+                ]
+        dec.apply(topics, data)
+        o = dec.decode()
+        self.assertEqual(o[0], 42)
+        self.assertEqual(o[1], data[0].hex())
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_nonce.py

@@ -0,0 +1,26 @@
+# 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()

tests/test_sign.py

@@ -0,0 +1,119 @@
+# 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()

tests/test_stat.py

@@ -0,0 +1,49 @@
+# 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()

tests/test_tx.py

@@ -0,0 +1,79 @@
+# standard imports
+import os
+import unittest
+import logging
+
+# 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,
+        pack,
+        raw,
+        transaction,
+        TxFormat,
+        TxFactory,
+        Tx,
+        )
+from chainlib.eth.contract import (
+        ABIContractEncoder,
+        ABIContractType,
+        )
+from chainlib.eth.address import to_checksum_address
+from hexathon import (
+        strip_0x,
+        add_0x,
+        )
+
+logging.basicConfig(level=logging.DEBUG)
+logg = logging.getLogger()
+
+
+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])
+
+
+    def test_tx_pack(self):
+        nonce_oracle = RPCNonceOracle(self.accounts[0], self.rpc)
+        gas_oracle = RPCGasOracle(self.rpc)
+
+        mock_contract = to_checksum_address(add_0x(os.urandom(20).hex()))
+
+        f = TxFactory(self.chain_spec, signer=self.rpc)
+        enc = ABIContractEncoder()
+        enc.method('fooMethod')
+        enc.typ(ABIContractType.UINT256)
+        enc.uint256(13)
+        data = enc.get()
+        tx = f.template(self.accounts[0], mock_contract, use_nonce=True)
+        tx = f.set_code(tx, data)
+        (tx_hash, tx_signed_raw_hex) = f.finalize(tx, TxFormat.RLP_SIGNED)
+        logg.debug('tx result {}'.format(tx))
+        o = raw(tx_signed_raw_hex)
+        r = self.rpc.do(o)
+        o = transaction(tx_hash)
+        tx_rpc_src = self.rpc.do(o)
+        logg.debug('rpc src {}'.format(tx_rpc_src))
+
+        tx_signed_raw_bytes = bytes.fromhex(strip_0x(tx_signed_raw_hex))
+        tx_src = unpack(tx_signed_raw_bytes, self.chain_spec)
+        txo = Tx(tx_src)
+        tx_signed_raw_bytes_recovered = pack(txo, self.chain_spec)
+        logg.debug('o {}'.format(tx_signed_raw_bytes.hex()))
+        logg.debug('r {}'.format(tx_signed_raw_bytes_recovered.hex()))
+        self.assertEqual(tx_signed_raw_bytes, tx_signed_raw_bytes_recovered)
+
+if __name__ == '__main__':
+    unittest.main()

tests/testdata/keystore/UTC--2021-01-08T17-18-44.521011372Z--eb3907ecad74a0013c259d5874ae7f22dcbcc95c

@@ -0,0 +1 @@
+{"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}