Initial commit; receive all eth code from chainlib package
This commit is contained in:
nolash
commit
f8afc172c6
GPG Key ID:
21D2E7BB88C2A746
|
|
@ -0,0 +1,6 @@
|
|||
__pycache__
|
||||
gmon.out
|
||||
*.pyc
|
||||
dist/
|
||||
build/
|
||||
*.egg-info
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
- 0.0.5-pending
|
||||
* Receive all ethereum components from chainlib package
|
||||
|
|
@ -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>.
|
||||
|
|
@ -0,0 +1 @@
|
|||
include *requirements.txt LICENSE
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
# chainlib-eth
|
||||
|
||||
Ethereum implementation of the chainlib blockchain interface tooling
|
||||
|
||||
See https://gitlab.com/chaintool/chainlib for more information
|
||||
|
|
@ -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
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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')
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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))
|
||||
|
|
@ -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
|
||||
|
|
@ -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.
|
||||
|
|
@ -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)
|
||||
|
|
@ -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
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
from .fixtures_ethtester import *
|
||||
from .fixtures_chain import *
|
||||
from .fixtures_signer import *
|
||||
|
|
@ -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,
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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],
|
||||
}
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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)))
|
||||
|
||||
|
|
@ -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)
|
||||
|
|
@ -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
|
||||
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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))
|
||||
|
|
@ -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]))
|
||||
|
|
@ -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))
|
||||
|
|
@ -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))
|
||||
|
|
@ -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))
|
||||
|
|
@ -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()))
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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,
|
||||
)
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
eth_tester==0.5.0b3
|
||||
py-evm==0.3.0a20
|
||||
rlp==2.0.1
|
||||
pytest==6.0.1
|
||||
|
|
@ -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
|
||||
|
|
@ -0,0 +1 @@
|
|||
608060405234801561001057600080fd5b50610260806100206000396000f3fe608060405234801561001057600080fd5b5060043610610048576000357c01000000000000000000000000000000000000000000000000000000009004806333aa24121461004d575b600080fd5b61006760048036038101906100629190610122565b61007d565b604051610074919061018b565b60405180910390f35b6000827fa8ed44a382304c8db2c9059e4de342080401fb8e9a71986396d595c869fa3792836040516100af91906101a6565b60405180910390a27f33c4ea6ccc21f1a14e9de7326edcc52c2b8a302ac875ae6b8fee2560eadd75ad836040516100e691906101c1565b60405180910390a16001905092915050565b600081359050610107816101fc565b92915050565b60008135905061011c81610213565b92915050565b6000806040838503121561013557600080fd5b60006101438582860161010d565b9250506020610154858286016100f8565b9150509250929050565b610167816101dc565b82525050565b610176816101e8565b82525050565b610185816101f2565b82525050565b60006020820190506101a0600083018461015e565b92915050565b60006020820190506101bb600083018461016d565b92915050565b60006020820190506101d6600083018461017c565b92915050565b60008115159050919050565b6000819050919050565b6000819050919050565b610205816101e8565b811461021057600080fd5b50565b61021c816101f2565b811461022757600080fd5b5056fea26469706673582212205c428504ca5a53a9250d76b287bec8ee4b13d5c7cb386a0f67cbf77ecb96a9ea64736f6c63430008040033
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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}
|
||||
Loading…
Reference in New Issue