Merge branch 'develop'

Conflicts:
	libdevcore/Common.cpp
	windows/LibEthereum.vcxproj

CMakeLists.txt

@@ -190,6 +190,7 @@ else()
 	endif ()
 
 	find_path( PYTHON_ID pyconfig.h
+		${PYTHON_INCLUDE_DIR}
 		/usr/include/python2.7
 		/usr/local/include/python2.7
 		)
@@ -289,7 +290,7 @@ else()
 	if (LANGUAGES)
 		find_package(Boost 1.53 REQUIRED COMPONENTS thread date_time)
 	else()
-		find_package(Boost 1.53 REQUIRED COMPONENTS thread date_time system)
+		find_package(Boost 1.53 REQUIRED COMPONENTS thread date_time system regex)
 	endif()
 
 	set(QTQML 1)
@@ -323,7 +324,7 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	include_directories(/usr/local/include)
 endif()
 
-add_subdirectory(libethential)
+add_subdirectory(libdevcore)
 add_subdirectory(libevmface)
 add_subdirectory(liblll)
 add_subdirectory(libserpent)
@@ -336,9 +337,16 @@ add_subdirectory(lllc)
 add_subdirectory(sc)
 if (NOT LANGUAGES)
 	add_subdirectory(secp256k1)
+	add_subdirectory(libp2p)
+	add_subdirectory(libdevcrypto)
+	add_subdirectory(libwhisper)
+
 	add_subdirectory(libethcore)
 	add_subdirectory(libevm)
 	add_subdirectory(libethereum)
+#	add_subdirectory(libethereumx)	 # TODO remove
+
+	add_subdirectory(libwebthree)
 	add_subdirectory(test)
 	add_subdirectory(eth)
 	if("x${CMAKE_BUILD_TYPE}" STREQUAL "xDebug")
@@ -358,8 +366,10 @@ if (NOT LANGUAGES)
 		
 		add_subdirectory(libqethereum)
 		add_subdirectory(alethzero)
+		add_subdirectory(third)
 		if(QTQML)
-			add_subdirectory(walleth)
+			#add_subdirectory(iethxi)
+			#add_subdirectory(walleth)	// resurect once we want to submit ourselves to QML.
 		endif()
 	endif()
 endif()

LICENSE

@@ -1,19 +1,673 @@
-The MIT License (MIT)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://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 <http://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
+<http://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
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

alethzero/CMakeLists.txt

@@ -52,7 +52,7 @@ else ()
 endif ()
 
 qt5_use_modules(${EXECUTEABLE} Core)# Gui Widgets Network WebKit WebKitWidgets)
-target_link_libraries(${EXECUTEABLE} qethereum ethereum evm ethcore secp256k1 gmp ${CRYPTOPP_LS} serpent lll evmface ethential)
+target_link_libraries(${EXECUTEABLE} webthree qethereum ethereum evm ethcore devcrypto secp256k1 gmp ${CRYPTOPP_LS} serpent lll evmface devcore)
 
 if (APPLE)
 	# First have qt5 install plugins and frameworks

alethzero/DownloadView.cpp

@@ -0,0 +1,83 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file DownloadView.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "DownloadView.h"
+
+#include <QtWidgets>
+#include <QtCore>
+#include <libethereum/DownloadMan.h>
+#include "Grapher.h"
+
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+DownloadView::DownloadView(QWidget* _p): QWidget(_p)
+{
+}
+
+void DownloadView::paintEvent(QPaintEvent*)
+{
+	QPainter p(this);
+
+	p.fillRect(rect(), Qt::white);
+	if (!m_man || m_man->chain().empty() || !m_man->subCount())
+		return;
+
+	double ratio = (double)rect().width() / rect().height();
+	if (ratio < 1)
+		ratio = 1 / ratio;
+	double n = min(rect().width(), rect().height()) / ceil(sqrt(m_man->chain().size() / ratio));
+
+//	QSizeF area(rect().width() / floor(rect().width() / n), rect().height() / floor(rect().height() / n));
+	QSizeF area(n, n);
+	QPointF pos(0, 0);
+
+	auto const& bg = m_man->blocksGot();
+
+	for (unsigned i = bg.all().first, ei = bg.all().second; i < ei; ++i)
+	{
+		int s = -2;
+		if (bg.contains(i))
+			s = -1;
+		else
+		{
+			unsigned h = 0;
+			m_man->foreachSub([&](DownloadSub const& sub)
+			{
+				if (sub.asked().contains(i))
+					s = h;
+				h++;
+			});
+		}
+		unsigned dh = 360 / m_man->subCount();
+		if (s == -2)
+			p.fillRect(QRectF(QPointF(pos) + QPointF(3 * area.width() / 8, 3 * area.height() / 8), area / 4), Qt::black);
+		else if (s == -1)
+			p.fillRect(QRectF(QPointF(pos) + QPointF(1 * area.width() / 8, 1 * area.height() / 8), area * 3 / 4), Qt::black);
+		else
+			p.fillRect(QRectF(QPointF(pos) + QPointF(1 * area.width() / 8, 1 * area.height() / 8), area * 3 / 4), QColor::fromHsv(s * dh, 64, 128));
+
+		pos.setX(pos.x() + n);
+		if (pos.x() >= rect().width() - n)
+			pos = QPoint(0, pos.y() + n);
+	}
+}

alethzero/DownloadView.h

@@ -0,0 +1,53 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file DownloadView.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#pragma once
+
+#ifdef Q_MOC_RUN
+#define BOOST_MPL_IF_HPP_INCLUDED
+#endif
+
+#include <list>
+#include <QtWidgets/QWidget>
+#ifndef Q_MOC_RUN
+#include <libethereum/Client.h>
+#endif
+
+namespace dev { namespace eth {
+struct MineInfo;
+class DownloadMan;
+}}
+
+class DownloadView: public QWidget
+{
+	Q_OBJECT
+
+public:
+	DownloadView(QWidget* _p = nullptr);
+
+	void setDownloadMan(dev::eth::DownloadMan const* _man) { m_man = _man; }
+
+protected:
+	virtual void paintEvent(QPaintEvent*);
+
+private:
+	dev::eth::DownloadMan const* m_man = nullptr;
+};

alethzero/Main.ui

@@ -132,6 +132,7 @@
     </property>
     <addaction name="upnp"/>
     <addaction name="usePast"/>
+    <addaction name="localNetworking"/>
     <addaction name="net"/>
     <addaction name="connect"/>
    </widget>
@@ -184,7 +185,11 @@
     <addaction name="paranoia"/>
     <addaction name="killBlockchain"/>
     <addaction name="inject"/>
-    <addaction name="clearPending"/>
+    <addaction name="forceMining"/>
+    <addaction name="turboMining"/>
+    <addaction name="enableOptimizer"/>
+    <addaction name="separator"/>
+    <addaction name="usePrivate"/>
    </widget>
    <addaction name="menu_File"/>
    <addaction name="menu_Network"/>
@@ -377,19 +382,27 @@
       <number>0</number>
      </property>
      <item>
-      <widget class="QListWidget" name="log">
+      <widget class="QPlainTextEdit" name="log">
        <property name="font">
         <font>
-         <family>Monospace</family>
-         <pointsize>12</pointsize>
+         <family>Ubuntu Mono</family>
         </font>
        </property>
-       <property name="focusPolicy">
-        <enum>Qt::NoFocus</enum>
-       </property>
        <property name="frameShape">
         <enum>QFrame::NoFrame</enum>
        </property>
+       <property name="frameShadow">
+        <enum>QFrame::Plain</enum>
+       </property>
+       <property name="lineWidth">
+        <number>0</number>
+       </property>
+       <property name="lineWrapMode">
+        <enum>QPlainTextEdit::NoWrap</enum>
+       </property>
+       <property name="readOnly">
+        <bool>true</bool>
+       </property>
       </widget>
      </item>
      <item>
@@ -498,6 +511,7 @@
    <addaction name="connect"/>
    <addaction name="preview"/>
    <addaction name="mine"/>
+   <addaction name="refresh"/>
   </widget>
   <widget class="QDockWidget" name="dockWidget_5">
    <property name="sizePolicy">
@@ -557,7 +571,7 @@
        </widget>
        <widget class="QTextEdit" name="code">
         <property name="focusPolicy">
-         <enum>Qt::NoFocus</enum>
+         <enum>Qt::ClickFocus</enum>
         </property>
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
@@ -565,6 +579,9 @@
         <property name="lineWidth">
          <number>0</number>
         </property>
+        <property name="readOnly">
+         <bool>true</bool>
+        </property>
        </widget>
       </widget>
      </item>
@@ -1416,6 +1433,39 @@ font-size: 14pt</string>
     </layout>
    </widget>
   </widget>
+  <widget class="QDockWidget" name="dockWidget_12">
+   <property name="features">
+    <set>QDockWidget::DockWidgetFeatureMask</set>
+   </property>
+   <property name="windowTitle">
+    <string>Blockchain Download</string>
+   </property>
+   <attribute name="dockWidgetArea">
+    <number>2</number>
+   </attribute>
+   <widget class="QWidget" name="dockWidgetContents_12">
+    <layout class="QHBoxLayout" name="horizontalLayout_8">
+     <property name="spacing">
+      <number>0</number>
+     </property>
+     <property name="leftMargin">
+      <number>0</number>
+     </property>
+     <property name="topMargin">
+      <number>0</number>
+     </property>
+     <property name="rightMargin">
+      <number>0</number>
+     </property>
+     <property name="bottomMargin">
+      <number>0</number>
+     </property>
+     <item>
+      <widget class="DownloadView" name="downloadView" native="true"/>
+     </item>
+    </layout>
+   </widget>
+  </widget>
   <action name="quit">
    <property name="text">
     <string>&amp;Quit</string>
@@ -1553,9 +1603,12 @@ font-size: 14pt</string>
     <string>Ctrl+F10</string>
    </property>
   </action>
-  <action name="clearPending">
+  <action name="forceMining">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
    <property name="text">
-    <string>&amp;Clear Pending</string>
+    <string>&amp;Force Mining</string>
    </property>
   </action>
   <action name="dumpTraceStorage">
@@ -1650,6 +1703,43 @@ font-size: 14pt</string>
     <string>&amp;Pretty...</string>
    </property>
   </action>
+  <action name="refresh">
+   <property name="text">
+    <string>&amp;Refresh</string>
+   </property>
+  </action>
+  <action name="usePrivate">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>&amp;Use Private Chain...</string>
+   </property>
+  </action>
+  <action name="enableOptimizer">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>&amp;Enable LLL &amp;Optimizer</string>
+   </property>
+  </action>
+  <action name="turboMining">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Reserved Debug 1</string>
+   </property>
+  </action>
+  <action name="localNetworking">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Enable Local Addresses</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
@@ -1664,6 +1754,12 @@ font-size: 14pt</string>
    <header>MiningView.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>DownloadView</class>
+   <extends>QWidget</extends>
+   <header>DownloadView.h</header>
+   <container>1</container>
+  </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>destination</tabstop>

alethzero/MainWin.h

@@ -27,36 +27,38 @@
 #include <QtCore/QAbstractListModel>
 #include <QtCore/QMutex>
 #include <QtWidgets/QMainWindow>
-#include <libethential/RLP.h>
+#include <libdevcore/RLP.h>
 #include <libethcore/CommonEth.h>
 #include <libethereum/State.h>
 #include <libqethereum/QEthereum.h>
+#include <libwebthree/WebThree.h>
 
 namespace Ui {
 class Main;
 }
 
-namespace eth {
+namespace dev { namespace eth {
 class Client;
 class State;
-}
+class MessageFilter;
+}}
 
 class QQuickView;
 
 struct WorldState
 {
 	uint64_t steps;
-	eth::Address cur;
-	eth::u256 curPC;
-	eth::Instruction inst;
-	unsigned newMemSize;
-	eth::u256 gas;
-	eth::h256 code;
-	eth::h256 callData;
-	eth::u256s stack;
-	eth::bytes memory;
-	eth::bigint gasCost;
-	std::map<eth::u256, eth::u256> storage;
+	dev::Address cur;
+	dev::u256 curPC;
+	dev::eth::Instruction inst;
+	dev::bigint newMemSize;
+	dev::u256 gas;
+	dev::h256 code;
+	dev::h256 callData;
+	dev::u256s stack;
+	dev::bytes memory;
+	dev::bigint gasCost;
+	std::map<dev::u256, dev::u256> storage;
 	std::vector<WorldState const*> levels;
 };
 
@@ -68,9 +70,11 @@ public:
 	explicit Main(QWidget *parent = 0);
 	~Main();
 
-	eth::Client* client() { return m_client.get(); }
+	dev::WebThreeDirect* web3() const { return m_webThree.get(); }
+	dev::eth::Client* ethereum() const { return m_webThree->ethereum(); }
+	dev::shh::WhisperHost* whisper() const { return m_webThree->whisper(); }
 
-	QList<eth::KeyPair> const& owned() const { return m_myKeys; }
+	QList<dev::KeyPair> const& owned() const { return m_myKeys; }
 	
 public slots:
 	void load(QString _file);
@@ -78,6 +82,8 @@ public slots:
 	void debug(QString _entry);
 	void warn(QString _entry);
 
+	void onKeysChanged();
+
 private slots:
 	void eval(QString const& _js);
 
@@ -106,7 +112,7 @@ private slots:
 	void on_about_triggered();
 	void on_paranoia_triggered();
 	void on_nameReg_textChanged();
-	void on_preview_triggered() { refresh(true); }
+	void on_preview_triggered();
 	void on_quit_triggered() { close(); }
 	void on_urlEdit_returnPressed();
 	void on_debugStep_triggered();
@@ -118,11 +124,11 @@ private slots:
 	void on_importKey_triggered();
 	void on_exportKey_triggered();
 	void on_inject_triggered();
-	void on_showAll_triggered() { refresh(true); }
-	void on_showAllAccounts_triggered() { refresh(true); }
+	void on_showAll_triggered() { refreshBlockChain(); }
+	void on_showAllAccounts_triggered() { refreshAccounts(); }
 	void on_loadJS_triggered();
 	void on_blockChainFilter_textChanged();
-	void on_clearPending_triggered();
+	void on_forceMining_triggered();
 	void on_dumpTrace_triggered();
 	void on_dumpTraceStorage_triggered();
 	void on_dumpTracePretty_triggered();
@@ -134,73 +140,105 @@ private slots:
 	void on_debugCurrent_triggered();
 	void on_debugDumpState_triggered(int _add = 1);
 	void on_debugDumpStatePre_triggered();
-
-	void refresh(bool _override = false);
-	void refreshNetwork();
-	void refreshMining();
-	void refreshBlockChain();
+	void on_refresh_triggered();
+    void on_usePrivate_triggered();
+	void on_enableOptimizer_triggered();
+	void on_turboMining_triggered();
 
 signals:
-	void changed();	// TODO: manifest
+	void poll();
 
 private:
-	void updateBlockCount();
+	dev::p2p::NetworkPreferences netPrefs() const;
+
+	QString pretty(dev::Address _a) const;
+	QString prettyU256(dev::u256 _n) const;
 
-	QString pretty(eth::Address _a) const;
-	QString prettyU256(eth::u256 _n) const;
+	QString lookup(QString const& _n) const;
 
-	void populateDebugger(eth::bytesConstRef r);
+	void populateDebugger(dev::bytesConstRef r);
 	void initDebugger();
 	void updateDebugger();
 	void debugFinished();
-	QString render(eth::Address _a) const;
-	eth::Address fromString(QString const& _a) const;
-	std::string renderDiff(eth::StateDiff const& _d) const;
+	QString render(dev::Address _a) const;
+	dev::Address fromString(QString const& _a) const;
+	std::string renderDiff(dev::eth::StateDiff const& _d) const;
 
 	void alterDebugStateGroup(bool _enable) const;
 
-	eth::State const& state() const;
-
 	void updateFee();
-	void readSettings();
+	void readSettings(bool _skipGeometry = false);
 	void writeSettings();
 
 	bool isCreation() const;
-	eth::u256 fee() const;
-	eth::u256 total() const;
-	eth::u256 value() const;
-	eth::u256 gasPrice() const;
+	dev::u256 fee() const;
+	dev::u256 total() const;
+	dev::u256 value() const;
+	dev::u256 gasPrice() const;
+
+	unsigned installWatch(dev::eth::MessageFilter const& _tf, std::function<void()> const& _f);
+	unsigned installWatch(dev::h256 _tf, std::function<void()> const& _f);
+
+	void onNewPending();
+	void onNewBlock();
+	void onNameRegChange();
+	void onCurrenciesChange();
+	void onBalancesChange();
+
+	void installWatches();
+	void installCurrenciesWatch();
+	void installNameRegWatch();
+	void installBalancesWatch();
+
+	virtual void timerEvent(QTimerEvent*);
+
+	void refreshNetwork();
+	void refreshMining();
+
+	void refreshAll();
+	void refreshPending();
+	void refreshAccounts();
+	void refreshDestination();
+	void refreshBlockChain();
+	void refreshBlockCount();
+	void refreshBalances();
 
 	std::unique_ptr<Ui::Main> ui;
 
-	std::unique_ptr<eth::Client> m_client;
+	std::unique_ptr<dev::WebThreeDirect> m_webThree;
+
+	std::map<unsigned, std::function<void()>> m_handlers;
+	unsigned m_nameRegFilter = (unsigned)-1;
+	unsigned m_currenciesFilter = (unsigned)-1;
+	unsigned m_balancesFilter = (unsigned)-1;
 
 	QByteArray m_peers;
-	QMutex m_guiLock;
-	QTimer* m_refresh;
-	QTimer* m_refreshNetwork;
-	QTimer* m_refreshMining;
 	QStringList m_servers;
-	QList<eth::KeyPair> m_myKeys;
+	QList<dev::KeyPair> m_myKeys;
+	QString m_privateChain;
 	bool m_keysChanged = false;
-	eth::bytes m_data;
-	eth::Address m_nameReg;
+	dev::bytes m_data;
+	dev::Address m_nameReg;
 
 	unsigned m_backupGas;
 
-	eth::State m_executiveState;
-	std::unique_ptr<eth::Executive> m_currentExecution;
-	eth::h256 m_lastCode;
-	eth::h256 m_lastData;
+	dev::eth::State m_executiveState;
+	std::unique_ptr<dev::eth::Executive> m_currentExecution;
+	dev::h256 m_lastCode;
+	dev::h256 m_lastData;
 	std::vector<WorldState const*> m_lastLevels;
 
 	QMap<unsigned, unsigned> m_pcWarp;
 	QList<WorldState> m_history;
-	std::map<eth::u256, eth::bytes> m_codes;	// and pcWarps
+	std::map<dev::u256, dev::bytes> m_codes;	// and pcWarps
+	bool m_enableOptimizer = true;
 
 	QNetworkAccessManager m_webCtrl;
 
 	QList<QPair<QString, QString>> m_consoleHistory;
+	QMutex m_logLock;
+	QString m_logHistory;
+	bool m_logChanged = true;
 
-	QEthereum* m_ethereum;
+	QEthereum* m_ethereum = nullptr;
 };

alethzero/MiningView.cpp

@@ -29,17 +29,18 @@
 using namespace std;
 using namespace lb;
 
-// do *not* use eth since eth::uint conflicts with Qt's global unit definition
-// using namespace eth;
+// do *not* use eth since unsigned conflicts with Qt's global unit definition
+// using namespace dev;
+using namespace dev::eth;
 
 // types
 
-using eth::MineInfo;
-using eth::MineProgress;
+using dev::eth::MineInfo;
+using dev::eth::MineProgress;
 
 // functions
-using eth::toString;
-using eth::trimFront;
+using dev::toString;
+using dev::trimFront;
 
 string id(float _y) { return toString(_y); }
 string s(float _x){ return toString(round(_x * 1000) / 1000) + (!_x ? "s" : ""); }

alethzero/MiningView.h

@@ -27,12 +27,13 @@
 
 #include <list>
 #include <QtWidgets/QWidget>
+#ifndef Q_MOC_RUN
 #include <libethereum/Client.h>
+#endif
 
-namespace eth
-{
+namespace dev { namespace eth {
 struct MineInfo;
-}
+}}
 
 class MiningView: public QWidget
 {
@@ -41,14 +42,14 @@ class MiningView: public QWidget
 public:
 	MiningView(QWidget* _p = nullptr);
 
-	void appendStats(std::list<eth::MineInfo> const& _l, eth::MineProgress const& _p);
+	void appendStats(std::list<dev::eth::MineInfo> const& _l, dev::eth::MineProgress const& _p);
 	void resetStats();
 
 protected:
 	virtual void paintEvent(QPaintEvent*);
 
 private:
-	eth::MineProgress m_progress;
+	dev::eth::MineProgress m_progress;
 	unsigned m_duration = 300;
 	std::vector<float> m_values;
 	std::vector<float> m_bests;

eth/CMakeLists.txt

@@ -4,13 +4,13 @@ aux_source_directory(. SRC_LIST)
 
 include_directories(..)
 link_directories(../libethcore)
-link_directories(../libethereum)
+link_directories(../libwebthree)
 
 set(EXECUTABLE eth)
 
 add_executable(${EXECUTABLE} ${SRC_LIST})
 
-target_link_libraries(${EXECUTABLE} ethereum)
+target_link_libraries(${EXECUTABLE} webthree)
 target_link_libraries(${EXECUTABLE} secp256k1)
 target_link_libraries(${EXECUTABLE} gmp)
 if(MINIUPNPC_LS)

eth/CommonJS.cpp

@@ -22,9 +22,10 @@
 
 #include "CommonJS.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
-bytes eth::jsToBytes(string const& _s)
+bytes dev::eth::jsToBytes(string const& _s)
 {
 	if (_s.substr(0, 2) == "0x")
 		// Hex
@@ -37,7 +38,7 @@ bytes eth::jsToBytes(string const& _s)
 		return asBytes(_s);
 }
 
-string eth::jsPadded(string const& _s, unsigned _l, unsigned _r)
+string dev::eth::jsPadded(string const& _s, unsigned _l, unsigned _r)
 {
 	bytes b = jsToBytes(_s);
 	while (b.size() < _l)
@@ -47,7 +48,7 @@ string eth::jsPadded(string const& _s, unsigned _l, unsigned _r)
 	return asString(b).substr(b.size() - max(_l, _r));
 }
 
-string eth::jsPadded(string const& _s, unsigned _l)
+string dev::eth::jsPadded(string const& _s, unsigned _l)
 {
 	if (_s.substr(0, 2) == "0x" || _s.find_first_not_of("0123456789") == string::npos)
 		// Numeric: pad to right
@@ -57,7 +58,7 @@ string eth::jsPadded(string const& _s, unsigned _l)
 		return jsPadded(_s, 0, _l);
 }
 
-string eth::jsUnpadded(string _s)
+string dev::eth::jsUnpadded(string _s)
 {
 	auto p = _s.find_last_not_of((char)0);
 	_s.resize(p == string::npos ? 0 : (p + 1));

eth/CommonJS.h

@@ -23,66 +23,69 @@
 #pragma once
 
 #include <string>
-#include <libethential/Common.h>
-#include <libethential/CommonIO.h>
-#include <libethential/CommonData.h>
-#include <libethential/FixedHash.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/CommonIO.h>
+#include <libdevcore/CommonData.h>
+#include <libdevcore/FixedHash.h>
 #include <libethcore/CommonEth.h>
 
+namespace dev
+{
 namespace eth
 {
 
-eth::bytes jsToBytes(std::string const& _s);
+bytes jsToBytes(std::string const& _s);
 std::string jsPadded(std::string const& _s, unsigned _l, unsigned _r);
 std::string jsPadded(std::string const& _s, unsigned _l);
 std::string jsUnpadded(std::string _s);
 
-template <unsigned N> eth::FixedHash<N> jsToFixed(std::string const& _s)
+template <unsigned N> FixedHash<N> jsToFixed(std::string const& _s)
 {
 	if (_s.substr(0, 2) == "0x")
 		// Hex
-		return eth::FixedHash<N>(_s.substr(2));
+		return FixedHash<N>(_s.substr(2));
 	else if (_s.find_first_not_of("0123456789") == std::string::npos)
 		// Decimal
-		return (typename eth::FixedHash<N>::Arith)(_s);
+		return (typename FixedHash<N>::Arith)(_s);
 	else
 		// Binary
-		return eth::FixedHash<N>(asBytes(jsPadded(_s, N)));
+		return FixedHash<N>(asBytes(jsPadded(_s, N)));
 }
 
 template <unsigned N> boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>> jsToInt(std::string const& _s)
 {
 	if (_s.substr(0, 2) == "0x")
 		// Hex
-		return eth::fromBigEndian<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>>(eth::fromHex(_s.substr(2)));
+		return fromBigEndian<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>>(fromHex(_s.substr(2)));
 	else if (_s.find_first_not_of("0123456789") == std::string::npos)
 		// Decimal
 		return boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>(_s);
 	else
 		// Binary
-		return eth::fromBigEndian<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>>(asBytes(jsPadded(_s, N)));
+		return fromBigEndian<boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>>(asBytes(jsPadded(_s, N)));
 }
 
-inline eth::Address jsToAddress(std::string const& _s) { return jsToFixed<20>(_s); }
-inline eth::Secret jsToSecret(std::string const& _s) { return jsToFixed<32>(_s); }
-inline eth::u256 jsToU256(std::string const& _s) { return jsToInt<32>(_s); }
+inline Address jsToAddress(std::string const& _s) { return jsToFixed<20>(_s); }
+inline Secret jsToSecret(std::string const& _s) { return jsToFixed<32>(_s); }
+inline u256 jsToU256(std::string const& _s) { return jsToInt<32>(_s); }
 
-template <unsigned S> std::string toJS(eth::FixedHash<S> const& _h) { return "0x" + toHex(_h.ref()); }
-template <unsigned N> std::string toJS(boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N, N, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>> const& _n) { return "0x" + eth::toHex(eth::toCompactBigEndian(_n)); }
+template <unsigned S> std::string toJS(FixedHash<S> const& _h) { return "0x" + toHex(_h.ref()); }
+template <unsigned N> std::string toJS(boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N, N, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>> const& _n) { return "0x" + toHex(toCompactBigEndian(_n)); }
 
 inline std::string jsToBinary(std::string const& _s)
 {
-	return eth::asString(jsToBytes(_s));
+	return asString(jsToBytes(_s));
 }
 
 inline std::string jsToDecimal(std::string const& _s)
 {
-	return eth::toString(jsToU256(_s));
+	return toString(jsToU256(_s));
 }
 
 inline std::string jsToHex(std::string const& _s)
 {
-	return "0x" + eth::toHex(asBytes(_s));
+	return "0x" + toHex(asBytes(_s));
 }
 
 }
+}

eth/EthStubServer.cpp

@@ -25,13 +25,15 @@
 #include <libevmface/Instruction.h>
 #include <liblll/Compiler.h>
 #include <libethereum/Client.h>
+#include <libwebthree/WebThree.h>
 #include "CommonJS.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
-EthStubServer::EthStubServer(jsonrpc::AbstractServerConnector* _conn, Client& _client):
+EthStubServer::EthStubServer(jsonrpc::AbstractServerConnector* _conn, WebThreeDirect& _web3):
 	AbstractEthStubServer(_conn),
-	m_client(_client)
+	m_web3(_web3)
 {
 }
 
@@ -58,40 +60,43 @@ Json::Value EthStubServer::procedures()
 	return ret;
 }
 
+dev::eth::Client& EthStubServer::ethereum() const
+{
+	return *m_web3.ethereum();
+}
+
 std::string EthStubServer::coinbase()
 {
-	ClientGuard g(&m_client);
-	return toJS(m_client.address());
+	return toJS(ethereum().address());
 }
 
 std::string EthStubServer::balanceAt(std::string const& _a)
 {
-	ClientGuard g(&m_client);
-	return toJS(m_client.postState().balance(jsToAddress(_a)));
+	return toJS(ethereum().balanceAt(jsToAddress(_a), 0));
 }
 
 Json::Value EthStubServer::check(Json::Value const& _as)
 {
-	if (m_client.changed())
+	// TODO
+//	if (ethereum().changed())
 		return _as;
-	else
+/*	else
 	{
 		Json::Value ret;
 		ret.resize(0);
 		return ret;
-	}
+	}*/
 }
 
 std::string EthStubServer::create(const std::string& _bCode, const std::string& _sec, const std::string& _xEndowment, const std::string& _xGas, const std::string& _xGasPrice)
 {
-	ClientGuard g(&m_client);
-	Address ret = m_client.transact(jsToSecret(_sec), jsToU256(_xEndowment), jsToBytes(_bCode), jsToU256(_xGas), jsToU256(_xGasPrice));
+	Address ret = ethereum().transact(jsToSecret(_sec), jsToU256(_xEndowment), jsToBytes(_bCode), jsToU256(_xGas), jsToU256(_xGasPrice));
 	return toJS(ret);
 }
 
 std::string EthStubServer::lll(const std::string& _s)
 {
-	return "0x" + toHex(eth::compileLLL(_s));
+	return "0x" + toHex(dev::eth::compileLLL(_s));
 }
 
 std::string EthStubServer::gasPrice()
@@ -101,18 +106,17 @@ std::string EthStubServer::gasPrice()
 
 bool EthStubServer::isContractAt(const std::string& _a)
 {
-	ClientGuard g(&m_client);
-	return m_client.postState().addressHasCode(jsToAddress(_a));
+	return ethereum().codeAt(jsToAddress(_a), 0).size();
 }
 
 bool EthStubServer::isListening()
 {
-	return m_client.haveNetwork();
+	return m_web3.haveNetwork();
 }
 
 bool EthStubServer::isMining()
 {
-	return m_client.isMining();
+	return ethereum().isMining();
 }
 
 std::string EthStubServer::key()
@@ -132,27 +136,28 @@ Json::Value EthStubServer::keys()
 
 int EthStubServer::peerCount()
 {
-	ClientGuard g(&m_client);
-	return m_client.peerCount();
+	return m_web3.peerCount();
 }
 
 std::string EthStubServer::storageAt(const std::string& _a, const std::string& x)
 {
-	ClientGuard g(&m_client);
-	return toJS(m_client.postState().storage(jsToAddress(_a), jsToU256(x)));
+	return toJS(ethereum().stateAt(jsToAddress(_a), jsToU256(x), 0));
+}
+
+std::string EthStubServer::stateAt(const std::string& _a, const std::string& x, const std::string& s)
+{
+	return toJS(ethereum().stateAt(jsToAddress(_a), jsToU256(x), std::atol(s.c_str())));
 }
 
 Json::Value EthStubServer::transact(const std::string& _aDest, const std::string& _bData, const std::string& _sec, const std::string& _xGas, const std::string& _xGasPrice, const std::string& _xValue)
 {
-	ClientGuard g(&m_client);
-	m_client.transact(jsToSecret(_sec), jsToU256(_xValue), jsToAddress(_aDest), jsToBytes(_bData), jsToU256(_xGas), jsToU256(_xGasPrice));
+	ethereum().transact(jsToSecret(_sec), jsToU256(_xValue), jsToAddress(_aDest), jsToBytes(_bData), jsToU256(_xGas), jsToU256(_xGasPrice));
 	return Json::Value();
 }
 
 std::string EthStubServer::txCountAt(const std::string& _a)
 {
-	ClientGuard g(&m_client);
-	return toJS(m_client.postState().transactionsFrom(jsToAddress(_a)));
+	return toJS(ethereum().countAt(jsToAddress(_a), 0));
 }
 
 std::string EthStubServer::secretToAddress(const std::string& _a)
@@ -173,7 +178,7 @@ Json::Value EthStubServer::block(const std::string& _hash)
 Json::Value EthStubServer::blockJson(const std::string& _hash)
 {
 	Json::Value res;
-	auto const& bc = m_client.blockChain();
+	auto const& bc = ethereum().blockChain();
 	
 	auto b = _hash.length() ? bc.block(h256(_hash)) : bc.block();
 	

eth/EthStubServer.h

@@ -23,18 +23,18 @@
 
 #include <iostream>
 #include <jsonrpc/rpc.h>
+#include <libdevcrypto/Common.h>
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-parameter"
 #include "abstractethstubserver.h"
 #pragma GCC diagnostic pop
 
-namespace eth { class Client; }
-namespace eth { class KeyPair; }
+namespace dev { class WebThreeDirect; namespace eth { class Client; } class KeyPair; }
 
 class EthStubServer: public AbstractEthStubServer
 {
 public:
-	EthStubServer(jsonrpc::AbstractServerConnector* _conn, eth::Client& _client);
+	EthStubServer(jsonrpc::AbstractServerConnector* _conn, dev::WebThreeDirect& _web3);
 
 	virtual Json::Value procedures();
 	virtual std::string balanceAt(std::string const& _a);
@@ -49,16 +49,18 @@ public:
 	virtual Json::Value keys();
 	virtual int peerCount();
 	virtual std::string storageAt(const std::string& a, const std::string& x);
+	virtual std::string stateAt(const std::string& a, const std::string& x, const std::string& s);
 	virtual Json::Value transact(const std::string& aDest, const std::string& bData, const std::string& sec, const std::string& xGas, const std::string& xGasPrice, const std::string& xValue);
 	virtual std::string txCountAt(const std::string& a);
 	virtual std::string secretToAddress(const std::string& a);
 	virtual Json::Value lastBlock();
 	virtual std::string lll(const std::string& s);
 	virtual Json::Value block(const std::string&);
-	void setKeys(std::vector<eth::KeyPair> _keys) { m_keys = _keys; }
+	void setKeys(std::vector<dev::KeyPair> _keys) { m_keys = _keys; }
 private:
-	eth::Client& m_client;
-	std::vector<eth::KeyPair> m_keys;
+	dev::eth::Client& ethereum() const;
+	dev::WebThreeDirect& m_web3;
+	std::vector<dev::KeyPair> m_keys;
 	Json::Value jsontypeToValue(int);
 	Json::Value blockJson(const std::string&);
 };

eth/abstractethstubserver.h

@@ -30,6 +30,7 @@ class AbstractEthStubServer : public jsonrpc::AbstractServer<AbstractEthStubServ
             this->bindAndAddMethod(new jsonrpc::Procedure("procedures", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_ARRAY,  NULL), &AbstractEthStubServer::proceduresI);
             this->bindAndAddMethod(new jsonrpc::Procedure("secretToAddress", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "a",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::secretToAddressI);
             this->bindAndAddMethod(new jsonrpc::Procedure("storageAt", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "a",jsonrpc::JSON_STRING,"x",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::storageAtI);
+            this->bindAndAddMethod(new jsonrpc::Procedure("stateAt", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "a",jsonrpc::JSON_STRING,"x",jsonrpc::JSON_STRING,"s",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::stateAtI);
             this->bindAndAddMethod(new jsonrpc::Procedure("transact", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_OBJECT, "aDest",jsonrpc::JSON_STRING,"bData",jsonrpc::JSON_STRING,"sec",jsonrpc::JSON_STRING,"xGas",jsonrpc::JSON_STRING,"xGasPrice",jsonrpc::JSON_STRING,"xValue",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::transactI);
             this->bindAndAddMethod(new jsonrpc::Procedure("txCountAt", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_STRING, "a",jsonrpc::JSON_STRING, NULL), &AbstractEthStubServer::txCountAtI);
 
@@ -120,6 +121,11 @@ class AbstractEthStubServer : public jsonrpc::AbstractServer<AbstractEthStubServ
             response = this->storageAt(request["a"].asString(), request["x"].asString());
         }
 
+        inline virtual void stateAtI(const Json::Value& request, Json::Value& response)
+        {
+            response = this->stateAt(request["a"].asString(), request["x"].asString(), request["s"].asString());
+        }
+
         inline virtual void transactI(const Json::Value& request, Json::Value& response) 
         {
             response = this->transact(request["aDest"].asString(), request["bData"].asString(), request["sec"].asString(), request["xGas"].asString(), request["xGasPrice"].asString(), request["xValue"].asString());
@@ -148,6 +154,7 @@ class AbstractEthStubServer : public jsonrpc::AbstractServer<AbstractEthStubServ
         virtual Json::Value procedures() = 0;
         virtual std::string secretToAddress(const std::string& a) = 0;
         virtual std::string storageAt(const std::string& a, const std::string& x) = 0;
+        virtual std::string stateAt(const std::string& a, const std::string& x, const std::string& b) = 0;
         virtual Json::Value transact(const std::string& aDest, const std::string& bData, const std::string& sec, const std::string& xGas, const std::string& xGasPrice, const std::string& xValue) = 0;
         virtual std::string txCountAt(const std::string& a) = 0;
 

eth/eth.js

@@ -25,6 +25,7 @@ var spec = [
             { "method": "peerCount", "params": null, "order": [], "returns" : 0 },
             { "method": "balanceAt", "params": { "a": "" }, "order": ["a"], "returns" : "" },
             { "method": "storageAt", "params": { "a": "", "x": "" }, "order": ["a", "x"], "returns" : "" },
+            { "method": "stateAt", "params": { "a": "", "x": "", "s": "" }, "order": ["a", "x", "s"], "returns" : "" },
             { "method": "txCountAt", "params": { "a": "" },"order": ["a"], "returns" : "" },
             { "method": "isContractAt", "params": { "a": "" }, "order": ["a"], "returns" : false },
             { "method": "create", "params": { "sec": "", "xEndowment": "", "bCode": "", "xGas": "", "xGasPrice": "" }, "order": ["sec", "xEndowment", "bCode", "xGas", "xGasPrice"] , "returns": "" },
@@ -70,24 +71,29 @@ window.eth = (function ethScope() {
 		var m = s.method;
 		var am = "get" + m.slice(0, 1).toUpperCase() + m.slice(1);
 		var getParams = function(a) {
-			var p = s.params ? {} : null
+			var p = s.params ? {} : null;
+			if (m == "stateAt")
+				if (a.length == 2)
+					a[2] = "0";
+				else
+					a[2] = String(a[2]);
 			for (j in s.order)
-				p[s.order[j]] = (s.order[j][0] === "b") ? a[j].unbin() : a[j]
+				p[s.order[j]] = (s.order[j][0] === "b") ? a[j].unbin() : a[j];
 			return p
 		};
-        if (m == "create" || m == "transact")
-            ret[m] = function() { return reqAsync(m, getParams(arguments), arguments[s.order.length]) }
+		if (m == "create" || m == "transact")
+			ret[m] = function() { return reqAsync(m, getParams(arguments), arguments[s.order.length]) }
 		else
 		{
 			ret[am] = function() { return reqAsync(m, getParams(arguments), arguments[s.order.length]) }
 			if (s.params)
 				ret[m] = function() { return reqSync(m, getParams(arguments)) }
-            else
+			else
 				Object.defineProperty(ret, m, {
 					get: function() { return reqSync(m, {}); },
 					set: function(v) {}
-			})
-        }
+				})
+		}
 	})(spec[si]);
 
 	ret.check = function(force) {
@@ -101,7 +107,7 @@ window.eth = (function ethScope() {
 		for (var c in changed)
 			m_watching[changed[c]]()
 		var that = this;
-		setTimeout(function() { that.check() }, 5000)
+		setTimeout(function() { that.check() }, 12000)
 	}
 
 	ret.watch = function(a, fx, f) {

eth/main.cpp

@@ -29,14 +29,11 @@
 #if ETH_JSONRPC
 #include <jsonrpc/connectors/httpserver.h>
 #endif
-#include <libethcore/FileSystem.h>
+#include <libdevcrypto/FileSystem.h>
 #include <libevmface/Instruction.h>
-#include <libethereum/Defaults.h>
-#include <libethereum/Client.h>
-#include <libethereum/PeerNetwork.h>
-#include <libethereum/BlockChain.h>
-#include <libethereum/State.h>
-#include <libethcore/CommonEth.h>
+#include <libevm/VM.h>
+#include <libethereum/All.h>
+#include <libwebthree/WebThree.h>
 #if ETH_READLINE
 #include <readline/readline.h>
 #include <readline/history.h>
@@ -46,10 +43,13 @@
 #endif
 #include "BuildInfo.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::p2p;
+using namespace dev::eth;
 using namespace boost::algorithm;
-using eth::Instruction;
-using eth::c_instructionInfo;
+using dev::eth::Instruction;
+
+#undef RETURN
 
 bool isTrue(std::string const& _m)
 {
@@ -73,6 +73,7 @@ void interactiveHelp()
 		<< "    verbosity (<level>)  Gets or sets verbosity level." << endl
 		<< "    minestart  Starts mining." << endl
 		<< "    minestop  Stops mining." << endl
+		<< "    mineforce <enable>  Forces mining, even when there are no transactions." << endl
 		<< "    address  Gives the current address." << endl
 		<< "    secret  Gives the current secret" << endl
 		<< "    block  Gives the current block height." << endl
@@ -81,13 +82,14 @@ void interactiveHelp()
 		<< "    send  Execute a given transaction with current secret." << endl
 		<< "    contract  Create a new contract with current secret." << endl
 		<< "    peers  List the peers that are connected" << endl
-		<< "    listAccounts List the accounts on the network." << endl
-		<< "    listContracts List the contracts on the network." << endl
-		<< "    setSecret <secret> Set the secret to the hex secret key." <<endl
-		<< "    setAddress <addr> Set the coinbase (mining payout) address." <<endl
-		<< "    exportConfig <path> Export the config (.RLP) to the path provided." <<endl
-		<< "    importConfig <path> Import the config (.RLP) from the path provided." <<endl
-		<< "    inspect <contract> Dumps a contract to <APPDATA>/<contract>.evm." << endl
+		<< "    listAccounts  List the accounts on the network." << endl
+		<< "    listContracts  List the contracts on the network." << endl
+		<< "    setSecret <secret>  Set the secret to the hex secret key." <<endl
+		<< "    setAddress <addr>  Set the coinbase (mining payout) address." <<endl
+		<< "    exportConfig <path>  Export the config (.RLP) to the path provided." <<endl
+		<< "    importConfig <path>  Import the config (.RLP) from the path provided." <<endl
+		<< "    inspect <contract>  Dumps a contract to <APPDATA>/<contract>.evm." << endl
+		<< "    dumptrace <block> <index> <filename> <format>  Dumps a transaction trace" << endl << "to <filename>. <format> should be one of pretty, standard, standard+." << endl
 		<< "    exit  Exits the application." << endl;
 }
 
@@ -97,10 +99,12 @@ void help()
         << "Usage eth [OPTIONS] <remote-host>" << endl
         << "Options:" << endl
         << "    -a,--address <addr>  Set the coinbase (mining payout) address to addr (default: auto)." << endl
+		<< "    -b,--bootstrap  Connect to the default Ethereum peerserver." << endl
         << "    -c,--client-name <name>  Add a name to your client's version string (default: blank)." << endl
         << "    -d,--db-path <path>  Load database from path (default:  ~/.ethereum " << endl
         << "                         <APPDATA>/Etherum or Library/Application Support/Ethereum)." << endl
-        << "    -h,--help  Show this help message and exit." << endl
+		<< "    -f,--force-mining  Mine even when there are no transaction to mine (Default: off)" << endl
+		<< "    -h,--help  Show this help message and exit." << endl
         << "    -i,--interactive  Enter interactive mode (default: non-interactive)." << endl
 #if ETH_JSONRPC
 		<< "    -j,--json-rpc  Enable JSON-RPC server (default: off)." << endl
@@ -108,8 +112,9 @@ void help()
 #endif
         << "    -l,--listen <port>  Listen on the given port for incoming connected (default: 30303)." << endl
 		<< "    -m,--mining <on/off/number>  Enable mining, optionally for a specified number of blocks (Default: off)" << endl
-        << "    -n,--upnp <on/off>  Use upnp for NAT (default: on)." << endl
-        << "    -o,--mode <full/peer>  Start a full node or a peer node (Default: full)." << endl
+		<< "    -n,--upnp <on/off>  Use upnp for NAT (default: on)." << endl
+		<< "    -L,--local-networking Use peers whose addresses are local." << endl
+		<< "    -o,--mode <full/peer>  Start a full node or a peer node (Default: full)." << endl
         << "    -p,--port <port>  Connect to remote port (default: 30303)." << endl
         << "    -r,--remote <host>  Connect to remote host (default: none)." << endl
         << "    -s,--secret <secretkeyhex>  Set the secret key for use with send command (default: auto)." << endl
@@ -124,23 +129,14 @@ string credits(bool _interactive = false)
 {
 	std::ostringstream cout;
 	cout
-        << "Ethereum (++) " << eth::EthVersion << endl
+		<< "Ethereum (++) " << dev::Version << endl
 		<< "  Code by Gav Wood, (c) 2013, 2014." << endl
 		<< "  Based on a design by Vitalik Buterin." << endl << endl;
 
 	if (_interactive)
 	{
-        string vs = toString(eth::EthVersion);
-		vs = vs.substr(vs.find_first_of('.') + 1)[0];
-		int pocnumber = stoi(vs);
-		string m_servers;
-		if (pocnumber == 4)
-			m_servers = "54.72.31.55";
-		else
-			m_servers = "54.72.69.180";
-
 		cout << "Type 'netstart 30303' to start networking" << endl;
-		cout << "Type 'connect " << m_servers << " 30303' to connect" << endl;
+		cout << "Type 'connect " << Host::pocHost() << " 30303' to connect" << endl;
 		cout << "Type 'exit' to quit" << endl << endl;
 	}
 	return cout.str();
@@ -148,13 +144,13 @@ string credits(bool _interactive = false)
 
 void version()
 {
-    cout << "eth version " << eth::EthVersion << endl;
-	cout << "Build: " << ETH_QUOTED(ETH_BUILD_PLATFORM) << "/" << ETH_QUOTED(ETH_BUILD_TYPE) << endl;
+	cout << "eth version " << dev::Version << endl;
+	cout << "Build: " << DEV_QUOTED(ETH_BUILD_PLATFORM) << "/" << DEV_QUOTED(ETH_BUILD_TYPE) << endl;
 	exit(0);
 }
 
 Address c_config = Address("ccdeac59d35627b7de09332e819d5159e7bb7250");
-string pretty(h160 _a, eth::State _st)
+string pretty(h160 _a, dev::eth::State _st)
 {
 	string ns;
 	h256 n;
@@ -169,22 +165,25 @@ string pretty(h160 _a, eth::State _st)
 	}
 	return ns;
 }
-bytes parse_data(string _args);
+
 int main(int argc, char** argv)
 {
 	unsigned short listenPort = 30303;
 	string remoteHost;
 	unsigned short remotePort = 30303;
 	string dbPath;
-	eth::uint mining = ~(eth::uint)0;
+	unsigned mining = ~(unsigned)0;
 	NodeMode mode = NodeMode::Full;
 	unsigned peers = 5;
 	bool interactive = false;
 #if ETH_JSONRPC
-	int jsonrpc = 8080;
+	int jsonrpc = -1;
 #endif
 	string publicIP;
+	bool bootstrap = false;
 	bool upnp = true;
+	bool useLocal = false;
+	bool forceMining = false;
 	string clientName;
 
 	// Init defaults
@@ -229,10 +228,12 @@ int main(int argc, char** argv)
 				upnp = false;
 			else
 			{
-				cerr << "Invalid UPnP option: " << m << endl;
+				cerr << "Invalid -n/--upnp option: " << m << endl;
 				return -1;
 			}
 		}
+		else if (arg == "-L" || arg == "--local-networking")
+			useLocal = true;
 		else if ((arg == "-c" || arg == "--client-name") && i + 1 < argc)
 			clientName = argv[++i];
 		else if ((arg == "-a" || arg == "--address" || arg == "--coinbase-address") && i + 1 < argc)
@@ -245,22 +246,26 @@ int main(int argc, char** argv)
 		{
 			string m = argv[++i];
 			if (isTrue(m))
-				mining = ~(eth::uint)0;
+				mining = ~(unsigned)0;
 			else if (isFalse(m))
 				mining = 0;
 			else if (int i = stoi(m))
 				mining = i;
 			else
 			{
-				cerr << "Unknown mining option: " << m << endl;
+				cerr << "Unknown -m/--mining option: " << m << endl;
 				return -1;
 			}
 		}
+		else if (arg == "-b" || arg == "--bootstrap")
+			bootstrap = true;
+		else if (arg == "-f" || arg == "--force-mining")
+			forceMining = true;
 		else if (arg == "-i" || arg == "--interactive")
 			interactive = true;
 #if ETH_JSONRPC
 		else if ((arg == "-j" || arg == "--json-rpc"))
-			jsonrpc = jsonrpc ? jsonrpc : 8080;
+			jsonrpc = jsonrpc == -1 ? 8080 : jsonrpc;
 		else if (arg == "--json-rpc-port" && i + 1 < argc)
 			jsonrpc = atoi(argv[++i]);
 #endif
@@ -291,18 +296,33 @@ int main(int argc, char** argv)
 
 	if (!clientName.empty())
 		clientName += "/";
-    Client c("Ethereum(++)/" + clientName + "v" + eth::EthVersion + "/" ETH_QUOTED(ETH_BUILD_TYPE) "/" ETH_QUOTED(ETH_BUILD_PLATFORM), coinbase, dbPath);
-	c.start();
+
 	cout << credits();
 
+	NetworkPreferences netPrefs(listenPort, publicIP, upnp, useLocal);
+	dev::WebThreeDirect web3("Ethereum(++)/" + clientName + "v" + dev::Version + "/" DEV_QUOTED(ETH_BUILD_TYPE) "/" DEV_QUOTED(ETH_BUILD_PLATFORM), dbPath, false, mode == NodeMode::Full ? set<string>{"eth", "shh"} : set<string>{}, netPrefs);
+	web3.setIdealPeerCount(peers);
+	eth::Client* c = mode == NodeMode::Full ? web3.ethereum() : nullptr;
+
+	if (c)
+	{
+		c->setForceMining(forceMining);
+		c->setAddress(coinbase);
+	}
+
 	cout << "Address: " << endl << toHex(us.address().asArray()) << endl;
-	c.startNetwork(listenPort, remoteHost, remotePort, mode, peers, publicIP, upnp);
+	web3.startNetwork();
+
+	if (bootstrap)
+		web3.connect(Host::pocHost());
+	if (remoteHost.size())
+		web3.connect(remoteHost, remotePort);
 
 #if ETH_JSONRPC
 	auto_ptr<EthStubServer> jsonrpcServer;
 	if (jsonrpc > -1)
 	{
-		jsonrpcServer = auto_ptr<EthStubServer>(new EthStubServer(new jsonrpc::HttpServer(jsonrpc), c));
+		jsonrpcServer = auto_ptr<EthStubServer>(new EthStubServer(new jsonrpc::HttpServer(jsonrpc), web3));
 		jsonrpcServer->setKeys({us});
 		jsonrpcServer->StartListening();
 	}
@@ -310,9 +330,16 @@ int main(int argc, char** argv)
 
 	if (interactive)
 	{
+		string logbuf;
 		string l;
 		while (true)
 		{
+			g_logPost = [](std::string const& a, char const*) { cout << "\r           \r" << a << endl << "Press Enter" << flush; };
+			cout << logbuf << "Press Enter" << flush;
+			std::getline(cin, l);
+			logbuf.clear();
+			g_logPost = [&](std::string const& a, char const*) { logbuf += a + "\n"; };
+
 #if ETH_READLINE
 			if (l.size())
 				add_history(l.c_str());
@@ -333,31 +360,34 @@ int main(int argc, char** argv)
 			iss >> cmd;
 			if (cmd == "netstart")
 			{
-				eth::uint port;
-				iss >> port;
-				ClientGuard g(&c);
-				c.startNetwork((short)port);
+				iss >> netPrefs.listenPort;
+				web3.setNetworkPreferences(netPrefs);
+				web3.startNetwork();
 			}
 			else if (cmd == "connect")
 			{
 				string addr;
-				eth::uint port;
+				unsigned port;
 				iss >> addr >> port;
-				ClientGuard g(&c);
-				c.connect(addr, (short)port);
+				web3.connect(addr, (short)port);
 			}
 			else if (cmd == "netstop")
 			{
-				ClientGuard g(&c);
-				c.stopNetwork();
+				web3.stopNetwork();
+			}
+			else if (c && cmd == "minestart")
+			{
+				c->startMining();
 			}
-			else if (cmd == "minestart")
+			else if (c && cmd == "minestop")
 			{
-				c.startMining();
+				c->stopMining();
 			}
-			else if (cmd == "minestop")
+			else if (c && cmd == "mineforce")
 			{
-				c.stopMining();
+				string enable;
+				iss >> enable;
+				c->setForceMining(isTrue(enable));
 			}
 			else if (cmd == "verbosity")
 			{
@@ -376,7 +406,7 @@ int main(int argc, char** argv)
 			{
 				if (jsonrpc < 0)
 					jsonrpc = 8080;
-				jsonrpcServer = auto_ptr<EthStubServer>(new EthStubServer(new jsonrpc::HttpServer(jsonrpc), c));
+				jsonrpcServer = auto_ptr<EthStubServer>(new EthStubServer(new jsonrpc::HttpServer(jsonrpc), web3));
 				jsonrpcServer->setKeys({us});
 				jsonrpcServer->StartListening();
 			}
@@ -397,28 +427,24 @@ int main(int argc, char** argv)
 			{
 				cout << "Secret Key: " << toHex(us.secret().asArray()) << endl;
 			}
-			else if (cmd == "block")
+			else if (c && cmd == "block")
 			{
-				ClientGuard g(&c);
-				cout << "Current block: " << c.blockChain().details().number;
+				cout << "Current block: " <<c->blockChain().details().number << endl;
 			}
 			else if (cmd == "peers")
 			{
-				ClientGuard g(&c);
-				for (auto it: c.peers())
+				for (auto it: web3.peers())
 					cout << it.host << ":" << it.port << ", " << it.clientVersion << ", "
 						<< std::chrono::duration_cast<std::chrono::milliseconds>(it.lastPing).count() << "ms"
 						<< endl;
 			}
-			else if (cmd == "balance")
+			else if (c && cmd == "balance")
 			{
-				ClientGuard g(&c);
-				cout << "Current balance: " << formatBalance(c.postState().balance(us.address())) << " = " << c.postState().balance(us.address()) << " wei" << endl;
+				cout << "Current balance: " << formatBalance( c->balanceAt(us.address())) << " = " <<c->balanceAt(us.address()) << " wei" << endl;
 			}
-			else if (cmd == "transact")
+			else if (c && cmd == "transact")
 			{
-				ClientGuard g(&c);
-				auto const& bc = c.blockChain();
+				auto const& bc =c->blockChain();
 				auto h = bc.currentHash();
 				auto blockData = bc.block(h);
 				BlockInfo info(blockData);
@@ -435,7 +461,7 @@ int main(int argc, char** argv)
 					
 					cnote << "Data:";
 					cnote << sdata;
-					bytes data = parse_data(sdata);
+					bytes data = dev::eth::parseData(sdata);
 					cnote << "Bytes:";
 					string sbd = asString(data);
 					bytes bbd = asBytes(sbd);
@@ -444,16 +470,16 @@ int main(int argc, char** argv)
 					cnote << ssbd.str();
 					int ssize = sechex.length();
 					int size = hexAddr.length();
-					u256 minGas = (u256)c.state().callGas(data.size(), 0);
+					u256 minGas = (u256)Client::txGas(data.size(), 0);
 					if (size < 40)
 					{
 						if (size > 0)
-							cwarn << "Invalid address length: " << size;
+							cwarn << "Invalid address length:" << size;
 					}
 					else if (gasPrice < info.minGasPrice)
-						cwarn << "Minimum gas price is " << info.minGasPrice;
+						cwarn << "Minimum gas price is" << info.minGasPrice;
 					else if (gas < minGas)
-						cwarn << "Minimum gas amount is " << minGas;
+						cwarn << "Minimum gas amount is" << minGas;
 					else if (ssize < 40)
 					{
 						if (ssize > 0)
@@ -463,48 +489,36 @@ int main(int argc, char** argv)
 					{
 						Secret secret = h256(fromHex(sechex));
 						Address dest = h160(fromHex(hexAddr));
-						c.transact(secret, amount, dest, data, gas, gasPrice);
+						c->transact(secret, amount, dest, data, gas, gasPrice);
 					}
 				}
 				else
 					cwarn << "Require parameters: transact ADDRESS AMOUNT GASPRICE GAS SECRET DATA";
 			}
-			else if (cmd == "listContracts")
+			else if (c && cmd == "listContracts")
 			{
-				ClientGuard g(&c);
-				auto const& st = c.state();
-				auto acs = st.addresses();
+				auto acs =c->addresses();
 				string ss;
 				for (auto const& i: acs)
-				{
-					auto r = i.first;
-					if (st.addressHasCode(r))
+					if ( c->codeAt(i, 0).size())
 					{
-						ss = toString(r) + " : " + toString(formatBalance(i.second)) + " [" + toString((unsigned)st.transactionsFrom(i.first)) + "]";
+						ss = toString(i) + " : " + toString( c->balanceAt(i)) + " [" + toString((unsigned) c->countAt(i)) + "]";
 						cout << ss << endl;
 					}
-				}
 			}
-			else if (cmd == "listAccounts")
+			else if (c && cmd == "listAccounts")
 			{
-				ClientGuard g(&c);
-				auto const& st = c.state();
-				auto acs = st.addresses();
+				auto acs =c->addresses();
 				string ss;
 				for (auto const& i: acs)
-				{
-					auto r = i.first;
-					if (!st.addressHasCode(r))
+					if ( c->codeAt(i, 0).empty())
 					{
-						ss = toString(r) + pretty(r, st) + " : " + toString(formatBalance(i.second)) + " [" + toString((unsigned)st.transactionsFrom(i.first)) + "]";
+						ss = toString(i) + " : " + toString( c->balanceAt(i)) + " [" + toString((unsigned) c->countAt(i)) + "]";
 						cout << ss << endl;
 					}
-					
-				}
 			}
-			else if (cmd == "send")
+			else if (c && cmd == "send")
 			{
-				ClientGuard g(&c);
 				if (iss.peek() != -1)
 				{
 					string hexAddr;
@@ -515,31 +529,30 @@ int main(int argc, char** argv)
 					if (size < 40)
 					{
 						if (size > 0)
-							cwarn << "Invalid address length: " << size;
+							cwarn << "Invalid address length:" << size;
 					}
 					else 
 					{
-						auto const& bc = c.blockChain();
+						auto const& bc =c->blockChain();
 						auto h = bc.currentHash();
 						auto blockData = bc.block(h);
 						BlockInfo info(blockData);
-						u256 minGas = (u256)c.state().callGas(0, 0);
+						u256 minGas = (u256)Client::txGas(0, 0);
 						Address dest = h160(fromHex(hexAddr));
-						c.transact(us.secret(), amount, dest, bytes(), minGas, info.minGasPrice);
+						c->transact(us.secret(), amount, dest, bytes(), minGas, info.minGasPrice);
 					}
-					
 				} 
 				else
 					cwarn << "Require parameters: send ADDRESS AMOUNT";
 			}
-			else if (cmd == "contract")
+			else if (c && cmd == "contract")
 			{
-				ClientGuard g(&c);
-				auto const& bc = c.blockChain();
+				auto const& bc =c->blockChain();
 				auto h = bc.currentHash();
 				auto blockData = bc.block(h);
 				BlockInfo info(blockData);
-				if(iss.peek() != -1) {
+				if (iss.peek() != -1)
+				{
 					u256 endowment;
 					u256 gas;
 					u256 gasPrice;
@@ -550,7 +563,7 @@ int main(int argc, char** argv)
 					bytes init;
 					cnote << "Init:";
 					cnote << sinit;
-					cnote << "Code size: " << size;
+					cnote << "Code size:" << size;
 					if (size < 1)
 						cwarn << "No code submitted";
 					else
@@ -563,20 +576,75 @@ int main(int argc, char** argv)
 						cnote << "Init:";
 						cnote << ssc.str();
 					}
-					u256 minGas = (u256)c.state().createGas(init.size(), 0);
+					u256 minGas = (u256)Client::txGas(init.size(), 0);
 					if (endowment < 0)
 						cwarn << "Invalid endowment";
 					else if (gasPrice < info.minGasPrice)
-						cwarn << "Minimum gas price is " << info.minGasPrice;
+						cwarn << "Minimum gas price is" << info.minGasPrice;
 					else if (gas < minGas)
-						cwarn << "Minimum gas amount is " << minGas;
+						cwarn << "Minimum gas amount is" << minGas;
 					else
-						c.transact(us.secret(), endowment, init, gas, gasPrice);
+						c->transact(us.secret(), endowment, init, gas, gasPrice);
 				} 
 				else
 					cwarn << "Require parameters: contract ENDOWMENT GASPRICE GAS CODEHEX";
 			}
-			else if (cmd == "inspect")
+			else if (c && cmd == "dumptrace")
+			{
+				unsigned block;
+				unsigned index;
+				string filename;
+				string format;
+				iss >> block >> index >> filename >> format;
+				ofstream f;
+				f.open(filename);
+
+				dev::eth::State state =c->state(index + 1,c->blockChain().numberHash(block));
+				if (index < state.pending().size())
+				{
+					Executive e(state);
+					Transaction t = state.pending()[index];
+					state = state.fromPending(index);
+					bytes r = t.rlp();
+					e.setup(&r);
+
+					OnOpFunc oof;
+					if (format == "pretty")
+						oof = [&](uint64_t steps, Instruction instr, bigint newMemSize, bigint gasCost, void* vvm, void const* vextVM)
+						{
+							dev::eth::VM* vm = (VM*)vvm;
+							dev::eth::ExtVM const* ext = (ExtVM const*)vextVM;
+							f << endl << "    STACK" << endl;
+							for (auto i: vm->stack())
+								f << (h256)i << endl;
+							f << "    MEMORY" << endl << dev::memDump(vm->memory());
+							f << "    STORAGE" << endl;
+							for (auto const& i: ext->state().storage(ext->myAddress))
+								f << showbase << hex << i.first << ": " << i.second << endl;
+							f << dec << ext->level << " | " << ext->myAddress << " | #" << steps << " | " << hex << setw(4) << setfill('0') << vm->curPC() << " : " << dev::eth::instructionInfo(instr).name << " | " << dec << vm->gas() << " | -" << dec << gasCost << " | " << newMemSize << "x32";
+						};
+					else if (format == "standard")
+						oof = [&](uint64_t, Instruction instr, bigint, bigint, void* vvm, void const* vextVM)
+						{
+							dev::eth::VM* vm = (VM*)vvm;
+							dev::eth::ExtVM const* ext = (ExtVM const*)vextVM;
+							f << ext->myAddress << " " << hex << toHex(dev::toCompactBigEndian(vm->curPC(), 1)) << " " << hex << toHex(dev::toCompactBigEndian((int)(byte)instr, 1)) << " " << hex << toHex(dev::toCompactBigEndian((uint64_t)vm->gas(), 1)) << endl;
+						};
+					else if (format == "standard+")
+						oof = [&](uint64_t, Instruction instr, bigint, bigint, void* vvm, void const* vextVM)
+						{
+							dev::eth::VM* vm = (VM*)vvm;
+							dev::eth::ExtVM const* ext = (ExtVM const*)vextVM;
+							if (instr == Instruction::STOP || instr == Instruction::RETURN || instr == Instruction::SUICIDE)
+								for (auto const& i: ext->state().storage(ext->myAddress))
+									f << toHex(dev::toCompactBigEndian(i.first, 1)) << " " << toHex(dev::toCompactBigEndian(i.second, 1)) << endl;
+							f << ext->myAddress << " " << hex << toHex(dev::toCompactBigEndian(vm->curPC(), 1)) << " " << hex << toHex(dev::toCompactBigEndian((int)(byte)instr, 1)) << " " << hex << toHex(dev::toCompactBigEndian((uint64_t)vm->gas(), 1)) << endl;
+						};
+					e.go(oof);
+					e.finalize(oof);
+				}
+			}
+			else if (c && cmd == "inspect")
 			{
 				string rechex;
 				iss >> rechex;
@@ -585,20 +653,28 @@ int main(int argc, char** argv)
 					cwarn << "Invalid address length";
 				else
 				{
-					ClientGuard g(&c);
 					auto h = h160(fromHex(rechex));
 					stringstream s;
-					auto mem = c.state().storage(h);
 
-					for (auto const& i: mem)
-						s << "@" << showbase << hex << i.first << "    " << showbase << hex << i.second << endl;
-					s << endl << disassemble(c.state().code(h));
+					try
+					{
+						auto storage =c->storageAt(h, 0);
+						for (auto const& i: storage)
+							s << "@" << showbase << hex << i.first << "    " << showbase << hex << i.second << endl;
+						s << endl << disassemble( c->codeAt(h, 0)) << endl;
+
+						string outFile = getDataDir() + "/" + rechex + ".evm";
+						ofstream ofs;
+						ofs.open(outFile, ofstream::binary);
+						ofs.write(s.str().c_str(), s.str().length());
+						ofs.close();
 
-					string outFile = getDataDir() + "/" + rechex + ".evm";
-					ofstream ofs;
-					ofs.open(outFile, ofstream::binary);
-					ofs.write(s.str().c_str(), s.str().length());
-					ofs.close();
+						cnote << "Saved" << rechex << "to" << outFile;
+					}
+					catch (dev::eth::InvalidTrie)
+					{
+						cwarn << "Corrupted trie.";
+					}
 				}
 			}
 			else if (cmd == "setSecret")
@@ -670,75 +746,22 @@ int main(int argc, char** argv)
 			jsonrpcServer->StopListening();
 #endif
 	}
-	else
+	else if (c)
 	{
-		eth::uint n = c.blockChain().details().number;
+		unsigned n =c->blockChain().details().number;
 		if (mining)
-			c.startMining();
+			c->startMining();
 		while (true)
 		{
-			if (c.blockChain().details().number - n == mining)
-				c.stopMining();
+			if ( c->isMining() &&c->blockChain().details().number - n == mining)
+				c->stopMining();
 			this_thread::sleep_for(chrono::milliseconds(100));
 		}
 	}
-
+	else
+		while (true)
+			this_thread::sleep_for(chrono::milliseconds(1000));
 
 	return 0;
 }
 
-bytes parse_data(string _args)
-{
-	bytes m_data;
-	stringstream args(_args);
-	string arg;
-	int cc = 0;
-	while (args >> arg)
-	{
-		int al = arg.length();
-		if (boost::starts_with(arg, "0x"))
-		{
-			bytes bs = fromHex(arg);
-			m_data += bs;
-		}
-		else if (arg[0] == '@')
-		{
-			arg = arg.substr(1, arg.length());
-			if (boost::starts_with(arg, "0x"))
-			{
-				cnote << "hex: " << arg;
-				bytes bs = fromHex(arg);
-				int size = bs.size();
-				if (size < 32)
-					for (auto i = 0; i < 32 - size; ++i)
-						m_data.push_back(0);
-				m_data += bs;
-			}
-			else if (boost::starts_with(arg, "\"") && boost::ends_with(arg, "\""))
-			{
-				arg = arg.substr(1, arg.length() - 2);
-				cnote << "string: " << arg;
-				if (al < 32)
-					for (int i = 0; i < 32 - al; ++i)
-						m_data.push_back(0);
-				for (int i = 0; i < al; ++i)
-					m_data.push_back(arg[i]);
-			}
-			else
-			{
-				cnote << "value: " << arg;
-				bytes bs = toBigEndian(u256(arg));
-				int size = bs.size();
-				if (size < 32)
-					for (auto i = 0; i < 32 - size; ++i)
-						m_data.push_back(0);
-				m_data += bs;
-			}
-		}
-		else
-			for (int i = 0; i < al; ++i)
-				m_data.push_back(arg[i]);
-		cc++;
-	}
-	return m_data;
-}

exp/CMakeLists.txt

@@ -9,6 +9,7 @@ set(EXECUTABLE exp)
 add_executable(${EXECUTABLE} ${SRC_LIST})
 
 target_link_libraries(${EXECUTABLE} ethereum)
+target_link_libraries(${EXECUTABLE} p2p)
 target_link_libraries(${EXECUTABLE} gmp)
 target_link_libraries(${EXECUTABLE} ${CRYPTOPP_LS})
 if(MINIUPNPC_LS)

exp/main.cpp

@@ -19,26 +19,97 @@
  * @date 2014
  * Ethereum client.
  */
-
-#include <libethential/Log.h>
-#include <libethential/Common.h>
-#include <libethential/CommonData.h>
-#include "BuildInfo.h"
+#include <functional>
+#include <libdevcore/Log.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/CommonData.h>
+#include <libdevcore/RLP.h>
+#include <libp2p/All.h>
+#include <libdevcore/RangeMask.h>
+#include <libethereum/DownloadMan.h>
+#include <libwhisper/WhisperPeer.h>
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
+using namespace dev::p2p;
+using namespace dev::shh;
+
+int main()
+{
+	DownloadMan man;
+	DownloadSub s0(man);
+	DownloadSub s1(man);
+	DownloadSub s2(man);
+	man.resetToChain(h256s({u256(0), u256(1), u256(2), u256(3), u256(4), u256(5), u256(6), u256(7), u256(8)}));
+	cnote << s0.nextFetch(2);
+	cnote << s1.nextFetch(2);
+	cnote << s2.nextFetch(2);
+	s0.noteBlock(u256(0));
+	s0.doneFetch();
+	cnote << s0.nextFetch(2);
+	s1.noteBlock(u256(2));
+	s1.noteBlock(u256(3));
+	s1.doneFetch();
+	cnote << s1.nextFetch(2);
+	s0.doneFetch();
+	cnote << s0.nextFetch(2);
+
+/*	RangeMask<unsigned> m(0, 100);
+	cnote << m;
+	m += UnsignedRange(3, 10);
+	cnote << m;
+	m += UnsignedRange(11, 16);
+	cnote << m;
+	m += UnsignedRange(10, 11);
+	cnote << m;
+	cnote << ~m;
+	cnote << (~m).lowest(10);
+	for (auto i: (~m).lowest(10))
+		cnote << i;*/
+	return 0;
+}
 
-int main(int, char**)
+/*
+int main(int argc, char** argv)
 {
-    u256 z = 0;
-    u256 s = 7;
-    u256 ms = z - s;
-    s256 ams = -7;
-    s256 sms = u2s(ms);
-    cnote << sms;
-    cnote << ams;
-    cnote << ms;
-    u256 t = 3;
-    s256 st = u2s(t);
-    cnote << ms << t << (sms % t) << sms << st << (s2u(sms % st) + 70);
+	g_logVerbosity = 20;
+
+	short listenPort = 30303;
+	string remoteHost;
+	short remotePort = 30303;
+
+	for (int i = 1; i < argc; ++i)
+	{
+		string arg = argv[i];
+		if (arg == "-l" && i + 1 < argc)
+			listenPort = (short)atoi(argv[++i]);
+		else if (arg == "-r" && i + 1 < argc)
+			remoteHost = argv[++i];
+		else if (arg == "-p" && i + 1 < argc)
+			remotePort = (short)atoi(argv[++i]);
+		else
+			remoteHost = argv[i];
+	}
+
+	Host ph("Test", NetworkPreferences(listenPort, "", false, true));
+	ph.registerCapability(new WhisperHost());
+	auto wh = ph.cap<WhisperHost>();
+
+	ph.start();
+
+	if (!remoteHost.empty())
+		ph.connect(remoteHost, remotePort);
+
+	/// Only interested in the packet if the lowest bit is 1
+	auto w = wh->installWatch(MessageFilter(std::vector<std::pair<bytes, bytes> >({{fromHex("0000000000000000000000000000000000000000000000000000000000000001"), fromHex("0000000000000000000000000000000000000000000000000000000000000001")}})));
+
+
+	for (int i = 0; ; ++i)
+	{
+		wh->sendRaw(h256(u256(i * i)).asBytes(), h256(u256(i)).asBytes(), 1000);
+		for (auto i: wh->checkWatch(w))
+			cnote << "New message:" << (u256)h256(wh->message(i).payload);
+	}
 	return 0;
 }
+*/

iethxi/CMakeLists.txt

@@ -0,0 +1,117 @@
+cmake_policy(SET CMP0015 NEW)
+
+if ("${TARGET_PLATFORM}" STREQUAL "w64")
+	cmake_policy(SET CMP0020 NEW)
+endif ()
+
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+aux_source_directory(. SRC_LIST)
+
+include_directories(..)
+link_directories(../libethcore)
+link_directories(../libethereum)
+link_directories(../libqethereum)
+
+# Find Qt5 for Apple and update src_list for windows
+if (APPLE)
+	# homebrew defaults to qt4 and installs qt5 as 'keg-only'
+	# which places it into /usr/local/opt insteadof /usr/local.
+
+	set(CMAKE_PREFIX_PATH /usr/local/opt/qt5)
+	include_directories(/usr/local/opt/qt5/include /usr/local/include)
+elseif ("${TARGET_PLATFORM}" STREQUAL "w64")
+	set(SRC_LIST ${SRC_LIST} ../windows/qt_plugin_import.cpp)
+elseif (UNIX)
+    set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ";$ENV{QTDIR}/lib/cmake")
+endif ()
+
+
+find_package(Qt5Widgets REQUIRED)
+find_package(Qt5Gui REQUIRED)
+find_package(Qt5Quick REQUIRED)
+find_package(Qt5Qml REQUIRED)
+find_package(Qt5Network REQUIRED)
+qt5_wrap_ui(ui_Main.h Main.ui)
+qt5_add_resources(RESOURCE_ADDED Resources.qrc)
+
+# Set name of binary and add_executable()
+if (APPLE)
+	set(EXECUTEABLE IEthXi)
+	set(CMAKE_INSTALL_PREFIX ./)
+	set(BIN_INSTALL_DIR ".")
+	set(DOC_INSTALL_DIR ".")
+
+	set(PROJECT_VERSION "${ETH_VERSION}")
+	set(MACOSX_BUNDLE_INFO_STRING "${PROJECT_NAME} ${PROJECT_VERSION}")
+	set(MACOSX_BUNDLE_BUNDLE_VERSION "${PROJECT_NAME} ${PROJECT_VERSION}")
+	set(MACOSX_BUNDLE_LONG_VERSION_STRING "${PROJECT_NAME} ${PROJECT_VERSION}")
+	set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${PROJECT_VERSION}")
+	set(MACOSX_BUNDLE_COPYRIGHT "${PROJECT_COPYRIGHT_YEAR} ${PROJECT_VENDOR}")
+	set(MACOSX_BUNDLE_GUI_IDENTIFIER "${PROJECT_DOMAIN_SECOND}.${PROJECT_DOMAIN_FIRST}")
+	set(MACOSX_BUNDLE_BUNDLE_NAME ${EXECUTEABLE})
+	include(BundleUtilities)
+
+	add_executable(${EXECUTEABLE} MACOSX_BUNDLE Main.ui ${RESOURCE_ADDED} ${SRC_LIST})
+else ()
+	set(EXECUTEABLE iethxi)
+	add_executable(${EXECUTEABLE} Main.ui ${RESOURCE_ADDED} ${SRC_LIST})
+endif ()
+
+qt5_use_modules(${EXECUTEABLE} Core Gui Widgets Network Quick Qml)
+target_link_libraries(${EXECUTEABLE} qethereum ethereum secp256k1 ${CRYPTOPP_LS})
+
+if (APPLE)
+	if (${ADDFRAMEWORKS})
+		set_target_properties(${EXECUTEABLE} PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_SOURCE_DIR}/EthereumMacOSXBundleInfo.plist.in")
+	endif ()
+
+	SET_SOURCE_FILES_PROPERTIES(${EXECUTEABLE} PROPERTIES MACOSX_PACKAGE_LOCATION MacOS)
+
+	# This is a workaround for when the build-type defaults to Debug, and when a multi-config generator like xcode is used, where the type
+	# will not be set but defaults to release.
+	set(generator_lowercase "${CMAKE_GENERATOR}")
+	string(TOLOWER "${CMAKE_GENERATOR}" generator_lowercase)
+	if ("${generator_lowercase}" STREQUAL "xcode")
+		# TODO: Not sure how to resolve this. Possibly \${TARGET_BUILD_DIR}
+		set(binary_build_dir "${CMAKE_CURRENT_BINARY_DIR}/Debug")
+	else ()
+		set(binary_build_dir "${CMAKE_CURRENT_BINARY_DIR}")
+	endif ()
+
+	set(APPS ${binary_build_dir}/${EXECUTEABLE}.app)
+
+	# This tool and the next will automatically looked at the linked libraries in order to determine what dependencies are required. Thus, target_link_libaries only needs to add ethereum and secp256k1 (above)
+	install(CODE "
+		include(BundleUtilities)
+		set(BU_CHMOD_BUNDLE_ITEMS 1)
+                fixup_bundle(\"${APPS}\" \"${BUNDLELIBS}\" \"../libqethereum ../libethereum ../secp256k1\")
+		" COMPONENT RUNTIME )
+
+	if (${ADDFRAMEWORKS})	
+		add_custom_target(addframeworks ALL
+			COMMAND /usr/local/opt/qt5/bin/macdeployqt ${binary_build_dir}/${EXECUTEABLE}.app
+			WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+			DEPENDS ${PROJECT_NAME}
+		)
+	endif ()
+
+elseif ("${TARGET_PLATFORM}" STREQUAL "w64")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-keep-inline-dllexport -static-libgcc -static-libstdc++ -static")
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-s -Wl,-subsystem,windows -mthreads -L/usr/x86_64-w64-mingw32/plugins/platforms")
+	target_link_libraries(${EXECUTEABLE} gcc)
+	target_link_libraries(${EXECUTEABLE} mingw32 qtmain mswsock iphlpapi qwindows shlwapi Qt5PlatformSupport gdi32 comdlg32 oleaut32 imm32 winmm ole32 uuid ws2_32)
+	target_link_libraries(${EXECUTEABLE} boost_system-mt-s)
+	target_link_libraries(${EXECUTEABLE} boost_filesystem-mt-s)
+	target_link_libraries(${EXECUTEABLE} boost_thread_win32-mt-s)
+	target_link_libraries(${EXECUTEABLE} Qt5PlatformSupport)
+	set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
+elseif (UNIX)
+else ()
+	target_link_libraries(${EXECUTEABLE} boost_system)
+	target_link_libraries(${EXECUTEABLE} boost_filesystem)
+	find_package(Threads REQUIRED)
+	target_link_libraries(${EXECUTEABLE} ${CMAKE_THREAD_LIBS_INIT})
+	install( TARGETS ${EXECUTEABLE} RUNTIME DESTINATION bin )
+endif ()
+

iethxi/EthereumMacOSXBundleInfo.plist.in

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
+	<key>CFBundleGetInfoString</key>
+	<string>${MACOSX_BUNDLE_INFO_STRING}</string>
+	<key>CFBundleIconFile</key>
+	<string>${MACOSX_BUNDLE_ICON_FILE}</string>
+	<key>CFBundleIdentifier</key>
+	<string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleLongVersionString</key>
+	<string>${MACOSX_BUNDLE_LONG_VERSION_STRING}</string>
+	<key>CFBundleName</key>
+	<string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>${MACOSX_BUNDLE_BUNDLE_VERSION}</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+	<key>LSRequiresCarbon</key>
+	<true/>
+	<key>NSHumanReadableCopyright</key>
+	<string>${MACOSX_BUNDLE_COPYRIGHT}</string>
+	<key>NSHighResolutionCapable</key>
+	<true/>
+</dict>
+</plist>

iethxi/Main.ui

@@ -0,0 +1,168 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Main</class>
+ <widget class="QMainWindow" name="Main">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>562</width>
+    <height>488</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Walleth</string>
+  </property>
+  <property name="dockNestingEnabled">
+   <bool>true</bool>
+  </property>
+  <property name="dockOptions">
+   <set>QMainWindow::AllowNestedDocks|QMainWindow::AllowTabbedDocks|QMainWindow::VerticalTabs</set>
+  </property>
+  <property name="sizeGripEnabled" stdset="0">
+   <bool>true</bool>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <layout class="QVBoxLayout" name="verticalLayout">
+    <property name="leftMargin">
+     <number>0</number>
+    </property>
+    <property name="topMargin">
+     <number>0</number>
+    </property>
+    <property name="rightMargin">
+     <number>0</number>
+    </property>
+    <property name="bottomMargin">
+     <number>0</number>
+    </property>
+    <item>
+     <layout class="QHBoxLayout" name="fullDisplay">
+      <item>
+       <widget class="QLabel" name="balance">
+        <property name="text">
+         <string>0 wei</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="peerCount">
+        <property name="text">
+         <string>0 peers</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="blockCount">
+        <property name="text">
+         <string>1 block</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>562</width>
+     <height>25</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menu_File">
+    <property name="title">
+     <string>&amp;File</string>
+    </property>
+    <addaction name="quit"/>
+   </widget>
+   <widget class="QMenu" name="menu_Network">
+    <property name="title">
+     <string>&amp;Network</string>
+    </property>
+    <addaction name="upnp"/>
+    <addaction name="net"/>
+    <addaction name="connect"/>
+   </widget>
+   <widget class="QMenu" name="menu_Tools">
+    <property name="title">
+     <string>T&amp;ools</string>
+    </property>
+    <addaction name="mine"/>
+    <addaction name="create"/>
+    <addaction name="preview"/>
+   </widget>
+   <widget class="QMenu" name="menu_Help">
+    <property name="title">
+     <string>&amp;Help</string>
+    </property>
+    <addaction name="about"/>
+   </widget>
+   <addaction name="menu_File"/>
+   <addaction name="menu_Network"/>
+   <addaction name="menu_Tools"/>
+   <addaction name="menu_Help"/>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+  <action name="quit">
+   <property name="text">
+    <string>&amp;Quit</string>
+   </property>
+  </action>
+  <action name="upnp">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="checked">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Use &amp;UPnP</string>
+   </property>
+  </action>
+  <action name="connect">
+   <property name="text">
+    <string>&amp;Connect to Peer...</string>
+   </property>
+  </action>
+  <action name="net">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Enable &amp;Network</string>
+   </property>
+  </action>
+  <action name="mine">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>&amp;Mine</string>
+   </property>
+  </action>
+  <action name="create">
+   <property name="text">
+    <string>&amp;New Address</string>
+   </property>
+  </action>
+  <action name="about">
+   <property name="text">
+    <string>&amp;About...</string>
+   </property>
+  </action>
+  <action name="preview">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>&amp;Preview</string>
+   </property>
+  </action>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources/>
+ <connections/>
+</ui>

iethxi/MainWin.cpp

@@ -0,0 +1,59 @@
+#include <QtNetwork/QNetworkReply>
+#include <QtQuick/QQuickView>
+#include <QtQml/QQmlContext>
+#include <QtQml/QQmlEngine>
+#include <QtQml/QtQml>
+#include <QtWidgets/QMessageBox>
+#include <QtWidgets/QInputDialog>
+#include <QtGui/QClipboard>
+#include <QtCore/QtCore>
+#include <libethcore/FileSystem.h>
+#include <libethcore/Dagger.h>
+#include <libevmface/Instruction.h>
+#include <libethereum/Client.h>
+#include <libethereum/EthereumHost.h>
+#include "BuildInfo.h"
+#include "MainWin.h"
+#include "ui_Main.h"
+using namespace std;
+using namespace eth;
+
+Main::Main(QWidget *parent) :
+	QObject(parent)
+{
+/*	qRegisterMetaType<eth::u256>("eth::u256");
+	qRegisterMetaType<eth::KeyPair>("eth::KeyPair");
+	qRegisterMetaType<eth::Secret>("eth::Secret");
+	qRegisterMetaType<eth::Address>("eth::Address");
+	qRegisterMetaType<QmlAccount*>("QmlAccount*");
+	qRegisterMetaType<QmlEthereum*>("QmlEthereum*");
+
+	qmlRegisterType<QmlEthereum>("org.ethereum", 1, 0, "Ethereum");
+	qmlRegisterType<QmlAccount>("org.ethereum", 1, 0, "Account");
+	qmlRegisterSingletonType<QmlU256Helper>("org.ethereum", 1, 0, "Balance", QmlEthereum::constructU256Helper);
+	qmlRegisterSingletonType<QmlKeyHelper>("org.ethereum", 1, 0, "Key", QmlEthereum::constructKeyHelper);
+*/
+	/*
+	ui->librariesView->setModel(m_libraryMan);
+	ui->graphsView->setModel(m_graphMan);
+	*/
+
+
+
+
+//	QQmlContext* context = m_view->rootContext();
+//	context->setContextProperty("u256", new U256Helper(this));
+}
+
+Main::~Main()
+{
+}
+
+// extra bits needed to link on VS
+#ifdef _MSC_VER
+
+// include moc file, ofuscated to hide from automoc
+#include\
+"moc_MainWin.cpp"
+
+#endif

iethxi/MainWin.h

@@ -0,0 +1,18 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+#include <QtQml/QQmlApplicationEngine>
+
+class Main: public QObject
+{
+	Q_OBJECT
+	
+public:
+	explicit Main(QWidget *parent = 0);
+	~Main();
+
+private:
+	QQmlApplicationEngine* m_view;
+};
+
+#endif // MAIN_H

iethxi/Resources.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/">
+        <file>Simple.qml</file>
+    </qresource>
+</RCC>

iethxi/Simple.qml

@@ -0,0 +1,9 @@
+import QtQuick.Controls 1.1
+
+ApplicationWindow {
+    title: "My App"
+    Button {
+        text: "Push Me"
+        anchors.centerIn: parent
+    }
+}

iethxi/main.cpp

@@ -0,0 +1,9 @@
+#include <QtQml/QQmlApplicationEngine>
+#include <QtWidgets/QApplication>
+
+int main(int argc, char *argv[])
+{
+	QApplication a(argc, argv);
+	QQmlApplicationEngine app(QUrl("qrc:/Simple.qml"));
+	return a.exec();
+}

libethential/CMakeLists.txt → libdevcore/CMakeLists.txt

@@ -8,7 +8,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSTATICLIB")
 
 aux_source_directory(. SRC_LIST)
 
-set(EXECUTABLE ethential)
+set(EXECUTABLE devcore)
 
 # set(CMAKE_INSTALL_PREFIX ../lib)
 if(ETH_STATIC)
@@ -20,7 +20,7 @@ file(GLOB HEADERS "*.h")
 
 include_directories(..)
 
-target_link_libraries(${EXECUTABLE} ethential)
+target_link_libraries(${EXECUTABLE} devcore)
 
 if("${TARGET_PLATFORM}" STREQUAL "w64")
 	include_directories(/usr/x86_64-w64-mingw32/include/cryptopp)

libethential/Common.cpp → libdevcore/Common.cpp

@@ -22,11 +22,12 @@
 #include "Common.h"
 
 using namespace std;
-using namespace eth;
+using namespace dev;
 
-namespace eth
+namespace dev
 {
 
-char const* EthVersion = "0.5.18";
+char const* Version = "0.6.9";
 
 }
+

libethential/Common.h → libdevcore/Common.h

@@ -23,7 +23,7 @@
 
 #pragma once
 
-// way to many uint to size_t warnings in 32 bit build
+// way to many unsigned to size_t warnings in 32 bit build
 #ifdef _M_IX86
 #pragma warning(disable:4244)
 #endif
@@ -43,13 +43,13 @@
 using byte = uint8_t;
 
 // Quote a given token stream to turn it into a string.
-#define ETH_QUOTED_HELPER(s) #s
-#define ETH_QUOTED(s) ETH_QUOTED_HELPER(s)
+#define DEV_QUOTED_HELPER(s) #s
+#define DEV_QUOTED(s) DEV_QUOTED_HELPER(s)
 
-namespace eth
+namespace dev
 {
 
-extern char const* EthVersion;
+extern char const* Version;
 
 // Binary data types.
 using bytes = std::vector<byte>;
@@ -62,8 +62,6 @@ using u256 =  boost::multiprecision::number<boost::multiprecision::cpp_int_backe
 using s256 =  boost::multiprecision::number<boost::multiprecision::cpp_int_backend<256, 256, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>>;
 using u160 =  boost::multiprecision::number<boost::multiprecision::cpp_int_backend<160, 160, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>;
 using s160 =  boost::multiprecision::number<boost::multiprecision::cpp_int_backend<160, 160, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void>>;
-using uint = uint64_t;
-using sint = int64_t;
 using u256s = std::vector<u256>;
 using u160s = std::vector<u160>;
 using u256Set = std::set<u256>;
@@ -98,4 +96,11 @@ inline u256 s2u(s256 _u)
         return (u256)(c_end + _u);
 }
 
+inline unsigned int toLog2(u256 _x)
+{
+	unsigned ret;
+	for (ret = 0; _x >>= 1; ++ret) {}
+	return ret;
+}
+
 }

libdevcore/CommonData.cpp

@@ -0,0 +1,282 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file Common.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "CommonData.h"
+
+#include <random>
+#include "Exceptions.h"
+using namespace std;
+using namespace dev;
+
+std::string dev::escaped(std::string const& _s, bool _all)
+{
+	std::string ret;
+	ret.reserve(_s.size());
+	ret.push_back('"');
+	for (auto i: _s)
+		if (i == '"' && !_all)
+			ret += "\\\"";
+		else if (i == '\\' && !_all)
+			ret += "\\\\";
+		else if (i < ' ' || _all)
+		{
+			ret += "\\x";
+			ret.push_back("0123456789abcdef"[(uint8_t)i / 16]);
+			ret.push_back("0123456789abcdef"[(uint8_t)i % 16]);
+		}
+		else
+			ret.push_back(i);
+	ret.push_back('"');
+	return ret;
+}
+
+std::string dev::randomWord()
+{
+	static std::mt19937_64 s_eng(0);
+	std::string ret(std::uniform_int_distribution<int>(1, 5)(s_eng), ' ');
+	char const n[] = "qwertyuiop";//asdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
+	std::uniform_int_distribution<int> d(0, sizeof(n) - 2);
+	for (char& c: ret)
+		c = n[d(s_eng)];
+	return ret;
+}
+
+int dev::fromHex(char _i)
+{
+	if (_i >= '0' && _i <= '9')
+		return _i - '0';
+	if (_i >= 'a' && _i <= 'f')
+		return _i - 'a' + 10;
+	if (_i >= 'A' && _i <= 'F')
+		return _i - 'A' + 10;
+	throw BadHexCharacter();
+}
+
+bytes dev::fromHex(std::string const& _s)
+{
+	unsigned s = (_s[0] == '0' && _s[1] == 'x') ? 2 : 0;
+	std::vector<uint8_t> ret;
+	ret.reserve((_s.size() - s + 1) / 2);
+
+	if (_s.size() % 2)
+		try
+		{
+			ret.push_back(fromHex(_s[s++]));
+		}
+		catch (...){ ret.push_back(0); }
+	for (unsigned i = s; i < _s.size(); i += 2)
+		try
+		{
+			ret.push_back((byte)(fromHex(_s[i]) * 16 + fromHex(_s[i + 1])));
+		}
+		catch (...){ ret.push_back(0); }
+	return ret;
+}
+
+bytes dev::asNibbles(std::string const& _s)
+{
+	std::vector<uint8_t> ret;
+	ret.reserve(_s.size() * 2);
+	for (auto i: _s)
+	{
+		ret.push_back(i / 16);
+		ret.push_back(i % 16);
+	}
+	return ret;
+}
+
+#if 0
+
+/* Following code is copyright 2012-2014 Luke Dashjr
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the standard MIT license.  See COPYING for more details.
+ */
+
+#include <cstdbool>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+static const int8_t b58digits_map[] = {
+	-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,
+	-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,
+	-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,
+	-1, 0, 1, 2, 3, 4, 5, 6,  7, 8,-1,-1,-1,-1,-1,-1,
+	-1, 9,10,11,12,13,14,15, 16,-1,17,18,19,20,21,-1,
+	22,23,24,25,26,27,28,29, 30,31,32,-1,-1,-1,-1,-1,
+	-1,33,34,35,36,37,38,39, 40,41,42,43,-1,44,45,46,
+	47,48,49,50,51,52,53,54, 55,56,57,-1,-1,-1,-1,-1,
+};
+
+bool b58tobin(void *bin, size_t *binszp, const char *b58, size_t b58sz)
+{
+	size_t binsz = *binszp;
+	const unsigned char *b58u = (void*)b58;
+	unsigned char *binu = bin;
+	size_t outisz = (binsz + 3) / 4;
+	uint32_t outi[outisz];
+	uint64_t t;
+	uint32_t c;
+	size_t i, j;
+	uint8_t bytesleft = binsz % 4;
+	uint32_t zeromask = bytesleft ? (0xffffffff << (bytesleft * 8)) : 0;
+	unsigned zerocount = 0;
+
+	if (!b58sz)
+		b58sz = strlen(b58);
+
+	memset(outi, 0, outisz * sizeof(*outi));
+
+	// Leading zeros, just count
+	for (i = 0; i < b58sz && !b58digits_map[b58u[i]]; ++i)
+		++zerocount;
+
+	for ( ; i < b58sz; ++i)
+	{
+		if (b58u[i] & 0x80)
+			// High-bit set on invalid digit
+			return false;
+		if (b58digits_map[b58u[i]] == -1)
+			// Invalid base58 digit
+			return false;
+		c = (unsigned)b58digits_map[b58u[i]];
+		for (j = outisz; j--; )
+		{
+			t = ((uint64_t)outi[j]) * 58 + c;
+			c = (t & 0x3f00000000) >> 32;
+			outi[j] = t & 0xffffffff;
+		}
+		if (c)
+			// Output number too big (carry to the next int32)
+			return false;
+		if (outi[0] & zeromask)
+			// Output number too big (last int32 filled too far)
+			return false;
+	}
+
+	j = 0;
+	switch (bytesleft) {
+		case 3:
+			*(binu++) = (outi[0] &   0xff0000) >> 16;
+		case 2:
+			*(binu++) = (outi[0] &     0xff00) >>  8;
+		case 1:
+			*(binu++) = (outi[0] &       0xff);
+			++j;
+		default:
+			break;
+	}
+
+	for (; j < outisz; ++j)
+	{
+		*(binu++) = (outi[j] >> 0x18) & 0xff;
+		*(binu++) = (outi[j] >> 0x10) & 0xff;
+		*(binu++) = (outi[j] >>    8) & 0xff;
+		*(binu++) = (outi[j] >>    0) & 0xff;
+	}
+
+	// Count canonical base58 byte count
+	binu = bin;
+	for (i = 0; i < binsz; ++i)
+	{
+		if (binu[i])
+			break;
+		--*binszp;
+	}
+	*binszp += zerocount;
+
+	return true;
+}
+
+static
+bool my_dblsha256(void *hash, const void *data, size_t datasz)
+{
+	uint8_t buf[0x20];
+	return b58_sha256_impl(buf, data, datasz) && b58_sha256_impl(hash, buf, sizeof(buf));
+}
+
+int b58check(const void *bin, size_t binsz, const char *base58str, size_t b58sz)
+{
+	unsigned char buf[32];
+	const uint8_t *binc = bin;
+	unsigned i;
+	if (binsz < 4)
+		return -4;
+	if (!my_dblsha256(buf, bin, binsz - 4))
+		return -2;
+	if (memcmp(&binc[binsz - 4], buf, 4))
+		return -1;
+
+	// Check number of zeros is correct AFTER verifying checksum (to avoid possibility of accessing base58str beyond the end)
+	for (i = 0; binc[i] == '\0' && base58str[i] == '1'; ++i)
+	{}  // Just finding the end of zeros, nothing to do in loop
+	if (binc[i] == '\0' || base58str[i] == '1')
+		return -3;
+
+	return binc[0];
+}
+
+static const char b58digits_ordered[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+bool b58enc(char *b58, size_t *b58sz, const void *data, size_t binsz)
+{
+	const uint8_t *bin = data;
+	int carry;
+	size_t i, j, high, zcount = 0;
+	size_t size;
+
+	while (zcount < binsz && !bin[zcount])
+		++zcount;
+
+	size = (binsz - zcount) * 138 / 100 + 1;
+	uint8_t buf[size];
+	memset(buf, 0, size);
+
+	for (i = zcount, high = size - 1; i < binsz; ++i, high = j)
+	{
+		for (carry = bin[i], j = size - 1; (j > high) || carry; --j)
+		{
+			carry += 256 * buf[j];
+			buf[j] = carry % 58;
+			carry /= 58;
+		}
+	}
+
+	for (j = 0; j < size && !buf[j]; ++j);
+
+	if (*b58sz <= zcount + size - j)
+	{
+		*b58sz = zcount + size - j + 1;
+		return false;
+	}
+
+	if (zcount)
+		memset(b58, '1', zcount);
+	for (i = zcount; j < size; ++i, ++j)
+		b58[i] = b58digits_ordered[buf[j]];
+	b58[i] = '\0';
+	*b58sz = i + 1;
+
+	return true;
+}
+
+#endif

libethential/CommonData.h → libdevcore/CommonData.h

@@ -30,7 +30,7 @@
 #include <string>
 #include "Common.h"
 
-namespace eth
+namespace dev
 {
 
 // String conversion functions, mainly to/from hex/nibble/byte representations.
@@ -55,6 +55,11 @@ int fromHex(char _i);
 /// @example fromHex("41626261") == asBytes("Abba")
 bytes fromHex(std::string const& _s);
 
+#if 0
+std::string toBase58(bytesConstRef _data);
+bytes fromBase58(std::string const& _s);
+#endif
+
 /// Converts byte array to a string containing the same (binary) data. Unless
 /// the byte array happens to contain ASCII data, this won't be printable.
 inline std::string asString(bytes const& _b)
@@ -79,7 +84,7 @@ bytes asNibbles(std::string const& _s);
 /// The size of the collection object will be unchanged. If it is too small, it will not represent the
 /// value properly, if too big then the additional elements will be zeroed out.
 /// @a _Out will typically be either std::string or bytes.
-/// @a _T will typically by uint, u160, u256 or bigint.
+/// @a _T will typically by unsigned, u160, u256 or bigint.
 template <class _T, class _Out>
 inline void toBigEndian(_T _val, _Out& o_out)
 {
@@ -89,7 +94,7 @@ inline void toBigEndian(_T _val, _Out& o_out)
 
 /// Converts a big-endian byte-stream represented on a templated collection to a templated integer value.
 /// @a _In will typically be either std::string or bytes.
-/// @a _T will typically by uint, u160, u256 or bigint.
+/// @a _T will typically by unsigned, u160, u256 or bigint.
 template <class _T, class _In>
 inline _T fromBigEndian(_In const& _bytes)
 {
@@ -140,10 +145,10 @@ std::string escaped(std::string const& _s, bool _all = true);
 /// @returns the number of elements both @a _t and @a _u share, in order, at the beginning.
 /// @example commonPrefix("Hello world!", "Hello, world!") == 5
 template <class _T, class _U>
-uint commonPrefix(_T const& _t, _U const& _u)
+unsigned commonPrefix(_T const& _t, _U const& _u)
 {
-	uint s = std::min<uint>(_t.size(), _u.size());
-	for (uint i = 0;; ++i)
+	unsigned s = std::min<unsigned>(_t.size(), _u.size());
+	for (unsigned i = 0;; ++i)
 		if (i == s || _t[i] != _u[i])
 			return i;
 	return s;
@@ -157,9 +162,9 @@ std::string randomWord();
 
 /// Determine bytes required to encode the given integer value. @returns 0 if @a _i is zero.
 template <class _T>
-inline uint bytesRequired(_T _i)
+inline unsigned bytesRequired(_T _i)
 {
-	uint i = 0;
+	unsigned i = 0;
 	for (; _i != 0; ++i, _i >>= 8) {}
 	return i;
 }
@@ -167,7 +172,7 @@ inline uint bytesRequired(_T _i)
 /// Trims a given number of elements from the front of a collection.
 /// Only works for POD element types.
 template <class _T>
-void trimFront(_T& _t, uint _elements)
+void trimFront(_T& _t, unsigned _elements)
 {
 	static_assert(std::is_pod<typename _T::value_type>::value, "");
 	memmove(_t.data(), _t.data() + _elements, (_t.size() - _elements) * sizeof(_t[0]));

libethential/CommonIO.cpp → libdevcore/CommonIO.cpp

@@ -24,9 +24,9 @@
 #include <fstream>
 #include "Exceptions.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
 
-string eth::memDump(bytes const& _b, unsigned _w, bool _html)
+string dev::memDump(bytes const& _b, unsigned _w, bool _html)
 {
 	stringstream ret;
 	if (_html)
@@ -36,7 +36,7 @@ string eth::memDump(bytes const& _b, unsigned _w, bool _html)
 		ret << hex << setw(4) << setfill('0') << i << " ";
 		for (unsigned j = i; j < i + _w; ++j)
 			if (j < _b.size())
-				if (_b[j] >= 32 && _b[j] < 128)
+				if (_b[j] >= 32 && _b[j] < 127)
 					if ((char)_b[j] == '<' && _html)
 						ret << "&lt;";
 					else if ((char)_b[j] == '&' && _html)
@@ -57,7 +57,7 @@ string eth::memDump(bytes const& _b, unsigned _w, bool _html)
 	return ret.str();
 }
 
-bytes eth::contents(std::string const& _file)
+bytes dev::contents(std::string const& _file)
 {
 	std::ifstream is(_file, std::ifstream::binary);
 	if (!is)
@@ -72,7 +72,7 @@ bytes eth::contents(std::string const& _file)
 	return ret;
 }
 
-void eth::writeFile(std::string const& _file, bytes const& _data)
+void dev::writeFile(std::string const& _file, bytes const& _data)
 {
 	ofstream(_file, ios::trunc).write((char const*)_data.data(), _data.size());
 }

libethential/CommonIO.h → libdevcore/CommonIO.h

@@ -37,7 +37,7 @@
 #include <iostream>
 #include "Common.h"
 
-namespace eth
+namespace dev
 {
 
 /// Retrieve and returns the contents of the given file. If the file doesn't exist or isn't readable, returns an empty bytes.
@@ -49,15 +49,6 @@ void writeFile(std::string const& _file, bytes const& _data);
 /// Nicely renders the given bytes to a string, optionally as HTML.
 std::string memDump(bytes const& _b, unsigned _w = 8, bool _html = false);
 
-/// Converts arbitrary value to string representation using std::stringstream.
-template <class _T>
-std::string toString(_T const& _t)
-{
-	std::ostringstream o;
-	o << _t;
-	return o.str();
-}
-
 // Stream I/O functions.
 // Provides templated stream I/O for all STL collections so they can be shifted on to any iostream-like interface.
 
@@ -223,4 +214,15 @@ template <class T, class U> inline std::ostream& operator<<(std::ostream& _out,
 
 template <class _S, class _T> _S& operator<<(_S& _out, std::shared_ptr<_T> const& _p) { if (_p) _out << "@" << (*_p); else _out << "nullptr"; return _out; }
 
+// Functions that use streaming stuff.
+
+/// Converts arbitrary value to string representation using std::stringstream.
+template <class _T>
+std::string toString(_T const& _t)
+{
+	std::ostringstream o;
+	o << _t;
+	return o.str();
+}
+
 }

libethential/Exceptions.h → libdevcore/Exceptions.h

@@ -26,7 +26,7 @@
 #include "CommonData.h"
 #include "FixedHash.h"
 
-namespace eth
+namespace dev
 {
 
 class Exception: public std::exception

libdevcore/FixedHash.cpp

@@ -0,0 +1,28 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file FixedHash.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include <ctime>
+#include "FixedHash.h"
+
+using namespace std;
+using namespace dev;
+
+std::mt19937_64 dev::s_fixedHashEngine(time(0));

libethential/FixedHash.h → libdevcore/FixedHash.h

@@ -28,9 +28,11 @@
 #include <algorithm>
 #include "CommonData.h"
 
-namespace eth
+namespace dev
 {
 
+extern std::mt19937_64 s_fixedHashEngine;
+
 /// Fixed-size raw-byte array container type, with an API optimised for storing hashes.
 /// Transparently converts to/from the corresponding arithmetic type; this will
 /// assume the data contained in the hash is big-endian.
@@ -63,13 +65,13 @@ public:
 	FixedHash(Arith const& _arith) { toBigEndian(_arith, m_data); }
 
 	/// Explicitly construct, copying from a byte array.
-	explicit FixedHash(bytes const& _b) { if (_b.size() == N) memcpy(m_data.data(), _b.data(), std::min<uint>(_b.size(), N)); }
+	explicit FixedHash(bytes const& _b) { if (_b.size() == N) memcpy(m_data.data(), _b.data(), std::min<unsigned>(_b.size(), N)); }
 
 	/// Explicitly construct, copying from a bytes in memory with given pointer.
 	explicit FixedHash(byte const* _bs, ConstructFromPointerType) { memcpy(m_data.data(), _bs, N); }
 
 	/// Explicitly construct, copying from a  string.
-	explicit FixedHash(std::string const& _s, ConstructFromStringType _t = FromHex): FixedHash(_t == FromHex ? fromHex(_s) : eth::asBytes(_s)) {}
+	explicit FixedHash(std::string const& _s, ConstructFromStringType _t = FromHex): FixedHash(_t == FromHex ? fromHex(_s) : dev::asBytes(_s)) {}
 
 	/// Convert to arithmetic type.
 	operator Arith() const { return fromBigEndian<Arith>(m_data); }
@@ -83,13 +85,13 @@ public:
 	bool operator<(FixedHash const& _c) const { return m_data < _c.m_data; }
 
 	// The obvious binary operators.
-	FixedHash& operator^=(FixedHash const& _c) { for (auto i = 0; i < N; ++i) m_data[i] ^= _c.m_data[i]; return *this; }
+	FixedHash& operator^=(FixedHash const& _c) { for (unsigned i = 0; i < N; ++i) m_data[i] ^= _c.m_data[i]; return *this; }
 	FixedHash operator^(FixedHash const& _c) const { return FixedHash(*this) ^= _c; }
-	FixedHash& operator|=(FixedHash const& _c) { for (auto i = 0; i < N; ++i) m_data[i] |= _c.m_data[i]; return *this; }
+	FixedHash& operator|=(FixedHash const& _c) { for (unsigned i = 0; i < N; ++i) m_data[i] |= _c.m_data[i]; return *this; }
 	FixedHash operator|(FixedHash const& _c) const { return FixedHash(*this) |= _c; }
-	FixedHash& operator&=(FixedHash const& _c) { for (auto i = 0; i < N; ++i) m_data[i] &= _c.m_data[i]; return *this; }
+	FixedHash& operator&=(FixedHash const& _c) { for (unsigned i = 0; i < N; ++i) m_data[i] &= _c.m_data[i]; return *this; }
 	FixedHash operator&(FixedHash const& _c) const { return FixedHash(*this) &= _c; }
-	FixedHash& operator~() { for (auto i = 0; i < N; ++i) m_data[i] = ~m_data[i]; return *this; }
+	FixedHash& operator~() { for (unsigned i = 0; i < N; ++i) m_data[i] = ~m_data[i]; return *this; }
 
 	/// @returns true if all bytes in @a _c are set in this object.
 	bool contains(FixedHash const& _c) const { return (*this & _c) == _c; }
@@ -100,7 +102,7 @@ public:
 	byte operator[](unsigned _i) const { return m_data[_i]; }
 
 	/// @returns an abridged version of the hash as a user-readable hex string.
-	std::string abridged() const { return toHex(ref().cropped(0, 4)) + ".."; }
+	std::string abridged() const { return toHex(ref().cropped(0, 4)) + "\342\200\246"; }
 
 	/// @returns a mutable byte vector_ref to the object's data.
 	bytesRef ref() { return bytesRef(m_data.data(), N); }
@@ -133,6 +135,8 @@ public:
 		return ret;
 	}
 
+	static FixedHash random() { return random(s_fixedHashEngine); }
+
 	/// A generic std::hash compatible function object.
 	struct hash
 	{
@@ -154,16 +158,14 @@ public:
 		return ret;
 	}
 
-
 private:
 	std::array<byte, N> m_data;		///< The binary data.
 };
 
-
 /// Fast equality operator for h256.
 template<> inline bool FixedHash<32>::operator==(FixedHash<32> const& _other) const
 {
-	const uint64_t* hash1 = (const uint64_t*)this->data();
+	const uint64_t* hash1 = (const uint64_t*)data();
 	const uint64_t* hash2 = (const uint64_t*)_other.data();
 	return (hash1[0] == hash2[0]) && (hash1[1] == hash2[1]) && (hash1[2] == hash2[2]) && (hash1[3] == hash2[3]);
 }
@@ -215,10 +217,20 @@ inline h160 left160(h256 const& _t)
 	return ret;
 }
 
+inline std::string toString(h256s const& _bs)
+{
+	std::ostringstream out;
+	out << "[ ";
+	for (auto i: _bs)
+		out << i.abridged() << ", ";
+	out << "]";
+	return out.str();
+}
+
 }
 
 namespace std
 {
-	/// Forward std::hash<eth::h256> to eth::h256::hash.
-	template<> struct hash<eth::h256>: eth::h256::hash {};
+	/// Forward std::hash<dev::h256> to dev::h256::hash.
+	template<> struct hash<dev::h256>: dev::h256::hash {};
 }

libethential/FixedHash.cpp → libdevcore/Guards.cpp

@@ -14,12 +14,16 @@
 	You should have received a copy of the GNU General Public License
 	along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
 */
-/** @file FixedHash.cpp
+/** @file Guards.cpp
  * @author Gav Wood <i@gavwood.com>
  * @date 2014
  */
 
-#include "FixedHash.h"
-
+#include "Guards.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+
+namespace dev
+{
+
+}

libdevcore/Guards.h

@@ -0,0 +1,41 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file Guards.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#pragma once
+
+#include <mutex>
+#include <boost/thread.hpp>
+
+namespace dev
+{
+
+using Mutex = std::mutex;
+using RecursiveMutex = std::recursive_mutex;
+using SharedMutex = boost::shared_mutex;
+
+using Guard = std::lock_guard<std::mutex>;
+using RecursiveGuard = std::lock_guard<std::recursive_mutex>;
+using ReadGuard = boost::shared_lock<boost::shared_mutex>;
+using UpgradableGuard = boost::upgrade_lock<boost::shared_mutex>;
+using UpgradeGuard = boost::upgrade_to_unique_lock<boost::shared_mutex>;
+using WriteGuard = boost::unique_lock<boost::shared_mutex>;
+
+}

libethential/Log.cpp → libdevcore/Log.cpp

@@ -23,22 +23,26 @@
 
 #include <string>
 #include <iostream>
+#include "Guards.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
 
 // Logging
-int eth::g_logVerbosity = 5;
-map<type_info const*, bool> eth::g_logOverride;
+int dev::g_logVerbosity = 5;
+map<type_info const*, bool> dev::g_logOverride;
 
-ThreadLocalLogName eth::t_logThreadName("main");
+ThreadLocalLogName dev::t_logThreadName("main");
 
 // foward declare without all of Windows.h
 #ifdef _WIN32
 extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char* lpOutputString);
 #endif
 
-void eth::simpleDebugOut(std::string const& _s, char const*)
+void dev::simpleDebugOut(std::string const& _s, char const*)
 {
+	static Mutex s_lock;
+	Guard l(s_lock);
+
 	cout << _s << endl << flush;
 
 	// helpful to use OutputDebugString on windows
@@ -50,5 +54,5 @@ void eth::simpleDebugOut(std::string const& _s, char const*)
 	#endif
 }
 
-std::function<void(std::string const&, char const*)> eth::g_logPost = simpleDebugOut;
+std::function<void(std::string const&, char const*)> dev::g_logPost = simpleDebugOut;
 

libethential/Log.h → libdevcore/Log.h

@@ -28,7 +28,7 @@
 #include <boost/thread.hpp>
 #include "vector_ref.h"
 
-namespace eth
+namespace dev
 {
 
 /// The null output stream. Used when logging is disabled.
@@ -39,7 +39,7 @@ public:
 };
 
 /// A simple log-output function that prints log messages to stdout.
-void simpleDebugOut(std::string const&, char const* );
+void simpleDebugOut(std::string const&, char const*);
 
 /// The logging system's current verbosity.
 extern int g_logVerbosity;
@@ -107,19 +107,19 @@ private:
 
 // Simple cout-like stream objects for accessing common log channels.
 // Dirties the global namespace, but oh so convenient...
-#define cnote eth::LogOutputStream<eth::NoteChannel, true>()
-#define cwarn eth::LogOutputStream<eth::WarnChannel, true>()
+#define cnote dev::LogOutputStream<dev::NoteChannel, true>()
+#define cwarn dev::LogOutputStream<dev::WarnChannel, true>()
 
 // Null stream-like objects.
-#define ndebug if (true) {} else eth::NullOutputStream()
-#define nlog(X) if (true) {} else eth::NullOutputStream()
-#define nslog(X) if (true) {} else eth::NullOutputStream()
+#define ndebug if (true) {} else dev::NullOutputStream()
+#define nlog(X) if (true) {} else dev::NullOutputStream()
+#define nslog(X) if (true) {} else dev::NullOutputStream()
 
 // Kill debugging log channel when we're in release mode.
 #if NDEBUG
 #define cdebug ndebug
 #else
-#define cdebug eth::LogOutputStream<eth::DebugChannel, true>()
+#define cdebug dev::LogOutputStream<dev::DebugChannel, true>()
 #endif
 
 // Kill all logs when when NLOG is defined.
@@ -127,8 +127,8 @@ private:
 #define clog(X) nlog(X)
 #define cslog(X) nslog(X)
 #else
-#define clog(X) eth::LogOutputStream<X, true>()
-#define cslog(X) eth::LogOutputStream<X, false>()
+#define clog(X) dev::LogOutputStream<X, true>()
+#define cslog(X) dev::LogOutputStream<X, false>()
 #endif
 
 }

libethential/RLP.cpp → libdevcore/RLP.cpp

@@ -21,10 +21,10 @@
 
 #include "RLP.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
 
-bytes eth::RLPNull = rlp("");
-bytes eth::RLPEmptyList = rlpList();
+bytes dev::RLPNull = rlp("");
+bytes dev::RLPEmptyList = rlpList();
 
 RLP::iterator& RLP::iterator::operator++()
 {
@@ -32,7 +32,7 @@ RLP::iterator& RLP::iterator::operator++()
 	{
 		m_lastItem.retarget(m_lastItem.next().data(), m_remaining);
 		m_lastItem = m_lastItem.cropped(0, RLP(m_lastItem).actualSize());
-		m_remaining -= std::min<uint>(m_remaining, m_lastItem.size());
+		m_remaining -= std::min<unsigned>(m_remaining, m_lastItem.size());
 	}
 	else
 		m_lastItem.retarget(m_lastItem.next().data(), 0);
@@ -54,7 +54,7 @@ RLP::iterator::iterator(RLP const& _parent, bool _begin)
 	}
 }
 
-RLP RLP::operator[](uint _i) const
+RLP RLP::operator[](unsigned _i) const
 {
 	if (_i < m_lastIndex)
 	{
@@ -81,7 +81,7 @@ RLPs RLP::toList() const
 	return ret;
 }
 
-eth::uint RLP::actualSize() const
+unsigned RLP::actualSize() const
 {
 	if (isNull())
 		return 0;
@@ -118,11 +118,11 @@ bool RLP::isInt() const
 	return false;
 }
 
-eth::uint RLP::length() const
+unsigned RLP::length() const
 {
 	if (isNull())
 		return 0;
-	uint ret = 0;
+	unsigned ret = 0;
 	byte n = m_data[0];
 	if (n < c_rlpDataImmLenStart)
 		return 1;
@@ -147,12 +147,12 @@ eth::uint RLP::length() const
 	return ret;
 }
 
-eth::uint RLP::items() const
+unsigned RLP::items() const
 {
 	if (isList())
 	{
 		bytesConstRef d = payload().cropped(0, length());
-		eth::uint i = 0;
+		unsigned i = 0;
 		for (; d.size(); ++i)
 			d = d.cropped(RLP(d).actualSize());
 		return i;
@@ -160,16 +160,16 @@ eth::uint RLP::items() const
 	return 0;
 }
 
-RLPStream& RLPStream::appendRaw(bytesConstRef _s, uint _itemCount)
+RLPStream& RLPStream::appendRaw(bytesConstRef _s, unsigned _itemCount)
 {
-	uint os = m_out.size();
+	unsigned os = m_out.size();
 	m_out.resize(os + _s.size());
 	memcpy(m_out.data() + os, _s.data(), _s.size());
 	noteAppended(_itemCount);
 	return *this;
 }
 
-void RLPStream::noteAppended(uint _itemCount)
+void RLPStream::noteAppended(unsigned _itemCount)
 {
 	if (!_itemCount)
 		return;
@@ -184,9 +184,9 @@ void RLPStream::noteAppended(uint _itemCount)
 		{
 			auto p = m_listStack.back().second;
 			m_listStack.pop_back();
-			uint s = m_out.size() - p;		// list size
+			unsigned s = m_out.size() - p;		// list size
 			auto brs = bytesRequired(s);
-			uint encodeSize = s < c_rlpListImmLenCount ? 1 : (1 + brs);
+			unsigned encodeSize = s < c_rlpListImmLenCount ? 1 : (1 + brs);
 //			cdebug << "s: " << s << ", p: " << p << ", m_out.size(): " << m_out.size() << ", encodeSize: " << encodeSize << " (br: " << brs << ")";
 			auto os = m_out.size();
 			m_out.resize(os + encodeSize);
@@ -205,7 +205,7 @@ void RLPStream::noteAppended(uint _itemCount)
 	}
 }
 
-RLPStream& RLPStream::appendList(uint _items)
+RLPStream& RLPStream::appendList(unsigned _items)
 {
 //	cdebug << "appendList(" << _items << ")";
 	if (_items)
@@ -227,7 +227,7 @@ RLPStream& RLPStream::appendList(bytesConstRef _rlp)
 
 RLPStream& RLPStream::append(bytesConstRef _s, bool _compact)
 {
-	uint s = _s.size();
+	unsigned s = _s.size();
 	byte const* d = _s.data();
 	if (_compact)
 		for (unsigned i = 0; i < _s.size() && !*d; ++i, --s, ++d) {}
@@ -254,7 +254,7 @@ RLPStream& RLPStream::append(bigint _i)
 		m_out.push_back((byte)_i);
 	else
 	{
-		uint br = bytesRequired(_i);
+		unsigned br = bytesRequired(_i);
 		if (br < c_rlpDataImmLenCount)
 			m_out.push_back((byte)(br + c_rlpDataImmLenStart));
 		else
@@ -269,21 +269,21 @@ RLPStream& RLPStream::append(bigint _i)
 	return *this;
 }
 
-void RLPStream::pushCount(uint _count, byte _base)
+void RLPStream::pushCount(unsigned _count, byte _base)
 {
 	auto br = bytesRequired(_count);
 	m_out.push_back((byte)(br + _base));	// max 8 bytes.
 	pushInt(_count, br);
 }
 
-std::ostream& eth::operator<<(std::ostream& _out, eth::RLP const& _d)
+std::ostream& dev::operator<<(std::ostream& _out, RLP const& _d)
 {
 	if (_d.isNull())
 		_out << "null";
 	else if (_d.isInt())
 		_out << std::showbase << std::hex << std::nouppercase << _d.toInt<bigint>(RLP::LaisezFaire) << dec;
 	else if (_d.isData())
-		_out << eth::escaped(_d.toString(), false);
+		_out << escaped(_d.toString(), false);
 	else if (_d.isList())
 	{
 		_out << "[";

libethential/RLP.h → libdevcore/RLP.h

@@ -28,21 +28,21 @@
 #include <exception>
 #include <iostream>
 #include <iomanip>
-#include <libethential/vector_ref.h>
-#include <libethential/Common.h>
-#include <libethential/Exceptions.h>
-#include <libethential/FixedHash.h>
+#include <libdevcore/vector_ref.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/Exceptions.h>
+#include <libdevcore/FixedHash.h>
 
-namespace eth
+namespace dev
 {
 
 class RLP;
 typedef std::vector<RLP> RLPs;
 
-template <class _T> struct intTraits { static const uint maxSize = sizeof(_T); };
-template <> struct intTraits<u160> { static const uint maxSize = 20; };
-template <> struct intTraits<u256> { static const uint maxSize = 32; };
-template <> struct intTraits<bigint> { static const uint maxSize = ~(uint)0; };
+template <class _T> struct intTraits { static const unsigned maxSize = sizeof(_T); };
+template <> struct intTraits<u160> { static const unsigned maxSize = 20; };
+template <> struct intTraits<u256> { static const unsigned maxSize = 32; };
+template <> struct intTraits<bigint> { static const unsigned maxSize = ~(unsigned)0; };
 
 static const byte c_rlpMaxLengthBytes = 8;
 static const byte c_rlpDataImmLenStart = 0x80;
@@ -72,7 +72,7 @@ public:
 	explicit RLP(bytes const& _d): m_data(&_d) {}
 
 	/// Construct a node to read RLP data in the bytes given.
-	RLP(byte const* _b, uint _s): m_data(bytesConstRef(_b, _s)) {}
+	RLP(byte const* _b, unsigned _s): m_data(bytesConstRef(_b, _s)) {}
 
 	/// Construct a node to read RLP data in the string.
 	explicit RLP(std::string const& _s): m_data(bytesConstRef((byte const*)_s.data(), _s.size())) {}
@@ -99,12 +99,12 @@ public:
 	bool isInt() const;
 
 	/// @returns the number of items in the list, or zero if it isn't a list.
-	uint itemCount() const { return isList() ? items() : 0; }
-	uint itemCountStrict() const { if (!isList()) throw BadCast(); return items(); }
+	unsigned itemCount() const { return isList() ? items() : 0; }
+	unsigned itemCountStrict() const { if (!isList()) throw BadCast(); return items(); }
 
 	/// @returns the number of bytes in the data, or zero if it isn't data.
-	uint size() const { return isData() ? length() : 0; }
-	uint sizeStrict() const { if (!isData()) throw BadCast(); return length(); }
+	unsigned size() const { return isData() ? length() : 0; }
+	unsigned sizeStrict() const { if (!isData()) throw BadCast(); return length(); }
 
 	/// Equality operators; does best-effort conversion and checks for equality.
 	bool operator==(char const* _s) const { return isData() && toString() == _s; }
@@ -113,8 +113,8 @@ public:
 	bool operator!=(std::string const& _s) const { return isData() && toString() != _s; }
 	template <unsigned _N> bool operator==(FixedHash<_N> const& _h) const { return isData() && toHash<_N>() == _h; }
 	template <unsigned _N> bool operator!=(FixedHash<_N> const& _s) const { return isData() && toHash<_N>() != _s; }
-	bool operator==(uint const& _i) const { return isInt() && toInt<uint>() == _i; }
-	bool operator!=(uint const& _i) const { return isInt() && toInt<uint>() != _i; }
+	bool operator==(unsigned const& _i) const { return isInt() && toInt<unsigned>() == _i; }
+	bool operator!=(unsigned const& _i) const { return isInt() && toInt<unsigned>() != _i; }
 	bool operator==(u256 const& _i) const { return isInt() && toInt<u256>() == _i; }
 	bool operator!=(u256 const& _i) const { return isInt() && toInt<u256>() != _i; }
 	bool operator==(bigint const& _i) const { return isInt() && toInt<bigint>() == _i; }
@@ -123,7 +123,7 @@ public:
 	/// Subscript operator.
 	/// @returns the list item @a _i if isList() and @a _i < listItems(), or RLP() otherwise.
 	/// @note if used to access items in ascending order, this is efficient.
-	RLP operator[](uint _i) const;
+	RLP operator[](unsigned _i) const;
 
 	typedef RLP element_type;
 
@@ -146,7 +146,7 @@ public:
 		iterator() {}
 		iterator(RLP const& _parent, bool _begin);
 
-		uint m_remaining = 0;
+		unsigned m_remaining = 0;
 		bytesConstRef m_lastItem;
 	};
 
@@ -160,10 +160,13 @@ public:
 	explicit operator std::string() const { return toString(); }
 	explicit operator RLPs() const { return toList(); }
 	explicit operator byte() const { return toInt<byte>(); }
-	explicit operator uint() const { return toInt<uint>(); }
 	explicit operator u256() const { return toInt<u256>(); }
 	explicit operator bigint() const { return toInt<bigint>(); }
 	template <unsigned _N> explicit operator FixedHash<_N>() const { return toHash<FixedHash<_N>>(); }
+	template <class T, class U> explicit operator std::pair<T, U>() const { return toPair<T, U>(); }
+	template <class T> explicit operator std::vector<T>() const { return toVector<T>(); }
+	template <class T> explicit operator std::set<T>() const { return toSet<T>(); }
+	template <class T, size_t N> explicit operator std::array<T, N>() const { return toArray<T, N>(); }
 
 	/// Converts to bytearray. @returns the empty byte array if not a string.
 	bytes toBytes() const { if (!isData()) return bytes(); return bytes(payload().data(), payload().data() + length()); }
@@ -174,8 +177,59 @@ public:
 	/// Converts to string. @throws BadCast if not a string.
 	std::string toStringStrict() const { if (!isData()) throw BadCast(); return payload().cropped(0, length()).toString(); }
 
-	template <class T> std::vector<T> toVector() const { std::vector<T> ret; if (isList()) { ret.reserve(itemCount()); for (auto const& i: *this) ret.push_back((T)i); } return ret; }
-	template <class T, size_t N> std::array<T, N> toArray() const { if (itemCount() != N || !isList()) throw BadCast(); std::array<T, N> ret; for (uint i = 0; i < N; ++i) ret[i] = (T)operator[](i); return ret; }
+	template <class T>
+	std::vector<T> toVector() const
+	{
+		std::vector<T> ret;
+		if (isList())
+		{
+			ret.reserve(itemCount());
+			for (auto const& i: *this)
+			{
+				ret.push_back((T)i);
+			}
+		 }
+		 return ret;
+	}
+
+	template <class T>
+	std::set<T> toSet() const
+	{
+		std::set<T> ret;
+		if (isList())
+		{
+			for (auto const& i: *this)
+			{
+				ret.insert((T)i);
+			}
+		}
+		return ret;
+	}
+	
+	template <class T, class U>
+	std::pair<T, U> toPair() const
+	{
+		std::pair<T, U> ret;
+		if (isList())
+		{
+			ret.first = (T)(*this)[0];
+			ret.second = (U)(*this)[1];
+		}
+		return ret;
+	}
+
+	template <class T, size_t N>
+	std::array<T, N> toArray() const
+	{
+		if (itemCount() != N || !isList())
+			throw BadCast();
+		std::array<T, N> ret;
+		for (unsigned i = 0; i < N; ++i)
+		{
+			ret[i] = (T)operator[](i);
+		}
+		return ret;
+	}
 
 	/// Int conversion flags
 	enum
@@ -188,7 +242,7 @@ public:
 	};
 
 	/// Converts to int of type given; if isString(), decodes as big-endian bytestream. @returns 0 if not an int or string.
-	template <class _T = uint> _T toInt(int _flags = Strict) const
+	template <class _T = unsigned> _T toInt(int _flags = Strict) const
 	{
 		if ((!isInt() && !(_flags & AllowNonCanon)) || isList() || isNull())
 			if (_flags & ThrowOnFail)
@@ -231,27 +285,27 @@ public:
 
 	/// @returns the theoretical size of this item.
 	/// @note Under normal circumstances, is equivalent to m_data.size() - use that unless you know it won't work.
-	uint actualSize() const;
+	unsigned actualSize() const;
 
 private:
 	/// Single-byte data payload.
 	bool isSingleByte() const { return !isNull() && m_data[0] < c_rlpDataImmLenStart; }
 
 	/// @returns the bytes used to encode the length of the data. Valid for all types.
-	uint lengthSize() const { if (isData() && m_data[0] > c_rlpDataIndLenZero) return m_data[0] - c_rlpDataIndLenZero; if (isList() && m_data[0] > c_rlpListIndLenZero) return m_data[0] - c_rlpListIndLenZero; return 0; }
+	unsigned lengthSize() const { if (isData() && m_data[0] > c_rlpDataIndLenZero) return m_data[0] - c_rlpDataIndLenZero; if (isList() && m_data[0] > c_rlpListIndLenZero) return m_data[0] - c_rlpListIndLenZero; return 0; }
 
 	/// @returns the size in bytes of the payload, as given by the RLP as opposed to as inferred from m_data.
-	uint length() const;
+	unsigned length() const;
 
 	/// @returns the number of data items.
-	uint items() const;
+	unsigned items() const;
 
 	/// Our byte data.
 	bytesConstRef m_data;
 
 	/// The list-indexing cache.
-	mutable uint m_lastIndex = (uint)-1;
-	mutable uint m_lastEnd = 0;
+	mutable unsigned m_lastIndex = (unsigned)-1;
+	mutable unsigned m_lastEnd = 0;
 	mutable bytesConstRef m_lastItem;
 };
 
@@ -265,12 +319,12 @@ public:
 	RLPStream() {}
 
 	/// Initializes the RLPStream as a list of @a _listItems items.
-	explicit RLPStream(uint _listItems) { appendList(_listItems); }
+	explicit RLPStream(unsigned _listItems) { appendList(_listItems); }
 
 	~RLPStream() {}
 
 	/// Append given datum to the byte stream.
-	RLPStream& append(uint _s) { return append(bigint(_s)); }
+	RLPStream& append(unsigned _s) { return append(bigint(_s)); }
 	RLPStream& append(u160 _s) { return append(bigint(_s)); }
 	RLPStream& append(u256 _s) { return append(bigint(_s)); }
 	RLPStream& append(bigint _s);
@@ -281,22 +335,24 @@ public:
 	template <unsigned N> RLPStream& append(FixedHash<N> _s, bool _compact = false, bool _allOrNothing = false) { return _allOrNothing && !_s ? append(bytesConstRef()) : append(_s.ref(), _compact); }
 
 	/// Appends an arbitrary RLP fragment - this *must* be a single item.
-	RLPStream& append(RLP const& _rlp, uint _itemCount = 1) { return appendRaw(_rlp.data(), _itemCount); }
+	RLPStream& append(RLP const& _rlp, unsigned _itemCount = 1) { return appendRaw(_rlp.data(), _itemCount); }
 
 	/// Appends a sequence of data to the stream as a list.
 	template <class _T> RLPStream& append(std::vector<_T> const& _s) { return appendVector(_s); }
-	template <class _T, size_t S> RLPStream& append(std::array<_T, S> const& _s) { appendList(_s.size()); for (auto const& i: _s) append(i); return *this; }
 	template <class _T> RLPStream& appendVector(std::vector<_T> const& _s) { appendList(_s.size()); for (auto const& i: _s) append(i); return *this; }
+	template <class _T, size_t S> RLPStream& append(std::array<_T, S> const& _s) { appendList(_s.size()); for (auto const& i: _s) append(i); return *this; }
+	template <class _T> RLPStream& append(std::set<_T> const& _s) { appendList(_s.size()); for (auto const& i: _s) append(i); return *this; }
+	template <class T, class U> RLPStream& append(std::pair<T, U> const& _s) { appendList(2); append(_s.first); append(_s.second); return *this; }
 
 	/// Appends a list.
-	RLPStream& appendList(uint _items);
+	RLPStream& appendList(unsigned _items);
 	RLPStream& appendList(bytesConstRef _rlp);
 	RLPStream& appendList(bytes const& _rlp) { return appendList(&_rlp); }
 	RLPStream& appendList(RLPStream const& _s) { return appendList(&_s.out()); }
 
 	/// Appends raw (pre-serialised) RLP data. Use with caution.
-	RLPStream& appendRaw(bytesConstRef _rlp, uint _itemCount = 1);
-	RLPStream& appendRaw(bytes const& _rlp, uint _itemCount = 1) { return appendRaw(&_rlp, _itemCount); }
+	RLPStream& appendRaw(bytesConstRef _rlp, unsigned _itemCount = 1);
+	RLPStream& appendRaw(bytes const& _rlp, unsigned _itemCount = 1) { return appendRaw(&_rlp, _itemCount); }
 
 	/// Shift operators for appending data items.
 	template <class T> RLPStream& operator<<(T _data) { return append(_data); }
@@ -311,14 +367,14 @@ public:
 	void swapOut(bytes& _dest) { assert(m_listStack.empty()); swap(m_out, _dest); }
 
 private:
-	void noteAppended(uint _itemCount = 1);
+	void noteAppended(unsigned _itemCount = 1);
 
 	/// Push the node-type byte (using @a _base) along with the item count @a _count.
 	/// @arg _count is number of characters for strings, data-bytes for ints, or items for lists.
-	void pushCount(uint _count, byte _offset);
+	void pushCount(unsigned _count, byte _offset);
 
 	/// Push an integer as a raw big-endian byte-stream.
-	template <class _T> void pushInt(_T _i, uint _br)
+	template <class _T> void pushInt(_T _i, unsigned _br)
 	{
 		m_out.resize(m_out.size() + _br);
 		byte* b = &m_out.back();
@@ -329,7 +385,7 @@ private:
 	/// Our output byte stream.
 	bytes m_out;
 
-	std::vector<std::pair<uint, uint>> m_listStack;
+	std::vector<std::pair<unsigned, unsigned>> m_listStack;
 };
 
 template <class _T> void rlpListAux(RLPStream& _out, _T _t) { _out << _t; }
@@ -354,6 +410,6 @@ extern bytes RLPNull;
 extern bytes RLPEmptyList;
 
 /// Human readable version of RLP.
-std::ostream& operator<<(std::ostream& _out, eth::RLP const& _d);
+std::ostream& operator<<(std::ostream& _out, dev::RLP const& _d);
 
 }

libdevcore/RangeMask.cpp

@@ -0,0 +1,22 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file RangeMask.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "RangeMask.h"

libdevcore/RangeMask.h

@@ -0,0 +1,212 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file EthereumHost.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#pragma once
+
+#include <map>
+#include <utility>
+#include <vector>
+#include <iostream>
+
+namespace dev
+{
+
+class RLPStream;
+
+using UnsignedRange = std::pair<unsigned, unsigned>;
+using UnsignedRanges = std::vector<UnsignedRange>;
+
+template <class T>
+class RangeMask
+{
+	template <class U> friend std::ostream& operator<<(std::ostream& _out, RangeMask<U> const& _r);
+
+public:
+	using Range = std::pair<T, T>;
+	using Ranges = std::vector<Range>;
+
+	RangeMask() {}
+	RangeMask(T _begin, T _end): m_all(_begin, _end) {}
+	RangeMask(Range const& _c): m_all(_c) {}
+
+	RangeMask operator+(RangeMask const& _m) const { return RangeMask(*this) += _m; }
+
+	RangeMask lowest(T _items) const
+	{
+		RangeMask ret(m_all);
+		for (auto i = m_ranges.begin(); i != m_ranges.end() && _items; ++i)
+			_items -= (ret.m_ranges[i->first] = std::min(i->first + _items, i->second)) - i->first;
+		return ret;
+	}
+
+	RangeMask operator~() const
+	{
+		RangeMask ret(m_all);
+		T last = m_all.first;
+		for (auto i: m_ranges)
+		{
+			if (i.first != last)
+				ret.m_ranges[last] = i.first;
+			last = i.second;
+		}
+		if (last != m_all.second)
+			ret.m_ranges[last] = m_all.second;
+		return ret;
+	}
+
+	RangeMask& operator+=(RangeMask const& _m)
+	{
+		for (auto const& i: _m.m_ranges)
+			operator+=(i);
+		return *this;
+	}
+	RangeMask& operator+=(UnsignedRange const& _m)
+	{
+		for (auto i = _m.first; i < _m.second;)
+		{
+			// for each number, we find the element equal or next lower. this, if any, must contain the value.
+			auto uit = m_ranges.upper_bound(i);
+			auto it = uit == m_ranges.begin() ? m_ranges.end() : std::prev(uit);
+			if (it == m_ranges.end() || it->second < i)
+				// lower range is too low to merge.
+				// if the next higher range is too high.
+				if (uit == m_ranges.end() || uit->first > _m.second)
+				{
+					// just create a new range
+					m_ranges[i] = _m.second;
+					break;
+				}
+				else
+				{
+					if (uit->first == i)
+						// move i to end of range
+						i = uit->second;
+					else
+					{
+						// merge with the next higher range
+						// move i to end of range
+						i = m_ranges[i] = uit->second;
+						i = uit->second;
+						m_ranges.erase(uit);
+					}
+				}
+			else if (it->second == i)
+			{
+				// if the next higher range is too high.
+				if (uit == m_ranges.end() || uit->first > _m.second)
+				{
+					// merge with the next lower range
+					m_ranges[it->first] = _m.second;
+					break;
+				}
+				else
+				{
+					// merge with both next lower & next higher.
+					i = m_ranges[it->first] = uit->second;
+					m_ranges.erase(uit);
+				}
+			}
+			else
+				i = it->second;
+		}
+		return *this;
+	}
+
+	RangeMask& operator+=(T _i)
+	{
+		return operator+=(Range(_i, _i + 1));
+	}
+
+	bool contains(T _i) const
+	{
+		auto it = m_ranges.upper_bound(_i);
+		if (it == m_ranges.begin())
+			return false;
+		return (--it)->second > _i;
+	}
+
+	bool empty() const
+	{
+		return m_ranges.empty();
+	}
+
+	bool full() const
+	{
+		return m_ranges.size() == 1 && m_ranges.begin()->first == m_all.first && m_ranges.begin()->second == m_all.second;
+	}
+
+	void clear()
+	{
+		m_ranges.clear();
+	}
+
+	std::pair<T, T> const& all() const { return m_all; }
+
+	class const_iterator
+	{
+		friend class RangeMask;
+
+	public:
+		const_iterator() {}
+
+		T operator*() const { return m_value; }
+		const_iterator& operator++() { if (m_owner) m_value = m_owner->next(m_value); return *this; }
+		const_iterator operator++(int) { auto ret = *this; if (m_owner) m_value = m_owner->next(m_value); return ret; }
+
+		bool operator==(const_iterator const& _i) const { return m_owner == _i.m_owner && m_value == _i.m_value; }
+		bool operator!=(const_iterator const& _i) const { return !operator==(_i); }
+		bool operator<(const_iterator const& _i) const { return m_value < _i.m_value; }
+
+	private:
+		const_iterator(RangeMask const& _m, bool _end): m_owner(&_m), m_value(_m.m_ranges.empty() || _end ? _m.m_all.second : _m.m_ranges.begin()->first) {}
+
+		RangeMask const* m_owner = nullptr;
+		T m_value = 0;
+	};
+
+	const_iterator begin() const { return const_iterator(*this, false); }
+	const_iterator end() const { return const_iterator(*this, true); }
+	T next(T _t) const
+	{
+		_t++;
+		// find next item in range at least _t
+		auto uit = m_ranges.upper_bound(_t);	 // > _t
+		auto it = uit == m_ranges.begin() ? m_ranges.end() : std::prev(uit);
+		if (it != m_ranges.end() && it->first <= _t && it->second > _t)
+			return _t;
+		return uit == m_ranges.end() ? m_all.second : uit->first;
+	}
+
+private:
+	UnsignedRange m_all;
+	std::map<T, T> m_ranges;
+};
+
+template <class T> inline std::ostream& operator<<(std::ostream& _out, RangeMask<T> const& _r)
+{
+	_out << _r.m_all.first << "{ ";
+	for (auto const& i: _r.m_ranges)
+		_out << "[" << i.first << ", " << i.second << ") ";
+	_out << "}" << _r.m_all.second;
+	return _out;
+}
+
+}

libdevcore/Worker.cpp

@@ -0,0 +1,63 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file Worker.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "Worker.h"
+
+#include <chrono>
+#include <thread>
+#include "Log.h"
+using namespace std;
+using namespace dev;
+
+void Worker::startWorking()
+{
+	cdebug << "startWorking for thread" << m_name;
+	Guard l(x_work);
+	if (m_work)
+		return;
+	cdebug << "Spawning" << m_name;
+	m_stop = false;
+	m_work.reset(new thread([&]()
+	{
+		setThreadName(m_name.c_str());
+		while (!m_stop)
+		{
+			this_thread::sleep_for(chrono::milliseconds(30));
+			doWork();
+		}
+		cdebug << "Finishing up worker thread";
+		doneWorking();
+	}));
+}
+
+void Worker::stopWorking()
+{
+	cdebug << "stopWorking for thread" << m_name;
+	Guard l(x_work);
+	if (!m_work)
+		return;
+	cdebug << "Stopping" << m_name;
+	m_stop = true;
+	m_work->join();
+	m_work.reset();
+	cdebug << "Stopped" << m_name;
+}
+

libdevcore/Worker.h

@@ -0,0 +1,59 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file Worker.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#pragma once
+
+#include <string>
+#include <thread>
+#include "Guards.h"
+
+namespace dev
+{
+
+class Worker
+{
+protected:
+	Worker(std::string const& _name = "anon"): m_name(_name) {}
+
+	/// Move-constructor.
+	Worker(Worker&& _m) { std::swap(m_name, _m.m_name); }
+
+	/// Move-assignment.
+	Worker& operator=(Worker&& _m) { std::swap(m_name, _m.m_name); return *this; }
+
+	virtual ~Worker() { stopWorking(); }
+
+	void setName(std::string _n) { if (!isWorking()) m_name = _n; }
+
+	void startWorking();
+	void stopWorking();
+	bool isWorking() const { Guard l(x_work); return !!m_work; }
+	virtual void doWork() = 0;
+	virtual void doneWorking() {}
+
+private:
+	mutable Mutex x_work;						///< Lock for the network existance.
+	std::unique_ptr<std::thread> m_work;		///< The network thread.
+	bool m_stop = false;
+	std::string m_name;
+};
+
+}

libdevcore/_libdevcore.cpp

@@ -0,0 +1,10 @@
+#ifdef _MSC_VER
+#include "All.h"
+#include "Common.cpp"
+#include "CommonData.cpp"
+#include "CommonIO.cpp"
+#include "FixedHash.cpp"
+#include "Guards.cpp"
+#include "Log.cpp"
+#include "RLP.cpp"
+#endif

libethential/vector_ref.h → libdevcore/vector_ref.h

@@ -5,12 +5,7 @@
 #include <vector>
 #include <string>
 
-#pragma warning(push)
-#pragma warning(disable: 4100 4267)
-#include <leveldb/db.h>
-#pragma warning(pop)
-
-namespace eth
+namespace dev
 {
 
 template <class _T>
@@ -26,8 +21,9 @@ public:
 	vector_ref(std::string* _data): m_data((_T*)_data->data()), m_count(_data->size() / sizeof(_T)) {}
 	vector_ref(typename std::conditional<std::is_const<_T>::value, std::vector<typename std::remove_const<_T>::type> const*, std::vector<_T>*>::type _data): m_data(_data->data()), m_count(_data->size()) {}
 	vector_ref(typename std::conditional<std::is_const<_T>::value, std::string const&, std::string&>::type _data): m_data((_T*)_data.data()), m_count(_data.size() / sizeof(_T)) {}
+#ifdef STORAGE_LEVELDB_INCLUDE_DB_H_
 	vector_ref(leveldb::Slice const& _s): m_data(_s.data()), m_count(_s.size() / sizeof(_T)) {}
-
+#endif
 	explicit operator bool() const { return m_data && m_count; }
 
 	bool contentsEqual(std::vector<mutable_value_type> const& _c) const { return _c.size() == m_count && !memcmp(_c.data(), m_data, m_count); }
@@ -56,7 +52,9 @@ public:
 	bool operator==(vector_ref<_T> const& _cmp) const { return m_data == _cmp.m_data && m_count == _cmp.m_count; }
 	bool operator!=(vector_ref<_T> const& _cmp) const { return !operator==(_cmp); }
 
+#ifdef STORAGE_LEVELDB_INCLUDE_DB_H_
 	operator leveldb::Slice() const { return leveldb::Slice((char const*)m_data, m_count * sizeof(_T)); }
+#endif
 
 	void reset() { m_data = nullptr; m_count = 0; }
 

libdevcrypto/All.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "Common.h"
+#include "FileSystem.h"
+#include "MemoryDB.h"
+#include "OverlayDB.h"
+#include "SHA3.h"
+#include "TrieCommon.h"
+#include "TrieDB.h"

libdevcrypto/CMakeLists.txt

@@ -0,0 +1,56 @@
+cmake_policy(SET CMP0015 NEW)
+
+aux_source_directory(. SRC_LIST)
+
+set(EXECUTABLE devcrypto)
+
+# set(CMAKE_INSTALL_PREFIX ../lib)
+if(ETH_STATIC)
+	add_library(${EXECUTABLE} STATIC ${SRC_LIST})
+else()
+	add_library(${EXECUTABLE} SHARED ${SRC_LIST})
+endif()
+
+file(GLOB HEADERS "*.h") 
+
+include_directories(..)
+
+target_link_libraries(${EXECUTABLE} devcore)
+target_link_libraries(${EXECUTABLE} secp256k1)
+target_link_libraries(${EXECUTABLE} gmp)
+target_link_libraries(${EXECUTABLE} ${LEVELDB_LS})
+target_link_libraries(${EXECUTABLE} ${CRYPTOPP_LS})
+
+if("${TARGET_PLATFORM}" STREQUAL "w64")
+	target_link_libraries(${EXECUTABLE} boost_system-mt-s)
+	target_link_libraries(${EXECUTABLE} boost_filesystem-mt-s)
+	target_link_libraries(${EXECUTABLE} boost_thread_win32-mt-s)
+	target_link_libraries(${EXECUTABLE} iphlpapi)
+	target_link_libraries(${EXECUTABLE} ws2_32)
+	target_link_libraries(${EXECUTABLE} mswsock)
+	target_link_libraries(${EXECUTABLE} shlwapi)
+elseif (APPLE)
+	# Latest mavericks boost libraries only come with -mt
+	target_link_libraries(${EXECUTABLE} boost_system-mt)
+	target_link_libraries(${EXECUTABLE} boost_filesystem-mt)
+	target_link_libraries(${EXECUTABLE} boost_thread-mt)
+	find_package(Threads REQUIRED)
+	target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
+elseif (UNIX)
+	find_package(Boost 1.53 REQUIRED COMPONENTS filesystem)
+	target_link_libraries(${EXECUTABLE} ${Boost_SYSTEM_LIBRARY})
+	target_link_libraries(${EXECUTABLE} ${Boost_FILESYSTEM_LIBRARY})
+	target_link_libraries(${EXECUTABLE} ${Boost_THREAD_LIBRARY})
+	target_link_libraries(${EXECUTABLE} ${Boost_DATE_TIME_LIBRARY})
+	target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
+else ()
+	target_link_libraries(${EXECUTABLE} boost_system)
+	target_link_libraries(${EXECUTABLE} boost_filesystem)
+	target_link_libraries(${EXECUTABLE} boost_thread)
+	find_package(Threads REQUIRED)
+	target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
+endif ()
+
+install( TARGETS ${EXECUTABLE} ARCHIVE DESTINATION lib LIBRARY DESTINATION lib )
+install( FILES ${HEADERS} DESTINATION include/${EXECUTABLE} )
+

libdevcrypto/Common.cpp

@@ -0,0 +1,104 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file CommonEth.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "Common.h"
+#include <random>
+#include <secp256k1/secp256k1.h>
+#include "SHA3.h"
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+//#define ETH_ADDRESS_DEBUG 1
+
+Address dev::toAddress(Secret _private)
+{
+	secp256k1_start();
+
+	byte pubkey[65];
+	int pubkeylen = 65;
+	int ok = secp256k1_ecdsa_seckey_verify(_private.data());
+	if (!ok)
+		return Address();
+	ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, _private.data(), 0);
+	assert(pubkeylen == 65);
+	if (!ok)
+		return Address();
+	ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65);
+	if (!ok)
+		return Address();
+	auto ret = right160(dev::eth::sha3(bytesConstRef(&(pubkey[1]), 64)));
+#if ETH_ADDRESS_DEBUG
+	cout << "---- ADDRESS -------------------------------" << endl;
+	cout << "SEC: " << _private << endl;
+	cout << "PUB: " << toHex(bytesConstRef(&(pubkey[1]), 64)) << endl;
+	cout << "ADR: " << ret << endl;
+#endif
+	return ret;
+}
+
+KeyPair KeyPair::create()
+{
+	secp256k1_start();
+	static std::mt19937_64 s_eng(time(0));
+	std::uniform_int_distribution<uint16_t> d(0, 255);
+
+	for (int i = 0; i < 100; ++i)
+	{
+		h256 sec;
+		for (unsigned i = 0; i < 32; ++i)
+			sec[i] = (byte)d(s_eng);
+
+		KeyPair ret(sec);
+		if (ret.address())
+			return ret;
+	}
+	return KeyPair();
+}
+
+KeyPair::KeyPair(h256 _sec):
+	m_secret(_sec)
+{
+	int ok = secp256k1_ecdsa_seckey_verify(m_secret.data());
+	if (!ok)
+		return;
+
+	byte pubkey[65];
+	int pubkeylen = 65;
+	ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, m_secret.data(), 0);
+	if (!ok || pubkeylen != 65)
+		return;
+
+	ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65);
+	if (!ok)
+		return;
+
+	m_secret = m_secret;
+	memcpy(m_public.data(), &(pubkey[1]), 64);
+	m_address = right160(dev::eth::sha3(bytesConstRef(&(pubkey[1]), 64)));
+
+#if ETH_ADDRESS_DEBUG
+	cout << "---- ADDRESS -------------------------------" << endl;
+	cout << "SEC: " << m_secret << endl;
+	cout << "PUB: " << m_public << endl;
+	cout << "ADR: " << m_address << endl;
+#endif
+}

libdevcrypto/Common.h

@@ -0,0 +1,86 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file CommonEth.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ *
+ * Ethereum-specific data structures & algorithms.
+ */
+
+#pragma once
+
+#include <libdevcore/Common.h>
+#include <libdevcore/FixedHash.h>
+
+namespace dev
+{
+
+/// A secret key: 32 bytes.
+/// @NOTE This is not endian-specific; it's just a bunch of bytes.
+using Secret = h256;
+
+/// A public key: 64 bytes.
+/// @NOTE This is not endian-specific; it's just a bunch of bytes.
+using Public = h512;
+
+/// An Ethereum address: 20 bytes.
+/// @NOTE This is not endian-specific; it's just a bunch of bytes.
+using Address = h160;
+
+/// A vector of Ethereum addresses.
+using Addresses = h160s;
+
+/// Convert a private key into the public key equivalent.
+/// @returns 0 if it's not a valid private key.
+Address toAddress(h256 _private);
+
+/// Simple class that represents a "key pair".
+/// All of the data of the class can be regenerated from the secret key (m_secret) alone.
+/// Actually stores a tuplet of secret, public and address (the right 160-bits of the public).
+class KeyPair
+{
+public:
+	/// Null constructor.
+	KeyPair() {}
+
+	/// Normal constructor - populates object from the given secret key.
+	KeyPair(Secret _k);
+
+	/// Create a new, randomly generated object.
+	static KeyPair create();
+
+	/// Retrieve the secret key.
+	Secret const& secret() const { return m_secret; }
+	/// Retrieve the secret key.
+	Secret const& sec() const { return m_secret; }
+
+	/// Retrieve the public key.
+	Public const& pub() const { return m_public; }
+
+	/// Retrieve the associated address of the public key.
+	Address const& address() const { return m_address; }
+
+	bool operator==(KeyPair const& _c) const { return m_secret == _c.m_secret; }
+	bool operator!=(KeyPair const& _c) const { return m_secret != _c.m_secret; }
+
+private:
+	Secret m_secret;
+	Public m_public;
+	Address m_address;
+};
+
+}

libdevcrypto/CryptoHeaders.h

@@ -0,0 +1,36 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file CryptoHeaders.h
+ * @author Tim Hughes <tim@twistedfury.com>
+ * @date 2014
+ */
+#pragma once
+
+// need to leave this one disabled
+#pragma GCC diagnostic ignored "-Wunused-function"
+
+#pragma warning(push)
+#pragma warning(disable:4100 4244)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#include <sha.h>
+#include <sha3.h>
+#include <ripemd.h>
+#include <secp256k1/secp256k1.h>
+#pragma warning(pop)
+#pragma GCC diagnostic pop

libethcore/FileSystem.cpp → libdevcrypto/FileSystem.cpp

@@ -22,17 +22,17 @@
  */
 
 #include "FileSystem.h"
-#include <libethential/Common.h>
-#include <libethential/Log.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/Log.h>
 
 #ifdef _WIN32
 #include <shlobj.h>
 #endif
 #include <boost/filesystem.hpp>
 using namespace std;
-using namespace eth;
+using namespace dev;
 
-std::string eth::getDataDir()
+std::string dev::getDataDir()
 {
 #ifdef _WIN32
 	char path[1024] = "";

libethcore/FileSystem.h → libdevcrypto/FileSystem.h

@@ -25,7 +25,7 @@
 
 #include <string>
 
-namespace eth
+namespace dev
 {
 
 /// @returns the path for user data.

libethcore/MemoryDB.cpp → libdevcrypto/MemoryDB.cpp

@@ -19,11 +19,14 @@
  * @date 2014
  */
 
-#include <libethential/Common.h>
+#include <libdevcore/Common.h>
 #include "MemoryDB.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
+namespace dev
+{
 namespace eth
 {
 
@@ -113,3 +116,4 @@ set<h256> MemoryDB::keys() const
 }
 
 }
+}

libethcore/MemoryDB.h → libdevcrypto/MemoryDB.h

@@ -22,11 +22,13 @@
 #pragma once
 
 #include <map>
-#include <libethential/Common.h>
-#include <libethential/FixedHash.h>
-#include <libethential/Log.h>
-#include <libethential/RLP.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/FixedHash.h>
+#include <libdevcore/Log.h>
+#include <libdevcore/RLP.h>
 
+namespace dev
+{
 namespace eth
 {
 
@@ -54,7 +56,7 @@ public:
 
 protected:
 	std::map<h256, std::string> m_over;
-	std::map<h256, uint> m_refCount;
+	std::map<h256, unsigned> m_refCount;
 
 	mutable bool m_enforceRefs = false;
 };
@@ -83,3 +85,4 @@ inline std::ostream& operator<<(std::ostream& _out, MemoryDB const& _m)
 }
 
 }
+}

libethcore/OverlayDB.cpp → libdevcrypto/OverlayDB.cpp

@@ -19,11 +19,14 @@
  * @date 2014
  */
 
-#include <libethential/Common.h>
+#include <libdevcore/Common.h>
 #include "OverlayDB.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
+namespace dev
+{
 namespace eth
 {
 
@@ -97,3 +100,4 @@ void OverlayDB::kill(h256 _h)
 }
 
 }
+}

libethcore/OverlayDB.h → libdevcrypto/OverlayDB.h

@@ -21,12 +21,19 @@
 
 #pragma once
 
+#pragma warning(push)
+#pragma warning(disable: 4100 4267)
+#include <leveldb/db.h>
+#pragma warning(pop)
+
 #include <memory>
-#include <libethential/Common.h>
-#include <libethential/Log.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/Log.h>
 #include "MemoryDB.h"
 namespace ldb = leveldb;
 
+namespace dev
+{
 namespace eth
 {
 
@@ -56,3 +63,4 @@ private:
 };
 
 }
+}

libethcore/SHA3.cpp → libdevcrypto/SHA3.cpp

@@ -23,11 +23,17 @@
 #include "CryptoHeaders.h"
 
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
-h256 eth::EmptySHA3 = sha3(bytesConstRef());
+namespace dev
+{
+namespace eth
+{
+
+h256 EmptySHA3 = sha3(bytesConstRef());
 
-std::string eth::sha3(std::string const& _input, bool _hex)
+std::string sha3(std::string const& _input, bool _hex)
 {
 	if (!_hex)
 	{
@@ -44,7 +50,7 @@ std::string eth::sha3(std::string const& _input, bool _hex)
 	return ret;
 }
 
-void eth::sha3(bytesConstRef _input, bytesRef _output)
+void sha3(bytesConstRef _input, bytesRef _output)
 {
 	CryptoPP::SHA3_256 ctx;
 	ctx.Update((byte*)_input.data(), _input.size());
@@ -52,17 +58,19 @@ void eth::sha3(bytesConstRef _input, bytesRef _output)
 	ctx.Final(_output.data());
 }
 
-bytes eth::sha3Bytes(bytesConstRef _input)
+bytes sha3Bytes(bytesConstRef _input)
 {
 	bytes ret(32);
 	sha3(_input, &ret);
 	return ret;
 }
 
-h256 eth::sha3(bytesConstRef _input)
+h256 sha3(bytesConstRef _input)
 {
 	h256 ret;
 	sha3(_input, bytesRef(&ret[0], 32));
 	return ret;
 }
 
+}
+}

libethcore/SHA3.h → libdevcrypto/SHA3.h

@@ -24,9 +24,11 @@
 #pragma once
 
 #include <string>
-#include <libethential/FixedHash.h>
-#include <libethential/vector_ref.h>
+#include <libdevcore/FixedHash.h>
+#include <libdevcore/vector_ref.h>
 
+namespace dev
+{
 namespace eth
 {
 
@@ -59,3 +61,4 @@ inline h256 sha3(std::string const& _input) { return sha3(bytesConstRef(_input))
 extern h256 EmptySHA3;
 
 }
+}

libethcore/TrieCommon.cpp → libdevcrypto/TrieCommon.cpp

@@ -21,6 +21,8 @@
 
 #include "TrieCommon.h"
 
+namespace dev
+{
 namespace eth
 {
 
@@ -42,8 +44,8 @@ namespace eth
 
 std::string hexPrefixEncode(bytes const& _hexVector, bool _leaf, int _begin, int _end)
 {
-	uint begin = _begin;
-	uint end = _end < 0 ? _hexVector.size() + 1 + _end : _end;
+	unsigned begin = _begin;
+	unsigned end = _end < 0 ? _hexVector.size() + 1 + _end : _end;
 	bool odd = ((end - begin) % 2) != 0;
 
 	std::string ret(1, ((_leaf ? 2 : 0) | (odd ? 1 : 0)) * 16);
@@ -52,21 +54,21 @@ std::string hexPrefixEncode(bytes const& _hexVector, bool _leaf, int _begin, int
 		ret[0] |= _hexVector[begin];
 		++begin;
 	}
-	for (uint i = begin; i < end; i += 2)
+	for (unsigned i = begin; i < end; i += 2)
 		ret += _hexVector[i] * 16 + _hexVector[i + 1];
 	return ret;
 }
 
-std::string hexPrefixEncode(bytesConstRef _data, bool _leaf, int _beginNibble, int _endNibble, uint _offset)
+std::string hexPrefixEncode(bytesConstRef _data, bool _leaf, int _beginNibble, int _endNibble, unsigned _offset)
 {
-	uint begin = _beginNibble + _offset;
-	uint end = (_endNibble < 0 ? (_data.size() * 2 - _offset) + 1 + _endNibble : _endNibble) + _offset;
+	unsigned begin = _beginNibble + _offset;
+	unsigned end = (_endNibble < 0 ? (_data.size() * 2 - _offset) + 1 + _endNibble : _endNibble) + _offset;
 	bool odd = (end - begin) & 1;
 
 	std::string ret(1, ((_leaf ? 2 : 0) | (odd ? 1 : 0)) * 16);
 	ret.reserve((end - begin) / 2 + 1);
 
-	uint d = odd ? 1 : 2;
+	unsigned d = odd ? 1 : 2;
 	for (auto i = begin; i < end; ++i, ++d)
 	{
 		byte n = nibble(_data, i);
@@ -78,19 +80,19 @@ std::string hexPrefixEncode(bytesConstRef _data, bool _leaf, int _beginNibble, i
 	return ret;
 }
 
-std::string hexPrefixEncode(bytesConstRef _d1, uint _o1, bytesConstRef _d2, uint _o2, bool _leaf)
+std::string hexPrefixEncode(bytesConstRef _d1, unsigned _o1, bytesConstRef _d2, unsigned _o2, bool _leaf)
 {
-	uint begin1 = _o1;
-	uint end1 = _d1.size() * 2;
-	uint begin2 = _o2;
-	uint end2 = _d2.size() * 2;
+	unsigned begin1 = _o1;
+	unsigned end1 = _d1.size() * 2;
+	unsigned begin2 = _o2;
+	unsigned end2 = _d2.size() * 2;
 
 	bool odd = (end1 - begin1 + end2 - begin2) & 1;
 
 	std::string ret(1, ((_leaf ? 2 : 0) | (odd ? 1 : 0)) * 16);
 	ret.reserve((end1 - begin1 + end2 - begin2) / 2 + 1);
 
-	uint d = odd ? 1 : 2;
+	unsigned d = odd ? 1 : 2;
 	for (auto i = begin1; i < end1; ++i, ++d)
 	{
 		byte n = nibble(_d1, i);
@@ -125,3 +127,4 @@ byte uniqueInUse(RLP const& _orig, byte except)
 }
 
 }
+}

libethcore/TrieCommon.h → libdevcrypto/TrieCommon.h

@@ -21,43 +21,45 @@
 
 #pragma once
 
-#include <libethential/Common.h>
-#include <libethential/RLP.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/RLP.h>
 
+namespace dev
+{
 namespace eth
 {
 
-inline byte nibble(bytesConstRef _data, uint _i)
+inline byte nibble(bytesConstRef _data, unsigned _i)
 {
 	return (_i & 1) ? (_data[_i / 2] & 15) : (_data[_i / 2] >> 4);
 }
 
-inline uint sharedNibbles(bytesConstRef _a, uint _ab, uint _ae, bytesConstRef _b, uint _bb, uint _be)
+inline unsigned sharedNibbles(bytesConstRef _a, unsigned _ab, unsigned _ae, bytesConstRef _b, unsigned _bb, unsigned _be)
 {
-	uint ret = 0;
-	for (uint ai = _ab, bi = _bb; ai < _ae && bi < _be && nibble(_a, ai) == nibble(_b, bi); ++ai, ++bi, ++ret) {}
+	unsigned ret = 0;
+	for (unsigned ai = _ab, bi = _bb; ai < _ae && bi < _be && nibble(_a, ai) == nibble(_b, bi); ++ai, ++bi, ++ret) {}
 	return ret;
 }
 
 struct NibbleSlice
 {
 	bytesConstRef data;
-	uint offset;
+	unsigned offset;
 
-	NibbleSlice(bytesConstRef _d = bytesConstRef(), uint _o = 0): data(_d), offset(_o) {}
-	byte operator[](uint _index) const { return nibble(data, offset + _index); }
-	uint size() const { return data.size() * 2 - offset; }
-	NibbleSlice mid(uint _index) const { return NibbleSlice(data, offset + _index); }
+	NibbleSlice(bytesConstRef _d = bytesConstRef(), unsigned _o = 0): data(_d), offset(_o) {}
+	byte operator[](unsigned _index) const { return nibble(data, offset + _index); }
+	unsigned size() const { return data.size() * 2 - offset; }
+	NibbleSlice mid(unsigned _index) const { return NibbleSlice(data, offset + _index); }
 
 	bool contains(NibbleSlice _k) const { return shared(_k) == _k.size(); }
-	uint shared(NibbleSlice _k) const { return sharedNibbles(data, offset, offset + size(), _k.data, _k.offset, _k.offset + _k.size()); }
+	unsigned shared(NibbleSlice _k) const { return sharedNibbles(data, offset, offset + size(), _k.data, _k.offset, _k.offset + _k.size()); }
 	bool operator==(NibbleSlice _k) const { return _k.size() == size() && shared(_k) == _k.size(); }
 	bool operator!=(NibbleSlice _s) const { return !operator==(_s); }
 };
 
 inline std::ostream& operator<<(std::ostream& _out, NibbleSlice const& _m)
 {
-	for (uint i = 0; i < _m.size(); ++i)
+	for (unsigned i = 0; i < _m.size(); ++i)
 		_out << std::hex << (int)_m[i] << std::dec;
 	return _out;
 }
@@ -86,8 +88,8 @@ inline NibbleSlice keyOf(RLP const& _twoItem)
 
 byte uniqueInUse(RLP const& _orig, byte except);
 std::string hexPrefixEncode(bytes const& _hexVector, bool _leaf = false, int _begin = 0, int _end = -1);
-std::string hexPrefixEncode(bytesConstRef _data, bool _leaf, int _beginNibble, int _endNibble, uint _offset);
-std::string hexPrefixEncode(bytesConstRef _d1, uint _o1, bytesConstRef _d2, uint _o2, bool _leaf);
+std::string hexPrefixEncode(bytesConstRef _data, bool _leaf, int _beginNibble, int _endNibble, unsigned _offset);
+std::string hexPrefixEncode(bytesConstRef _d1, unsigned _o1, bytesConstRef _d2, unsigned _o2, bool _leaf);
 
 inline std::string hexPrefixEncode(NibbleSlice _s, bool _leaf, int _begin = 0, int _end = -1)
 {
@@ -100,3 +102,4 @@ inline std::string hexPrefixEncode(NibbleSlice _s1, NibbleSlice _s2, bool _leaf)
 }
 
 }
+}

libethcore/TrieDB.cpp → libdevcrypto/TrieDB.cpp

@@ -19,17 +19,14 @@
  * @date 2014
  */
 
-#include <libethential/Common.h>
+#include <libdevcore/Common.h>
 #include "TrieDB.h"
 using namespace std;
-using namespace eth;
-
-namespace eth
-{
+using namespace dev;
+using namespace dev::eth;
 
 #if !ETH_LANGUAGES
 
-const h256 c_shaNull = sha3(rlp(""));
+const h256 dev::eth::c_shaNull = sha3(rlp(""));
 
 #endif
-}

libethcore/TrieDB.h → libdevcrypto/TrieDB.h

@@ -21,16 +21,23 @@
 
 #pragma once
 
+#pragma warning(push)
+#pragma warning(disable: 4100 4267)
+#include <leveldb/db.h>
+#pragma warning(pop)
+
 #include <map>
 #include <memory>
-#include <libethential/Common.h>
-#include <libethential/Log.h>
-#include <libethcore/SHA3.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/Log.h>
+#include <libdevcrypto/SHA3.h>
 #include "MemoryDB.h"
 #include "OverlayDB.h"
 #include "TrieCommon.h"
 namespace ldb = leveldb;
 
+namespace dev
+{
 namespace eth
 {
 
@@ -223,7 +230,7 @@ private:
 
 	// in: [K1 & K2, V] (DEL) : nibbles(K1) == _s, 0 < _s <= nibbles(K1 & K2)
 	// out: [K1, H] ; [K2, V] => H (INS)  (being  [K1, [K2, V]]  if necessary)
-	bytes cleve(RLP const& _orig, uint _s);
+	bytes cleve(RLP const& _orig, unsigned _s);
 
 	// in: [K1, H] (DEL) ; H <= [K2, V] (DEL)  (being  [K1, [K2, V]] (DEL)  if necessary)
 	// out: [K1 & K2, V]
@@ -308,9 +315,12 @@ std::ostream& operator<<(std::ostream& _out, TrieDB<KeyType, DB> const& _db)
 	return _out;
 }
 
+}
 }
 
 // Template implementations...
+namespace dev
+{
 namespace eth
 {
 
@@ -756,7 +766,7 @@ template <class DB> bytes GenericTrieDB<DB>::place(RLP const& _orig, NibbleSlice
 		return (RLPStream(2) << _orig[0] << _s).out();
 
 	auto s = RLPStream(17);
-	for (uint i = 0; i < 16; ++i)
+	for (unsigned i = 0; i < 16; ++i)
 		s << _orig[i];
 	s << _s;
 	return s.out();
@@ -778,7 +788,7 @@ template <class DB> bytes GenericTrieDB<DB>::remove(RLP const& _orig)
 	if (_orig.itemCount() == 2)
 		return RLPNull;
 	RLPStream r(17);
-	for (uint i = 0; i < 16; ++i)
+	for (unsigned i = 0; i < 16; ++i)
 		r << _orig[i];
 	r << "";
 	return r.out();
@@ -793,7 +803,7 @@ template <class DB> RLPStream& GenericTrieDB<DB>::streamNode(RLPStream& _s, byte
 	return _s;
 }
 
-template <class DB> bytes GenericTrieDB<DB>::cleve(RLP const& _orig, uint _s)
+template <class DB> bytes GenericTrieDB<DB>::cleve(RLP const& _orig, unsigned _s)
 {
 #if ETH_PARANOIA
 	tdebug << "cleve " << _orig << _s;
@@ -874,14 +884,14 @@ template <class DB> bytes GenericTrieDB<DB>::branch(RLP const& _orig)
 	if (k.size() == 0)
 	{
 		assert(isLeaf(_orig));
-		for (uint i = 0; i < 16; ++i)
+		for (unsigned i = 0; i < 16; ++i)
 			r << "";
 		r << _orig[1];
 	}
 	else
 	{
 		byte b = k[0];
-		for (uint i = 0; i < 16; ++i)
+		for (unsigned i = 0; i < 16; ++i)
 			if (i == b)
 				if (isLeaf(_orig) || k.size() > 1)
 				{
@@ -899,3 +909,5 @@ template <class DB> bytes GenericTrieDB<DB>::branch(RLP const& _orig)
 }
 
 }
+}
+

libethcore/All.h

@@ -3,10 +3,6 @@
 #include "BlockInfo.h"
 #include "CommonEth.h"
 #include "Dagger.h"
-#include "FileSystem.h"
-#include "MemoryDB.h"
-#include "OverlayDB.h"
-#include "SHA3.h"
-#include "TrieCommon.h"
-#include "TrieDB.h"
-#include "UPnP.h"
+#include "CryptoHeaders.h"
+#include "Exceptions.h"
+

libethcore/BlockInfo.cpp

@@ -21,16 +21,17 @@
 
 #if !ETH_LANGUAGES
 
-#include <libethential/Common.h>
-#include <libethential/RLP.h>
-#include <libethcore/TrieDB.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/RLP.h>
+#include <libdevcrypto/TrieDB.h>
 #include "Dagger.h"
 #include "Exceptions.h"
 #include "BlockInfo.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
-u256 eth::c_genesisDifficulty = (u256)1 << 22;
+u256 dev::eth::c_genesisDifficulty = (u256)1 << 17;
 
 BlockInfo::BlockInfo(): timestamp(Invalid256)
 {
@@ -64,8 +65,15 @@ void BlockInfo::fillStream(RLPStream& _s, bool _nonce) const
 		_s << nonce;
 }
 
+h256 BlockInfo::headerHash(bytesConstRef _block)
+{
+	return sha3(RLP(_block)[0].data());
+}
+
 void BlockInfo::populateFromHeader(RLP const& _header, bool _checkNonce)
 {
+	hash = dev::eth::sha3(_header.data());
+
 	int field = 0;
 	try
 	{
@@ -101,10 +109,9 @@ void BlockInfo::populateFromHeader(RLP const& _header, bool _checkNonce)
 
 void BlockInfo::populate(bytesConstRef _block, bool _checkNonce)
 {
-	hash = eth::sha3(_block);
-
 	RLP root(_block);
 	RLP header = root[0];
+
 	if (!header.isList())
 		throw InvalidBlockFormat(0, header.data());
 	populateFromHeader(header, _checkNonce);
@@ -166,7 +173,7 @@ u256 BlockInfo::calculateDifficulty(BlockInfo const& _parent) const
 	if (!parentHash)
 		return c_genesisDifficulty;
 	else
-		return timestamp >= _parent.timestamp + 42 ? _parent.difficulty - (_parent.difficulty >> 10) : (_parent.difficulty + (_parent.difficulty >> 10));
+		return timestamp >= _parent.timestamp + 5 ? _parent.difficulty - (_parent.difficulty >> 10) : (_parent.difficulty + (_parent.difficulty >> 10));
 }
 
 void BlockInfo::verifyParent(BlockInfo const& _parent) const
@@ -176,7 +183,7 @@ void BlockInfo::verifyParent(BlockInfo const& _parent) const
 		throw InvalidDifficulty();
 
 	if (gasLimit != calculateGasLimit(_parent))
-		throw InvalidGasLimit();
+		throw InvalidGasLimit(gasLimit, calculateGasLimit(_parent));
 
 	// Check timestamp is after previous timestamp.
 	if (parentHash)

libethcore/BlockInfo.h

@@ -21,10 +21,12 @@
 
 #pragma once
 
-#include <libethential/Common.h>
-#include <libethential/RLP.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/RLP.h>
 #include "CommonEth.h"
 
+namespace dev
+{
 namespace eth
 {
 
@@ -48,13 +50,13 @@ extern u256 c_genesisDifficulty;
  * and calculateGasLimit() and the object serialised to RLP with fillStream. To determine the
  * header hash without the nonce (for mining), the method headerHashWithoutNonce() is provided.
  *
- * The defualt constructor creates an empty object, which can be tested against with the boolean
+ * The default constructor creates an empty object, which can be tested against with the boolean
  * conversion operator.
  */
 struct BlockInfo
 {
 public:
-	h256 hash;						///< SHA3 hash of the entire block! Not serialised (the only member not contained in a block header).
+	h256 hash;						///< SHA3 hash of the block header! Not serialised (the only member not contained in a block header).
 	h256 parentHash;
 	h256 sha3Uncles;
 	Address coinbaseAddress;
@@ -73,6 +75,9 @@ public:
 	explicit BlockInfo(bytes const& _block): BlockInfo(&_block) {}
 	explicit BlockInfo(bytesConstRef _block);
 
+	static h256 headerHash(bytes const& _block) { return headerHash(&_block); }
+	static h256 headerHash(bytesConstRef _block);
+
 	static BlockInfo fromHeader(bytesConstRef _block);
 
 	explicit operator bool() const { return timestamp != Invalid256; }
@@ -118,5 +123,4 @@ inline std::ostream& operator<<(std::ostream& _out, BlockInfo const& _bi)
 }
 
 }
-
-
+}

libethcore/CMakeLists.txt

@@ -15,12 +15,10 @@ file(GLOB HEADERS "*.h")
 
 include_directories(..)
 
-target_link_libraries(${EXECUTABLE} ethential)
+target_link_libraries(${EXECUTABLE} devcrypto)
+target_link_libraries(${EXECUTABLE} devcore)
 target_link_libraries(${EXECUTABLE} secp256k1)
 target_link_libraries(${EXECUTABLE} gmp)
-if(MINIUPNPC_LS)
-target_link_libraries(${EXECUTABLE} ${MINIUPNPC_LS})
-endif()
 target_link_libraries(${EXECUTABLE} ${LEVELDB_LS})
 target_link_libraries(${EXECUTABLE} ${CRYPTOPP_LS})
 

libethcore/CommonEth.cpp

@@ -22,15 +22,20 @@
 #include "CommonEth.h"
 #include <random>
 #include <secp256k1/secp256k1.h>
-#include <libethcore/SHA3.h>
+#include <libdevcrypto/SHA3.h>
 #include "Exceptions.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
 //#define ETH_ADDRESS_DEBUG 1
+namespace dev
+{
+namespace eth
+{
 
-const unsigned eth::c_protocolVersion = 23;
-const unsigned eth::c_databaseVersion = 1;
+const unsigned c_protocolVersion = 33;
+const unsigned c_databaseVersion = 1;
 
 static const vector<pair<u256, string>> g_units =
 {
@@ -55,12 +60,12 @@ static const vector<pair<u256, string>> g_units =
 	{u256(1), "wei"}
 };
 
-vector<pair<u256, string>> const& eth::units()
+vector<pair<u256, string>> const& units()
 {
 	return g_units;
 }
 
-std::string eth::formatBalance(u256 _b)
+std::string formatBalance(u256 _b)
 {
 	ostringstream ret;
 	if (_b > g_units[0].first * 10000)
@@ -79,7 +84,7 @@ std::string eth::formatBalance(u256 _b)
 	return ret.str();
 }
 
-Address eth::toAddress(Secret _private)
+Address toAddress(Secret _private)
 {
 	secp256k1_start();
 
@@ -95,7 +100,7 @@ Address eth::toAddress(Secret _private)
 	ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65);
 	if (!ok)
 		return Address();
-	auto ret = right160(eth::sha3(bytesConstRef(&(pubkey[1]), 64)));
+	auto ret = right160(dev::eth::sha3(bytesConstRef(&(pubkey[1]), 64)));
 #if ETH_ADDRESS_DEBUG
 	cout << "---- ADDRESS -------------------------------" << endl;
 	cout << "SEC: " << _private << endl;
@@ -105,50 +110,4 @@ Address eth::toAddress(Secret _private)
 	return ret;
 }
 
-KeyPair KeyPair::create()
-{
-	secp256k1_start();
-	static std::mt19937_64 s_eng(time(0));
-	std::uniform_int_distribution<uint16_t> d(0, 255);
-
-	for (int i = 0; i < 100; ++i)
-	{
-		h256 sec;
-		for (unsigned i = 0; i < 32; ++i)
-			sec[i] = (byte)d(s_eng);
-
-		KeyPair ret(sec);
-		if (ret.address())
-			return ret;
-	}
-	return KeyPair();
-}
-
-KeyPair::KeyPair(h256 _sec):
-	m_secret(_sec)
-{
-	int ok = secp256k1_ecdsa_seckey_verify(m_secret.data());
-	if (!ok)
-		return;
-
-	byte pubkey[65];
-	int pubkeylen = 65;
-	ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, m_secret.data(), 0);
-	if (!ok || pubkeylen != 65)
-		return;
-
-	ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65);
-	if (!ok)
-		return;
-
-	m_secret = m_secret;
-	memcpy(m_public.data(), &(pubkey[1]), 64);
-	m_address = right160(eth::sha3(bytesConstRef(&(pubkey[1]), 64)));
-
-#if ETH_ADDRESS_DEBUG
-	cout << "---- ADDRESS -------------------------------" << endl;
-	cout << "SEC: " << m_secret << endl;
-	cout << "PUB: " << m_public << endl;
-	cout << "ADR: " << m_address << endl;
-#endif
-}
+}}

libethcore/CommonEth.h

@@ -23,9 +23,12 @@
 
 #pragma once
 
-#include <libethential/Common.h>
-#include <libethential/FixedHash.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/FixedHash.h>
+#include <libdevcrypto/Common.h>
 
+namespace dev
+{
 namespace eth
 {
 
@@ -35,21 +38,6 @@ extern const unsigned c_protocolVersion;
 /// Current database version.
 extern const unsigned c_databaseVersion;
 
-/// A secret key: 32 bytes.
-/// @NOTE This is not endian-specific; it's just a bunch of bytes.
-using Secret = h256;
-
-/// A public key: 64 bytes.
-/// @NOTE This is not endian-specific; it's just a bunch of bytes.
-using Public = h512;
-
-/// An Ethereum address: 20 bytes.
-/// @NOTE This is not endian-specific; it's just a bunch of bytes.
-using Address = h160;
-
-/// A vector of Ethereum addresses.
-using Addresses = h160s;
-
 /// User-friendly string representation of the amount _b in wei.
 std::string formatBalance(u256 _b);
 
@@ -77,43 +65,5 @@ static const u256 Mwei = u256(1000000);
 static const u256 Kwei = u256(1000);
 static const u256 wei = u256(1);
 
-/// Convert a private key into the public key equivalent.
-/// @returns 0 if it's not a valid private key.
-Address toAddress(h256 _private);
-
-/// Simple class that represents a "key pair".
-/// All of the data of the class can be regenerated from the secret key (m_secret) alone.
-/// Actually stores a tuplet of secret, public and address (the right 160-bits of the public).
-class KeyPair
-{
-public:
-	/// Null constructor.
-	KeyPair() {}
-
-	/// Normal constructor - populates object from the given secret key.
-	KeyPair(Secret _k);
-
-	/// Create a new, randomly generated object.
-	static KeyPair create();
-
-	/// Retrieve the secret key.
-	Secret const& secret() const { return m_secret; }
-	/// Retrieve the secret key.
-	Secret const& sec() const { return m_secret; }
-
-	/// Retrieve the public key.
-	Public const& pub() const { return m_public; }
-
-	/// Retrieve the associated address of the public key.
-	Address const& address() const { return m_address; }
-
-	bool operator==(KeyPair const& _c) const { return m_secret == _c.m_secret; }
-	bool operator!=(KeyPair const& _c) const { return m_secret != _c.m_secret; }
-
-private:
-	Secret m_secret;
-	Public m_public;
-	Address m_address;
-};
-
+}
 }

libethcore/Dagger.cpp

@@ -25,20 +25,23 @@
 #include <chrono>
 #include <array>
 #include <random>
+#include <thread>
 #include <libethcore/CryptoHeaders.h>
-#include <libethential/Common.h>
+#include <libdevcore/Common.h>
 #include "Dagger.h"
 using namespace std;
 using namespace std::chrono;
 
+namespace dev
+{
 namespace eth
 {
 
 #if FAKE_DAGGER
 
-MineInfo Dagger::mine(h256& o_solution, h256 const& _root, u256 const& _difficulty, uint _msTimeout, bool const& _continue)
+MineInfo Dagger::mine(h256& o_solution, h256 const& _root, u256 const& _difficulty, unsigned _msTimeout, bool _continue, bool _turbo)
 {
-	MineInfo ret{0.f, 1e99, 0, false};
+	MineInfo ret;
 	static std::mt19937_64 s_eng((time(0) + (unsigned)m_last));
 	u256 s = (m_last = h256::random(s_eng));
 
@@ -49,7 +52,10 @@ MineInfo Dagger::mine(h256& o_solution, h256 const& _root, u256 const& _difficul
 	//   [--------*-------------------------]
 	//
 	// evaluate until we run out of time
-	for (auto startTime = steady_clock::now(); (steady_clock::now() - startTime) < milliseconds(_msTimeout) && _continue; s++, ret.hashes++)
+	auto startTime = steady_clock::now();
+	if (!_turbo)
+		this_thread::sleep_for(chrono::milliseconds(_msTimeout * 90 / 100));
+	for (; (steady_clock::now() - startTime) < milliseconds(_msTimeout) && _continue; s++, ret.hashes++)
 	{
 		o_solution = (h256)s;
 		auto e = (bigint)(u256)eval(_root, o_solution);
@@ -87,7 +93,7 @@ bool Dagger::verify(h256 const& _root, u256 const& _nonce, u256 const& _difficul
 	return eval(_root, _nonce) < bound(_difficulty);
 }
 
-bool Dagger::mine(u256& o_solution, h256 const& _root, u256 const& _difficulty, uint _msTimeout, bool const& _continue)
+bool Dagger::mine(u256& o_solution, h256 const& _root, u256 const& _difficulty, unsigned _msTimeout, bool const& _continue)
 {
 	// restart search if root has changed
 	if (m_root != _root)
@@ -181,5 +187,5 @@ h256 Dagger::eval(h256 const& _root, u256 const& _nonce)
 
 #endif
 }
-
+}
 #endif

libethcore/Dagger.h

@@ -23,25 +23,23 @@
 
 #pragma once
 
-#include <libethcore/SHA3.h>
+#include <libdevcrypto/SHA3.h>
 #include "CommonEth.h"
 
 #define FAKE_DAGGER 1
 
-namespace eth
+namespace dev
 {
-
-inline uint toLog2(u256 _d)
+namespace eth
 {
-	return (uint)log2((double)_d);
-}
 
 struct MineInfo
 {
-	double requirement;
-	double best;
-	uint hashes;
-	bool completed;
+	void combine(MineInfo const& _m) { requirement = std::max(requirement, _m.requirement); best = std::min(best, _m.best); hashes += _m.hashes; completed = completed || _m.completed; }
+	double requirement = 0;
+	double best = 1e99;
+	unsigned hashes = 0;
+	bool completed = false;
 };
 
 #if FAKE_DAGGER
@@ -52,7 +50,7 @@ public:
 	static h256 eval(h256 const& _root, h256 const& _nonce) { h256 b[2] = { _root, _nonce }; return sha3(bytesConstRef((byte const*)&b[0], 64)); }
 	static bool verify(h256 const& _root, h256 const& _nonce, u256 const& _difficulty) { return (bigint)(u256)eval(_root, _nonce) <= (bigint(1) << 256) / _difficulty; }
 
-	MineInfo mine(h256& o_solution, h256 const& _root, u256 const& _difficulty, uint _msTimeout = 100, bool const& _continue = bool(true));
+	MineInfo mine(h256& o_solution, h256 const& _root, u256 const& _difficulty, unsigned _msTimeout = 100, bool _continue = true, bool _turbo = false);
 
 	h256 m_last;
 };
@@ -70,7 +68,7 @@ public:
 	static h256 eval(h256 const& _root, u256 const& _nonce);
 	static bool verify(h256 const& _root, u256 const& _nonce, u256 const& _difficulty);
 
-	bool mine(u256& o_solution, h256 const& _root, u256 const& _difficulty, uint _msTimeout = 100, bool const& _continue = bool(true));
+	bool mine(u256& o_solution, h256 const& _root, u256 const& _difficulty, unsigned _msTimeout = 100, bool const& _continue = bool(true));
 
 private:
 
@@ -83,5 +81,4 @@ private:
 #endif
 
 }
-
-
+}

libethcore/Exceptions.h

@@ -1,40 +1,46 @@
 #pragma once
 
-#include <libethential/Exceptions.h>
+#include <libdevcore/Exceptions.h>
 
+namespace dev
+{
 namespace eth
 {
 
-class NotEnoughCash: public Exception {};
+class DatabaseAlreadyOpen: public dev::Exception {};
+
+class NotEnoughCash: public dev::Exception {};
 
-class GasPriceTooLow: public Exception {};
-class BlockGasLimitReached: public Exception {};
-class NoSuchContract: public Exception {};
-class ContractAddressCollision: public Exception {};
-class FeeTooSmall: public Exception {};
-class TooMuchGasUsed: public Exception {};
-class ExtraDataTooBig: public Exception {};
-class InvalidSignature: public Exception {};
-class InvalidTransactionFormat: public Exception { public: InvalidTransactionFormat(int _f, bytesConstRef _d): m_f(_f), m_d(_d.toBytes()) {} int m_f; bytes m_d; virtual std::string description() const { return "Invalid transaction format: Bad field " + toString(m_f) + " (" + toHex(m_d) + ")"; } };
-class InvalidBlockFormat: public Exception { public: InvalidBlockFormat(int _f, bytesConstRef _d): m_f(_f), m_d(_d.toBytes()) {} int m_f; bytes m_d; virtual std::string description() const { return "Invalid block format: Bad field " + toString(m_f) + " (" + toHex(m_d) + ")"; } };
-class InvalidBlockHeaderFormat: public Exception { public: InvalidBlockHeaderFormat(int _f, bytesConstRef _d): m_f(_f), m_d(_d.toBytes()) {} int m_f; bytes m_d; virtual std::string description() const { return "Invalid block header format: Bad field " + toString(m_f) + " (" + toHex(m_d) + ")"; } };
-class InvalidUnclesHash: public Exception {};
-class InvalidUncle: public Exception {};
-class UncleNotAnUncle: public Exception {};
-class DuplicateUncleNonce: public Exception {};
-class InvalidStateRoot: public Exception {};
-class InvalidTransactionsHash: public Exception { public: InvalidTransactionsHash(h256 _head, h256 _real): m_head(_head), m_real(_real) {} h256 m_head; h256 m_real; virtual std::string description() const { return "Invalid transactions hash:  header says: " + toHex(m_head.ref()) + " block is:" + toHex(m_real.ref()); } };
-class InvalidTransaction: public Exception {};
-class InvalidDifficulty: public Exception {};
-class InvalidGasLimit: public Exception {};
-class InvalidMinGasPrice: public Exception { public: InvalidMinGasPrice(u256 _provided = 0, u256 _limit = 0): provided(_provided), limit(_limit) {} u256 provided; u256 limit; virtual std::string description() const { return "Invalid minimum gas price (provided: " + toString(provided) + " limit:" + toString(limit) + ")"; } };
-class InvalidTransactionGasUsed: public Exception {};
-class InvalidTransactionStateRoot: public Exception {};
-class InvalidTimestamp: public Exception {};
-class InvalidNonce: public Exception { public: InvalidNonce(u256 _required = 0, u256 _candidate = 0): required(_required), candidate(_candidate) {} u256 required; u256 candidate; virtual std::string description() const { return "Invalid nonce (r: " + toString(required) + " c:" + toString(candidate) + ")"; } };
-class InvalidBlockNonce: public Exception { public: InvalidBlockNonce(h256 _h = h256(), h256 _n = h256(), u256 _d = 0): h(_h), n(_n), d(_d) {} h256 h; h256 n; u256 d; virtual std::string description() const { return "Invalid nonce (h: " + toString(h) + " n:" + toString(n) + " d:" + toString(d) + ")"; } };
-class InvalidParentHash: public Exception {};
-class InvalidNumber: public Exception {};
-class InvalidContractAddress: public Exception {};
+class GasPriceTooLow: public dev::Exception {};
+class BlockGasLimitReached: public dev::Exception {};
+class NoSuchContract: public dev::Exception {};
+class ContractAddressCollision: public dev::Exception {};
+class FeeTooSmall: public dev::Exception {};
+class TooMuchGasUsed: public dev::Exception {};
+class ExtraDataTooBig: public dev::Exception {};
+class InvalidSignature: public dev::Exception {};
+class InvalidTransactionFormat: public dev::Exception { public: InvalidTransactionFormat(int _f, bytesConstRef _d): m_f(_f), m_d(_d.toBytes()) {} int m_f; bytes m_d; virtual std::string description() const { return "Invalid transaction format: Bad field " + toString(m_f) + " (" + toHex(m_d) + ")"; } };
+class InvalidBlockFormat: public dev::Exception { public: InvalidBlockFormat(int _f, bytesConstRef _d): m_f(_f), m_d(_d.toBytes()) {} int m_f; bytes m_d; virtual std::string description() const { return "Invalid block format: Bad field " + toString(m_f) + " (" + toHex(m_d) + ")"; } };
+class InvalidBlockHeaderFormat: public dev::Exception { public: InvalidBlockHeaderFormat(int _f, bytesConstRef _d): m_f(_f), m_d(_d.toBytes()) {} int m_f; bytes m_d; virtual std::string description() const { return "Invalid block header format: Bad field " + toString(m_f) + " (" + toHex(m_d) + ")"; } };
+class InvalidUnclesHash: public dev::Exception {};
+class InvalidUncle: public dev::Exception {};
+class UncleTooOld: public dev::Exception {};
+class UncleInChain: public dev::Exception {};
+class DuplicateUncleNonce: public dev::Exception {};
+class InvalidStateRoot: public dev::Exception {};
+class InvalidTransactionsHash: public dev::Exception { public: InvalidTransactionsHash(h256 _head, h256 _real): m_head(_head), m_real(_real) {} h256 m_head; h256 m_real; virtual std::string description() const { return "Invalid transactions hash:  header says: " + toHex(m_head.ref()) + " block is:" + toHex(m_real.ref()); } };
+class InvalidTransaction: public dev::Exception {};
+class InvalidDifficulty: public dev::Exception {};
+class InvalidGasLimit: public dev::Exception { public: InvalidGasLimit(u256 _provided = 0, u256 _valid = 0): provided(_provided), valid(_valid) {} u256 provided; u256 valid; virtual std::string description() const { return "Invalid gas limit (provided: " + toString(provided) + " valid:" + toString(valid) + ")"; } };
+class InvalidMinGasPrice: public dev::Exception { public: InvalidMinGasPrice(u256 _provided = 0, u256 _limit = 0): provided(_provided), limit(_limit) {} u256 provided; u256 limit; virtual std::string description() const { return "Invalid minimum gas price (provided: " + toString(provided) + " limit:" + toString(limit) + ")"; } };
+class InvalidTransactionGasUsed: public dev::Exception {};
+class InvalidTransactionStateRoot: public dev::Exception {};
+class InvalidTimestamp: public dev::Exception {};
+class InvalidNonce: public dev::Exception { public: InvalidNonce(u256 _required = 0, u256 _candidate = 0): required(_required), candidate(_candidate) {} u256 required; u256 candidate; virtual std::string description() const { return "Invalid nonce (r: " + toString(required) + " c:" + toString(candidate) + ")"; } };
+class InvalidBlockNonce: public dev::Exception { public: InvalidBlockNonce(h256 _h = h256(), h256 _n = h256(), u256 _d = 0): h(_h), n(_n), d(_d) {} h256 h; h256 n; u256 d; virtual std::string description() const { return "Invalid nonce (h: " + toString(h) + " n:" + toString(n) + " d:" + toString(d) + ")"; } };
+class InvalidParentHash: public dev::Exception {};
+class InvalidNumber: public dev::Exception {};
+class InvalidContractAddress: public dev::Exception {};
 
 }
+}

libethcore/_libethcore.cpp

@@ -0,0 +1,6 @@
+#ifdef _MSC_VER
+#include "All.h"
+#include "BlockInfo.cpp"
+#include "CommonEth.cpp"
+#include "Dagger.cpp"
+#endif

libethential/CommonData.cpp

@@ -1,104 +0,0 @@
-/*
-	This file is part of cpp-ethereum.
-
-	cpp-ethereum 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.
-
-	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/** @file Common.cpp
- * @author Gav Wood <i@gavwood.com>
- * @date 2014
- */
-
-#include "CommonData.h"
-
-#include <random>
-#include "Exceptions.h"
-using namespace std;
-using namespace eth;
-
-std::string eth::escaped(std::string const& _s, bool _all)
-{
-	std::string ret;
-	ret.reserve(_s.size());
-	ret.push_back('"');
-	for (auto i: _s)
-		if (i == '"' && !_all)
-			ret += "\\\"";
-		else if (i == '\\' && !_all)
-			ret += "\\\\";
-		else if (i < ' ' || _all)
-		{
-			ret += "\\x";
-			ret.push_back("0123456789abcdef"[(uint8_t)i / 16]);
-			ret.push_back("0123456789abcdef"[(uint8_t)i % 16]);
-		}
-		else
-			ret.push_back(i);
-	ret.push_back('"');
-	return ret;
-}
-
-std::string eth::randomWord()
-{
-	static std::mt19937_64 s_eng(0);
-	std::string ret(std::uniform_int_distribution<int>(1, 5)(s_eng), ' ');
-	char const n[] = "qwertyuiop";//asdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
-	std::uniform_int_distribution<int> d(0, sizeof(n) - 2);
-	for (char& c: ret)
-		c = n[d(s_eng)];
-	return ret;
-}
-
-int eth::fromHex(char _i)
-{
-	if (_i >= '0' && _i <= '9')
-		return _i - '0';
-	if (_i >= 'a' && _i <= 'f')
-		return _i - 'a' + 10;
-	if (_i >= 'A' && _i <= 'F')
-		return _i - 'A' + 10;
-	throw BadHexCharacter();
-}
-
-bytes eth::fromHex(std::string const& _s)
-{
-	uint s = (_s[0] == '0' && _s[1] == 'x') ? 2 : 0;
-	std::vector<uint8_t> ret;
-	ret.reserve((_s.size() - s + 1) / 2);
-
-	if (_s.size() % 2)
-		try
-		{
-			ret.push_back(fromHex(_s[s++]));
-		}
-		catch (...){ ret.push_back(0); }
-	for (uint i = s; i < _s.size(); i += 2)
-		try
-		{
-			ret.push_back((byte)(fromHex(_s[i]) * 16 + fromHex(_s[i + 1])));
-		}
-		catch (...){ ret.push_back(0); }
-	return ret;
-}
-
-bytes eth::asNibbles(std::string const& _s)
-{
-	std::vector<uint8_t> ret;
-	ret.reserve(_s.size() * 2);
-	for (auto i: _s)
-	{
-		ret.push_back(i / 16);
-		ret.push_back(i % 16);
-	}
-	return ret;
-}

libethereum/AccountDiff.cpp

@@ -0,0 +1,84 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file AccountDiff.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "AccountDiff.h"
+
+#include <libdevcore/CommonIO.h>
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+AccountChange AccountDiff::changeType() const
+{
+	bool bn = (balance || nonce);
+	bool sc = (!storage.empty() || code);
+	return exist ? exist.from() ? AccountChange::Deletion : AccountChange::Creation : (bn && sc) ? AccountChange::All : bn ? AccountChange::Intrinsic: sc ? AccountChange::CodeStorage : AccountChange::None;
+}
+
+char const* AccountDiff::lead() const
+{
+	bool bn = (balance || nonce);
+	bool sc = (!storage.empty() || code);
+	return exist ? exist.from() ? "XXX" : "+++" : (bn && sc) ? "***" : bn ? " * " : sc ? "* *" : "   ";
+}
+
+namespace dev {
+
+std::ostream& operator<<(std::ostream& _out, dev::eth::AccountDiff const& _s)
+{
+	if (!_s.exist.to())
+		return _out;
+
+	if (_s.nonce)
+	{
+		_out << std::dec << "#" << _s.nonce.to() << " ";
+		if (_s.nonce.from())
+			_out << "(" << std::showpos << (((bigint)_s.nonce.to()) - ((bigint)_s.nonce.from())) << std::noshowpos << ") ";
+	}
+	if (_s.balance)
+	{
+		_out << std::dec << _s.balance.to() << " ";
+		if (_s.balance.from())
+			_out << "(" << std::showpos << (((bigint)_s.balance.to()) - ((bigint)_s.balance.from())) << std::noshowpos << ") ";
+	}
+	if (_s.code)
+		_out << "$" << std::hex << nouppercase << _s.code.to() << " (" << _s.code.from() << ") ";
+	for (pair<u256, Diff<u256>> const& i: _s.storage)
+		if (!i.second.from())
+			_out << endl << " +     " << (h256)i.first << ": " << std::hex << nouppercase << i.second.to();
+		else if (!i.second.to())
+			_out << endl << "XXX    " << (h256)i.first << " (" << std::hex << nouppercase << i.second.from() << ")";
+		else
+			_out << endl << " *     " << (h256)i.first << ": " << std::hex << nouppercase << i.second.to() << " (" << i.second.from() << ")";
+	return _out;
+}
+
+std::ostream& operator<<(std::ostream& _out, dev::eth::StateDiff const& _s)
+{
+	_out << _s.accounts.size() << " accounts changed:" << endl;
+	dev::eth::AccountDiff d;
+	_out << d;
+	for (auto const& i: _s.accounts)
+		_out << i.second.lead() << "  " << i.first << ": " << i.second << endl;
+	return _out;
+}
+
+}

libethereum/AccountDiff.h

@@ -0,0 +1,76 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file AccountDiff.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#pragma once
+
+#include <libdevcore/Common.h>
+#include <libethcore/CommonEth.h>
+
+namespace dev
+{
+namespace eth
+{
+
+enum class ExistDiff { Same, New, Dead };
+template <class T>
+class Diff
+{
+public:
+	Diff() {}
+	Diff(T _from, T _to): m_from(_from), m_to(_to) {}
+
+	T const& from() const { return m_from; }
+	T const& to() const { return m_to; }
+
+	explicit operator bool() const { return m_from != m_to; }
+
+private:
+	T m_from;
+	T m_to;
+};
+
+enum class AccountChange { None, Creation, Deletion, Intrinsic, CodeStorage, All };
+
+struct AccountDiff
+{
+	inline bool changed() const { return storage.size() || code || nonce || balance || exist; }
+	char const* lead() const;
+	AccountChange changeType() const;
+
+	Diff<bool> exist;
+	Diff<u256> balance;
+	Diff<u256> nonce;
+	std::map<u256, Diff<u256>> storage;
+	Diff<bytes> code;
+};
+
+struct StateDiff
+{
+	std::map<Address, AccountDiff> accounts;
+};
+
+}
+
+std::ostream& operator<<(std::ostream& _out, dev::eth::StateDiff const& _s);
+std::ostream& operator<<(std::ostream& _out, dev::eth::AccountDiff const& _s);
+
+}
+

libethereum/AddressState.cpp

@@ -22,7 +22,8 @@
 #include "AddressState.h"
 #include <libethcore/CommonEth.h>
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
 #pragma GCC diagnostic ignored "-Wunused-variable"
 namespace { char dummy; };

libethereum/AddressState.h

@@ -21,10 +21,12 @@
 
 #pragma once
 
-#include <libethential/Common.h>
-#include <libethential/RLP.h>
-#include <libethcore/SHA3.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/RLP.h>
+#include <libdevcrypto/SHA3.h>
 
+namespace dev
+{
 namespace eth
 {
 
@@ -61,7 +63,6 @@ public:
 
 private:
 	bool m_isAlive;
-	bool m_gotCode;
 	u256 m_nonce;
 	u256 m_balance;
 
@@ -79,5 +80,5 @@ private:
 };
 
 }
-
+}
 

libethereum/All.h

@@ -6,9 +6,10 @@
 #include "Defaults.h"
 #include "Executive.h"
 #include "ExtVM.h"
-#include "PeerNetwork.h"
-#include "PeerServer.h"
-#include "PeerSession.h"
+#include "CommonNet.h"
+#include "EthereumHost.h"
+#include "EthereumPeer.h"
 #include "State.h"
 #include "Transaction.h"
 #include "TransactionQueue.h"
+#include "Utility.h"

libethereum/BlockChain.cpp

@@ -22,25 +22,23 @@
 #include "BlockChain.h"
 
 #include <boost/filesystem.hpp>
-#include <libethential/Common.h>
-#include <libethential/RLP.h>
-#include <libethcore/FileSystem.h>
+#include <libdevcore/Common.h>
+#include <libdevcore/RLP.h>
+#include <libdevcrypto/FileSystem.h>
 #include <libethcore/Exceptions.h>
 #include <libethcore/Dagger.h>
 #include <libethcore/BlockInfo.h>
 #include "State.h"
 #include "Defaults.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
 #define ETH_CATCH 1
 
-namespace eth
+std::ostream& dev::eth::operator<<(std::ostream& _out, BlockChain const& _bc)
 {
-
-std::ostream& operator<<(std::ostream& _out, BlockChain const& _bc)
-{
-	string cmp = toBigEndianString(_bc.m_lastBlockHash);
+	string cmp = toBigEndianString(_bc.currentHash());
 	auto it = _bc.m_extrasDB->NewIterator(_bc.m_readOptions);
 	for (it->SeekToFirst(); it->Valid(); it->Next())
 		if (it->key().ToString() != "best")
@@ -51,23 +49,8 @@ std::ostream& operator<<(std::ostream& _out, BlockChain const& _bc)
 	delete it;
 	return _out;
 }
-}
-
-BlockDetails::BlockDetails(RLP const& _r)
-{
-	number = _r[0].toInt<uint>();
-	totalDifficulty = _r[1].toInt<u256>();
-	parent = _r[2].toHash<h256>();
-	children = _r[3].toVector<h256>();
-	bloom = _r[4].toHash<h256>();
-}
 
-bytes BlockDetails::rlp() const
-{
-	return rlpList(number, totalDifficulty, parent, children, bloom);
-}
-
-std::map<Address, AddressState> const& eth::genesisState()
+std::map<Address, AddressState> const& dev::eth::genesisState()
 {
 	static std::map<Address, AddressState> s_ret;
 	if (s_ret.empty())
@@ -87,6 +70,21 @@ std::map<Address, AddressState> const& eth::genesisState()
 }
 
 BlockInfo* BlockChain::s_genesis = nullptr;
+boost::shared_mutex BlockChain::x_genesis;
+
+ldb::Slice dev::eth::toSlice(h256 _h, unsigned _sub)
+{
+#if ALL_COMPILERS_ARE_CPP11_COMPLIANT
+	static thread_local h256 h = _h ^ h256(u256(_sub));
+	return ldb::Slice((char const*)&h, 32);
+#else
+	static boost::thread_specific_ptr<h256> t_h;
+	if (!t_h.get())
+		t_h.reset(new h256);
+	*t_h = _h ^ h256(u256(_sub));
+	return ldb::Slice((char const*)t_h.get(), 32);
+#endif
+}
 
 bytes BlockChain::createGenesisBlock()
 {
@@ -98,18 +96,32 @@ bytes BlockChain::createGenesisBlock()
 		MemoryDB db;
 		TrieDB<Address, MemoryDB> state(&db);
 		state.init();
-		eth::commit(genesisState(), db, state);
+		dev::eth::commit(genesisState(), db, state);
 		stateRoot = state.root();
 	}
 
 	block.appendList(13) << h256() << sha3EmptyList << h160();
-	block.append(stateRoot, false, true) << bytes() << c_genesisDifficulty << 0 << 0 << 1000000 << 0 << (uint)0 << string() << sha3(bytes(1, 42));
+	block.append(stateRoot, false, true) << bytes() << c_genesisDifficulty << 0 << 0 << 1000000 << 0 << (unsigned)0 << string() << sha3(bytes(1, 42));
 	block.appendRaw(RLPEmptyList);
 	block.appendRaw(RLPEmptyList);
 	return block.out();
 }
 
 BlockChain::BlockChain(std::string _path, bool _killExisting)
+{
+	// Initialise with the genesis as the last block on the longest chain.
+	m_genesisHash = BlockChain::genesis().hash;
+	m_genesisBlock = BlockChain::createGenesisBlock();
+
+	open(_path, _killExisting);
+}
+
+BlockChain::~BlockChain()
+{
+	close();
+}
+
+void BlockChain::open(std::string _path, bool _killExisting)
 {
 	if (_path.empty())
 		_path = Defaults::get()->m_dbPath;
@@ -122,21 +134,19 @@ BlockChain::BlockChain(std::string _path, bool _killExisting)
 
 	ldb::Options o;
 	o.create_if_missing = true;
-	auto s = ldb::DB::Open(o, _path + "/blocks", &m_db);
-	assert(m_db);
-	s = ldb::DB::Open(o, _path + "/details", &m_extrasDB);
-	assert(m_extrasDB);
-
-	// Initialise with the genesis as the last block on the longest chain.
-	m_genesisHash = BlockChain::genesis().hash;
-	m_genesisBlock = BlockChain::createGenesisBlock();
+	ldb::DB::Open(o, _path + "/blocks", &m_db);
+	ldb::DB::Open(o, _path + "/details", &m_extrasDB);
+	if (!m_db)
+		throw DatabaseAlreadyOpen();
+	if (!m_extrasDB)
+		throw DatabaseAlreadyOpen();
 
 	if (!details(m_genesisHash))
 	{
 		// Insert details of genesis block.
 		m_details[m_genesisHash] = BlockDetails(0, c_genesisDifficulty, h256(), {}, h256());
 		auto r = m_details[m_genesisHash].rlp();
-		m_extrasDB->Put(m_writeOptions, ldb::Slice((char const*)&m_genesisHash, 32), (ldb::Slice)eth::ref(r));
+		m_extrasDB->Put(m_writeOptions, ldb::Slice((char const*)&m_genesisHash, 32), (ldb::Slice)dev::ref(r));
 	}
 
 	checkConsistency();
@@ -144,16 +154,22 @@ BlockChain::BlockChain(std::string _path, bool _killExisting)
 	// TODO: Implement ability to rebuild details map from DB.
 	std::string l;
 	m_extrasDB->Get(m_readOptions, ldb::Slice("best"), &l);
+
 	m_lastBlockHash = l.empty() ? m_genesisHash : *(h256*)l.data();
 
-	cnote << "Opened blockchain DB. Latest: " << m_lastBlockHash;
+	cnote << "Opened blockchain DB. Latest: " << currentHash();
 }
 
-BlockChain::~BlockChain()
+void BlockChain::close()
 {
 	cnote << "Closing blockchain DB";
 	delete m_extrasDB;
 	delete m_db;
+	m_lastBlockHash = m_genesisHash;
+	m_details.clear();
+	m_blooms.clear();
+	m_traces.clear();
+	m_cache.clear();
 }
 
 template <class T, class V>
@@ -165,38 +181,64 @@ bool contains(T const& _t, V const& _v)
 	return false;
 }
 
-bool BlockChain::attemptImport(bytes const& _block, OverlayDB const& _stateDB)
+inline string toString(h256s const& _bs)
+{
+	ostringstream out;
+	out << "[ ";
+	for (auto i: _bs)
+		out << i.abridged() << ", ";
+	out << "]";
+	return out.str();
+}
+
+h256s BlockChain::sync(BlockQueue& _bq, OverlayDB const& _stateDB, unsigned _max)
+{
+	_bq.tick(*this);
+
+	vector<bytes> blocks;
+	_bq.drain(blocks);
+
+	h256s ret;
+	for (auto const& block: blocks)
+	{
+		try
+		{
+			for (auto h: import(block, _stateDB))
+				if (!_max--)
+					break;
+				else
+					ret.push_back(h);
+		}
+		catch (UnknownParent)
+		{
+			cwarn << "Unknown parent of block!!!" << BlockInfo::headerHash(block).abridged();
+			_bq.import(&block, *this);
+		}
+		catch (Exception const& _e)
+		{
+			cwarn << "Unexpected exception!" << _e.description();
+			_bq.import(&block, *this);
+		}
+		catch (...)
+		{}
+	}
+	_bq.doneDrain();
+	return ret;
+}
+
+h256s BlockChain::attemptImport(bytes const& _block, OverlayDB const& _stateDB) noexcept
 {
-#if ETH_CATCH
 	try
-#endif
 	{
-		import(_block, _stateDB);
-		return true;
+		return import(_block, _stateDB);
 	}
-#if ETH_CATCH
 	catch (...)
 	{
-		return false;
+		return h256s();
 	}
-#endif
 }
 
-inline ldb::Slice toSlice(h256 _h, unsigned _sub = 0)
-{
-#if ALL_COMPILERS_ARE_CPP11_COMPLIANT
-	static thread_local h256 h = _h ^ h256(u256(_sub));
-	return ldb::Slice((char const*)&h, 32);
-#else
-	static boost::thread_specific_ptr<h256> t_h;
-	if (!t_h.get())
-		t_h.reset(new h256);
-	*t_h = _h ^ h256(u256(_sub));
-	return ldb::Slice((char const*)t_h.get(), 32);
-#endif
-}
-
-void BlockChain::import(bytes const& _block, OverlayDB const& _db)
+h256s BlockChain::import(bytes const& _block, OverlayDB const& _db)
 {
 	// VERIFY: populates from the block and checks the block is internally coherent.
 	BlockInfo bi;
@@ -215,33 +257,35 @@ void BlockChain::import(bytes const& _block, OverlayDB const& _db)
 		throw;
 	}
 #endif
-	auto newHash = eth::sha3(_block);
+	auto newHash = BlockInfo::headerHash(_block);
 
 	// Check block doesn't already exist first!
-	if (details(newHash))
+	if (isKnown(newHash))
 	{
 		clog(BlockChainNote) << newHash << ": Not new.";
 		throw AlreadyHaveBlock();
 	}
 
 	// Work out its number as the parent's number + 1
-	auto pd = details(bi.parentHash);
-	if (!pd)
+	if (!isKnown(bi.parentHash))
 	{
 		clog(BlockChainNote) << newHash << ": Unknown parent " << bi.parentHash;
 		// We don't know the parent (yet) - discard for now. It'll get resent to us if we find out about its ancestry later on.
 		throw UnknownParent();
 	}
 
+	auto pd = details(bi.parentHash);
+	assert(pd);
+
 	// Check it's not crazy
 	if (bi.timestamp > (u256)time(0))
 	{
 		clog(BlockChainNote) << newHash << ": Future time " << bi.timestamp << " (now at " << time(0) << ")";
-		// We don't know the parent (yet) - discard for now. It'll get resent to us if we find out about its ancestry later on.
+		// Block has a timestamp in the future. This is no good.
 		throw FutureTime();
 	}
 
-	clog(BlockChainNote) << "Attempting import of " << newHash << "...";
+	clog(BlockChainNote) << "Attempting import of " << newHash.abridged() << "...";
 
 	u256 td;
 #if ETH_CATCH
@@ -268,17 +312,23 @@ void BlockChain::import(bytes const& _block, OverlayDB const& _db)
 #endif
 		// All ok - insert into DB
 		{
-			lock_guard<recursive_mutex> l(m_lock);
-			m_details[newHash] = BlockDetails((uint)pd.number + 1, td, bi.parentHash, {}, b);
+			WriteGuard l(x_details);
+			m_details[newHash] = BlockDetails((unsigned)pd.number + 1, td, bi.parentHash, {}, b);
 			m_details[bi.parentHash].children.push_back(newHash);
+		}
+		{
+			WriteGuard l(x_blooms);
 			m_blooms[newHash] = bb;
+		}
+		{
+			WriteGuard l(x_traces);
 			m_traces[newHash] = bt;
 		}
 
-		m_extrasDB->Put(m_writeOptions, toSlice(newHash), (ldb::Slice)eth::ref(m_details[newHash].rlp()));
-		m_extrasDB->Put(m_writeOptions, toSlice(bi.parentHash), (ldb::Slice)eth::ref(m_details[bi.parentHash].rlp()));
-		m_extrasDB->Put(m_writeOptions, toSlice(newHash, 1), (ldb::Slice)eth::ref(m_blooms[newHash].rlp()));
-		m_extrasDB->Put(m_writeOptions, toSlice(newHash, 2), (ldb::Slice)eth::ref(m_traces[newHash].rlp()));
+		m_extrasDB->Put(m_writeOptions, toSlice(newHash), (ldb::Slice)dev::ref(m_details[newHash].rlp()));
+		m_extrasDB->Put(m_writeOptions, toSlice(bi.parentHash), (ldb::Slice)dev::ref(m_details[bi.parentHash].rlp()));
+		m_extrasDB->Put(m_writeOptions, toSlice(newHash, 1), (ldb::Slice)dev::ref(m_blooms[newHash].rlp()));
+		m_extrasDB->Put(m_writeOptions, toSlice(newHash, 2), (ldb::Slice)dev::ref(m_traces[newHash].rlp()));
 		m_db->Put(m_writeOptions, toSlice(newHash), (ldb::Slice)ref(_block));
 
 #if ETH_PARANOIA
@@ -295,22 +345,78 @@ void BlockChain::import(bytes const& _block, OverlayDB const& _db)
 
 //	cnote << "Parent " << bi.parentHash << " has " << details(bi.parentHash).children.size() << " children.";
 
+	h256s ret;
 	// This might be the new best block...
-	if (td > details(m_lastBlockHash).totalDifficulty)
+	h256 last = currentHash();
+	if (td > details(last).totalDifficulty)
 	{
-		m_lastBlockHash = newHash;
+		ret = treeRoute(last, newHash);
+		{
+			WriteGuard l(x_lastBlockHash);
+			m_lastBlockHash = newHash;
+		}
 		m_extrasDB->Put(m_writeOptions, ldb::Slice("best"), ldb::Slice((char const*)&newHash, 32));
-		clog(BlockChainNote) << "   Imported and best. Has" << (details(bi.parentHash).children.size() - 1) << "siblings.";
+		clog(BlockChainNote) << "   Imported and best" << td << ". Has" << (details(bi.parentHash).children.size() - 1) << "siblings. Route:" << toString(ret);
 	}
 	else
 	{
-		clog(BlockChainNote) << "   Imported but not best (oTD:" << details(m_lastBlockHash).totalDifficulty << ", TD:" << td << ")";
+		clog(BlockChainNote) << "   Imported but not best (oTD:" << details(last).totalDifficulty << " > TD:" << td << ")";
 	}
+	return ret;
+}
+
+h256s BlockChain::treeRoute(h256 _from, h256 _to, h256* o_common, bool _pre, bool _post) const
+{
+//	cdebug << "treeRoute" << _from.abridged() << "..." << _to.abridged();
+	if (!_from || !_to)
+	{
+		return h256s();
+	}
+	h256s ret;
+	h256s back;
+	unsigned fn = details(_from).number;
+	unsigned tn = details(_to).number;
+//	cdebug << "treeRoute" << fn << "..." << tn;
+	while (fn > tn)
+	{
+		if (_pre)
+			ret.push_back(_from);
+		_from = details(_from).parent;
+		fn--;
+//		cdebug << "from:" << fn << _from.abridged();
+	}
+	while (fn < tn)
+	{
+		if (_post)
+			back.push_back(_to);
+		_to = details(_to).parent;
+		tn--;
+//		cdebug << "to:" << tn << _to.abridged();
+	}
+	while (_from != _to)
+	{
+		assert(_from);
+		assert(_to);
+		_from = details(_from).parent;
+		_to = details(_to).parent;
+		if (_pre)
+			ret.push_back(_from);
+		if (_post)
+			back.push_back(_to);
+		fn--;
+		tn--;
+//		cdebug << "from:" << fn << _from.abridged() << "; to:" << tn << _to.abridged();
+	}
+	if (o_common)
+		*o_common = _from;
+	ret.reserve(ret.size() + back.size());
+	for (auto it = back.cbegin(); it != back.cend(); ++it)
+		ret.push_back(*it);
+	return ret;
 }
 
 void BlockChain::checkConsistency()
 {
-	lock_guard<recursive_mutex> l(m_lock);
 	m_details.clear();
 	ldb::Iterator* it = m_db->NewIterator(m_readOptions);
 	for (it->SeekToFirst(); it->Valid(); it->Next())
@@ -329,34 +435,59 @@ void BlockChain::checkConsistency()
 	delete it;
 }
 
+h256Set BlockChain::allUnclesFrom(h256 _parent) const
+{
+	// Get all uncles cited given a parent (i.e. featured as uncles/main in parent, parent + 1, ... parent + 5).
+	h256Set ret;
+	h256 p = _parent;
+	for (unsigned i = 0; i < 6 && p != m_genesisHash; ++i, p = details(p).parent)
+	{
+		ret.insert(p);		// TODO: check: should this be details(p).parent?
+		for (auto i: RLP(block(p))[2])
+			ret.insert(sha3(i.data()));
+	}
+	return ret;
+}
+
+bool BlockChain::isKnown(h256 _hash) const
+{
+	if (_hash == m_genesisHash)
+		return true;
+	{
+		ReadGuard l(x_cache);
+		if (m_cache.count(_hash))
+			return true;
+	}
+	string d;
+	m_db->Get(m_readOptions, ldb::Slice((char const*)&_hash, 32), &d);
+	return !!d.size();
+}
+
 bytes BlockChain::block(h256 _hash) const
 {
 	if (_hash == m_genesisHash)
 		return m_genesisBlock;
 
-	lock_guard<recursive_mutex> l(m_lock);
-
-	auto it = m_cache.find(_hash);
-	if (it != m_cache.end())
-		return it->second;
+	{
+		ReadGuard l(x_cache);
+		auto it = m_cache.find(_hash);
+		if (it != m_cache.end())
+			return it->second;
+	}
 
 	string d;
 	m_db->Get(m_readOptions, ldb::Slice((char const*)&_hash, 32), &d);
 
+	WriteGuard l(x_cache);
 	m_cache[_hash].resize(d.size());
 	memcpy(m_cache[_hash].data(), d.data(), d.size());
 
 	if (!d.size())
-		cwarn << "Couldn't find requested block:" << _hash;
+		cwarn << "Couldn't find requested block:" << _hash.abridged();
 
 	return m_cache[_hash];
 }
 
-eth::uint BlockChain::number(h256 _hash) const
-{
-	return details(_hash).number;
-}
-
 h256 BlockChain::numberHash(unsigned _n) const
 {
 	if (!_n)
@@ -365,69 +496,3 @@ h256 BlockChain::numberHash(unsigned _n) const
 	for (; _n < details().number; ++_n, ret = details(ret).parent) {}
 	return ret;
 }
-
-BlockDetails BlockChain::details(h256 _h) const
-{
-	lock_guard<recursive_mutex> l(m_lock);
-
-	BlockDetailsHash::const_iterator it = m_details.find(_h);
-	if (it != m_details.end())
-		return it->second;
-
-	std::string s;
-	m_extrasDB->Get(m_readOptions, toSlice(_h), &s);
-	if (s.empty())
-	{
-//			cout << "Not found in DB: " << _h << endl;
-		return NullBlockDetails;
-	}
-	{
-		bool ok;
-		tie(it, ok) = m_details.insert(std::make_pair(_h, BlockDetails(RLP(s))));
-	}
-	return it->second;
-}
-
-BlockBlooms BlockChain::blooms(h256 _h) const
-{
-	lock_guard<recursive_mutex> l(m_lock);
-
-	BlockBloomsHash::const_iterator it = m_blooms.find(_h);
-	if (it != m_blooms.end())
-		return it->second;
-
-	std::string s;
-	m_extrasDB->Get(m_readOptions, toSlice(_h, 1), &s);
-	if (s.empty())
-	{
-//			cout << "Not found in DB: " << _h << endl;
-		return NullBlockBlooms;
-	}
-	{
-		bool ok;
-		tie(it, ok) = m_blooms.insert(std::make_pair(_h, BlockBlooms(RLP(s))));
-	}
-	return it->second;
-}
-
-BlockTraces BlockChain::traces(h256 _h) const
-{
-	lock_guard<recursive_mutex> l(m_lock);
-
-	BlockTracesHash::const_iterator it = m_traces.find(_h);
-	if (it != m_traces.end())
-		return it->second;
-
-	std::string s;
-	m_extrasDB->Get(m_readOptions, toSlice(_h, 2), &s);
-	if (s.empty())
-	{
-//			cout << "Not found in DB: " << _h << endl;
-		return NullBlockTraces;
-	}
-	{
-		bool ok;
-		tie(it, ok) = m_traces.insert(std::make_pair(_h, BlockTraces(RLP(s))));
-	}
-	return it->second;
-}

libethereum/BlockChain.h

@@ -21,63 +21,25 @@
 
 #pragma once
 
+#pragma warning(push)
+#pragma warning(disable: 4100 4267)
+#include <leveldb/db.h>
+#pragma warning(pop)
+
 #include <mutex>
-#include <libethential/Log.h>
+#include <libdevcore/Log.h>
 #include <libethcore/CommonEth.h>
 #include <libethcore/BlockInfo.h>
-#include "Manifest.h"
+#include <libdevcore/Guards.h>
+#include "BlockDetails.h"
 #include "AddressState.h"
+#include "BlockQueue.h"
 namespace ldb = leveldb;
 
-namespace eth
-{
-
-class RLP;
-class RLPStream;
-
-struct BlockDetails
-{
-	BlockDetails(): number(0), totalDifficulty(0) {}
-	BlockDetails(uint _n, u256 _tD, h256 _p, h256s _c, h256 _bloom): number(_n), totalDifficulty(_tD), parent(_p), children(_c), bloom(_bloom) {}
-	BlockDetails(RLP const& _r);
-	bytes rlp() const;
-
-	bool isNull() const { return !totalDifficulty; }
-	explicit operator bool() const { return !isNull(); }
-
-	uint number;			// TODO: remove?
-	u256 totalDifficulty;
-	h256 parent;
-	h256s children;
-	h256 bloom;
-};
-
-struct BlockBlooms
+namespace dev
 {
-	BlockBlooms() {}
-	BlockBlooms(RLP const& _r) { blooms = _r.toVector<h256>(); }
-	bytes rlp() const { RLPStream s; s << blooms; return s.out(); }
-
-	h256s blooms;
-};
-
-struct BlockTraces
+namespace eth
 {
-	BlockTraces() {}
-	BlockTraces(RLP const& _r) { for (auto const& i: _r) traces.emplace_back(i.data()); }
-	bytes rlp() const { RLPStream s(traces.size()); for (auto const& i: traces) i.streamOut(s); return s.out(); }
-
-	Manifests traces;
-};
-
-
-typedef std::map<h256, BlockDetails> BlockDetailsHash;
-typedef std::map<h256, BlockBlooms> BlockBloomsHash;
-typedef std::map<h256, BlockTraces> BlockTracesHash;
-
-static const BlockDetails NullBlockDetails;
-static const BlockBlooms NullBlockBlooms;
-static const BlockTraces NullBlockTraces;
 
 static const h256s NullH256s;
 
@@ -94,9 +56,11 @@ struct BlockChainNote: public LogChannel { static const char* name() { return "=
 // TODO: Move all this Genesis stuff into Genesis.h/.cpp
 std::map<Address, AddressState> const& genesisState();
 
+ldb::Slice toSlice(h256 _h, unsigned _sub = 0);
+
 /**
  * @brief Implements the blockchain database. All data this gives is disk-backed.
- * @todo Make thread-safe.
+ * @threadsafe
  * @todo Make not memory hog (should actually act as a cache and deallocate old entries).
  */
 class BlockChain
@@ -106,71 +70,130 @@ public:
 	BlockChain(std::string _path, bool _killExisting = false);
 	~BlockChain();
 
+	void reopen(std::string _path, bool _killExisting = false) { close(); open(_path, _killExisting); }
+
 	/// (Potentially) renders invalid existing bytesConstRef returned by lastBlock.
 	/// To be called from main loop every 100ms or so.
 	void process();
 
-	/// Attempt to import the given block.
-	bool attemptImport(bytes const& _block, OverlayDB const& _stateDB);
+	/// Sync the chain with any incoming blocks. All blocks should, if processed in order
+	h256s sync(BlockQueue& _bq, OverlayDB const& _stateDB, unsigned _max);
+
+	/// Attempt to import the given block directly into the BlockChain and sync with the state DB.
+	/// @returns the block hashes of any blocks that came into/went out of the canonical block chain.
+	h256s attemptImport(bytes const& _block, OverlayDB const& _stateDB) noexcept;
 
 	/// Import block into disk-backed DB
-	void import(bytes const& _block, OverlayDB const& _stateDB);
+	/// @returns the block hashes of any blocks that came into/went out of the canonical block chain.
+	h256s import(bytes const& _block, OverlayDB const& _stateDB);
+
+	/// Returns true if the given block is known (though not necessarily a part of the canon chain).
+	bool isKnown(h256 _hash) const;
 
 	/// Get the familial details concerning a block (or the most recent mined if none given). Thread-safe.
-	BlockDetails details(h256 _hash) const;
+	BlockDetails details(h256 _hash) const { return queryExtras<BlockDetails, 0>(_hash, m_details, x_details, NullBlockDetails); }
 	BlockDetails details() const { return details(currentHash()); }
 
 	/// Get the transactions' bloom filters of a block (or the most recent mined if none given). Thread-safe.
-	BlockBlooms blooms(h256 _hash) const;
+	BlockBlooms blooms(h256 _hash) const { return queryExtras<BlockBlooms, 1>(_hash, m_blooms, x_blooms, NullBlockBlooms); }
 	BlockBlooms blooms() const { return blooms(currentHash()); }
 
 	/// Get the transactions' trace manifests of a block (or the most recent mined if none given). Thread-safe.
-	BlockTraces traces(h256 _hash) const;
+	BlockTraces traces(h256 _hash) const { return queryExtras<BlockTraces, 2>(_hash, m_traces, x_traces, NullBlockTraces); }
 	BlockTraces traces() const { return traces(currentHash()); }
 
-	/// Get a given block (RLP format). Thread-safe.
+	/// Get a block (RLP format) for the given hash (or the most recent mined if none given). Thread-safe.
 	bytes block(h256 _hash) const;
 	bytes block() const { return block(currentHash()); }
 
-	uint number(h256 _hash) const;
-	uint number() const { return number(currentHash()); }
+	/// Get a number for the given hash (or the most recent mined if none given). Thread-safe.
+	unsigned number(h256 _hash) const { return details(_hash).number; }
+	unsigned number() const { return number(currentHash()); }
 
 	/// Get a given block (RLP format). Thread-safe.
-	h256 currentHash() const { return m_lastBlockHash; }
+	h256 currentHash() const { ReadGuard l(x_lastBlockHash); return m_lastBlockHash; }
 
-	/// Get the hash of the genesis block.
+	/// Get the hash of the genesis block. Thread-safe.
 	h256 genesisHash() const { return m_genesisHash; }
 
-	/// Get the hash of a block of a given number.
+	/// Get the hash of a block of a given number. Slow; try not to use it too much.
 	h256 numberHash(unsigned _n) const;
 
-	std::vector<std::pair<Address, AddressState>> interestQueue() { std::vector<std::pair<Address, AddressState>> ret; swap(ret, m_interestQueue); return ret; }
-	void pushInterest(Address _a) { m_interest[_a]++; }
-	void popInterest(Address _a) { if (m_interest[_a] > 1) m_interest[_a]--; else if (m_interest[_a]) m_interest.erase(_a); }
+	/// Get all blocks not allowed as uncles given a parent (i.e. featured as uncles/main in parent, parent + 1, ... parent + 5).
+	/// @returns set including the header-hash of every parent (including @a _parent) up to and including generation +5
+	/// togther with all their quoted uncles.
+	h256Set allUnclesFrom(h256 _parent) const;
 
-	static BlockInfo const& genesis() { if (!s_genesis) { auto gb = createGenesisBlock(); (s_genesis = new BlockInfo)->populate(&gb); } return *s_genesis; }
+	/// @returns the genesis block header.
+	static BlockInfo const& genesis() { UpgradableGuard l(x_genesis); if (!s_genesis) { auto gb = createGenesisBlock(); UpgradeGuard ul(l); (s_genesis = new BlockInfo)->populate(&gb); } return *s_genesis; }
+
+	/// @returns the genesis block as its RLP-encoded byte array.
+	/// @note This is slow as it's constructed anew each call. Consider genesis() instead.
 	static bytes createGenesisBlock();
 
+	/** @returns the hash of all blocks between @a _from and @a _to, all blocks are ordered first by a number of
+	 * blocks that are parent-to-child, then two sibling blocks, then a number of blocks that are child-to-parent.
+	 *
+	 * If non-null, the h256 at @a o_common is set to the latest common ancestor of both blocks.
+	 *
+	 * e.g. if the block tree is 3a -> 2a -> 1a -> g and 2b -> 1b -> g (g is genesis, *a, *b are competing chains),
+	 * then:
+	 * @code
+	 * treeRoute(3a, 2b) == { 3a, 2a, 1a, 1b, 2b }; // *o_common == g
+	 * treeRoute(2a, 1a) == { 2a, 1a }; // *o_common == 1a
+	 * treeRoute(1a, 2a) == { 1a, 2a }; // *o_common == 1a
+	 * treeRoute(1b, 2a) == { 1b, 1a, 2a }; // *o_common == g
+	 * @endcode
+	 */
+	h256s treeRoute(h256 _from, h256 _to, h256* o_common = nullptr, bool _pre = true, bool _post = true) const;
+
 private:
+	void open(std::string _path, bool _killExisting = false);
+	void close();
+
+	template<class T, unsigned N> T queryExtras(h256 _h, std::map<h256, T>& _m, boost::shared_mutex& _x, T const& _n) const
+	{
+		{
+			ReadGuard l(_x);
+			auto it = _m.find(_h);
+			if (it != _m.end())
+				return it->second;
+		}
+
+		std::string s;
+		m_extrasDB->Get(m_readOptions, toSlice(_h, N), &s);
+		if (s.empty())
+		{
+	//			cout << "Not found in DB: " << _h << endl;
+			return _n;
+		}
+
+		WriteGuard l(_x);
+		auto ret = _m.insert(std::make_pair(_h, T(RLP(s))));
+		return ret.first->second;
+	}
+
 	void checkConsistency();
 
-	/// Get fully populated from disk DB.
+	/// The caches of the disk DB and their locks.
+	mutable boost::shared_mutex x_details;
 	mutable BlockDetailsHash m_details;
+	mutable boost::shared_mutex x_blooms;
 	mutable BlockBloomsHash m_blooms;
+	mutable boost::shared_mutex x_traces;
 	mutable BlockTracesHash m_traces;
-
+	mutable boost::shared_mutex x_cache;
 	mutable std::map<h256, bytes> m_cache;
-	mutable std::recursive_mutex m_lock;
-
-	/// The queue of transactions that have happened that we're interested in.
-	std::map<Address, int> m_interest;
-	std::vector<std::pair<Address, AddressState>> m_interestQueue;
 
+	/// The disk DBs. Thread-safe, so no need for locks.
 	ldb::DB* m_db;
 	ldb::DB* m_extrasDB;
 
 	/// Hash of the last (valid) block on the longest chain.
+	mutable boost::shared_mutex x_lastBlockHash;
 	h256 m_lastBlockHash;
+
+	/// Genesis block info.
 	h256 m_genesisHash;
 	bytes m_genesisBlock;
 
@@ -179,9 +202,12 @@ private:
 
 	friend std::ostream& operator<<(std::ostream& _out, BlockChain const& _bc);
 
+	/// Static genesis info and its lock.
+	static boost::shared_mutex x_genesis;
 	static BlockInfo* s_genesis;
 };
 
 std::ostream& operator<<(std::ostream& _out, BlockChain const& _bc);
 
 }
+}

libethereum/BlockDetails.cpp

@@ -0,0 +1,41 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file BlockDetails.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "BlockDetails.h"
+
+#include <libdevcore/Common.h>
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+BlockDetails::BlockDetails(RLP const& _r)
+{
+	number = _r[0].toInt<unsigned>();
+	totalDifficulty = _r[1].toInt<u256>();
+	parent = _r[2].toHash<h256>();
+	children = _r[3].toVector<h256>();
+	bloom = _r[4].toHash<h256>();
+}
+
+bytes BlockDetails::rlp() const
+{
+	return rlpList(number, totalDifficulty, parent, children, bloom);
+}

libethereum/BlockDetails.h

@@ -0,0 +1,84 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file BlockDetails.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#pragma once
+
+#pragma warning(push)
+#pragma warning(disable: 4100 4267)
+#include <leveldb/db.h>
+#pragma warning(pop)
+
+#include <libdevcore/Log.h>
+#include <libdevcore/RLP.h>
+#include "Manifest.h"
+namespace ldb = leveldb;
+
+namespace dev
+{
+namespace eth
+{
+
+struct BlockDetails
+{
+	BlockDetails(): number(0), totalDifficulty(0) {}
+	BlockDetails(unsigned _n, u256 _tD, h256 _p, h256s _c, h256 _bloom): number(_n), totalDifficulty(_tD), parent(_p), children(_c), bloom(_bloom) {}
+	BlockDetails(RLP const& _r);
+	bytes rlp() const;
+
+	bool isNull() const { return !totalDifficulty; }
+	explicit operator bool() const { return !isNull(); }
+
+	unsigned number;			// TODO: remove?
+	u256 totalDifficulty;
+	h256 parent;
+	h256s children;
+	h256 bloom;
+};
+
+struct BlockBlooms
+{
+	BlockBlooms() {}
+	BlockBlooms(RLP const& _r) { blooms = _r.toVector<h256>(); }
+	bytes rlp() const { RLPStream s; s << blooms; return s.out(); }
+
+	h256s blooms;
+};
+
+struct BlockTraces
+{
+	BlockTraces() {}
+	BlockTraces(RLP const& _r) { for (auto const& i: _r) traces.emplace_back(i.data()); }
+	bytes rlp() const { RLPStream s(traces.size()); for (auto const& i: traces) i.streamOut(s); return s.out(); }
+
+	Manifests traces;
+};
+
+
+typedef std::map<h256, BlockDetails> BlockDetailsHash;
+typedef std::map<h256, BlockBlooms> BlockBloomsHash;
+typedef std::map<h256, BlockTraces> BlockTracesHash;
+
+static const BlockDetails NullBlockDetails;
+static const BlockBlooms NullBlockBlooms;
+static const BlockTraces NullBlockTraces;
+
+}
+}

libethereum/BlockQueue.cpp

@@ -0,0 +1,142 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file BlockQueue.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "BlockQueue.h"
+
+#include <libdevcore/Log.h>
+#include <libethcore/Exceptions.h>
+#include <libethcore/BlockInfo.h>
+#include "BlockChain.h"
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+bool BlockQueue::import(bytesConstRef _block, BlockChain const& _bc)
+{
+	// Check if we already know this block.
+	h256 h = BlockInfo::headerHash(_block);
+
+	cblockq << "Queuing block" << h.abridged() << "for import...";
+
+	UpgradableGuard l(m_lock);
+
+	if (m_readySet.count(h) || m_drainingSet.count(h) || m_unknownSet.count(h))
+	{
+		// Already know about this one.
+		cblockq << "Already known.";
+		return false;
+	}
+
+	// VERIFY: populates from the block and checks the block is internally coherent.
+	BlockInfo bi;
+
+#if ETH_CATCH
+	try
+#endif
+	{
+		bi.populate(_block);
+		bi.verifyInternals(_block);
+	}
+#if ETH_CATCH
+	catch (Exception const& _e)
+	{
+		cwarn << "Ignoring malformed block: " << _e.description();
+		return false;
+	}
+#endif
+
+	// Check block doesn't already exist first!
+	if (_bc.details(h))
+	{
+		cblockq << "Already known in chain.";
+		return false;
+	}
+
+	UpgradeGuard ul(l);
+
+	// Check it's not in the future
+	if (bi.timestamp > (u256)time(0))
+	{
+		m_future.insert(make_pair((unsigned)bi.timestamp, _block.toBytes()));
+		cblockq << "OK - queued for future.";
+	}
+	else
+	{
+		// We now know it.
+		if (!m_readySet.count(bi.parentHash) && !m_drainingSet.count(bi.parentHash) && !_bc.isKnown(bi.parentHash))
+		{
+			// We don't know the parent (yet) - queue it up for later. It'll get resent to us if we find out about its ancestry later on.
+			cblockq << "OK - queued as unknown parent:" << bi.parentHash.abridged();
+			m_unknown.insert(make_pair(bi.parentHash, make_pair(h, _block.toBytes())));
+			m_unknownSet.insert(h);
+		}
+		else
+		{
+			// If valid, append to blocks.
+			cblockq << "OK - ready for chain insertion.";
+			m_ready.push_back(_block.toBytes());
+			m_readySet.insert(h);
+
+			noteReadyWithoutWriteGuard(h);
+		}
+	}
+
+	return true;
+}
+
+void BlockQueue::tick(BlockChain const& _bc)
+{
+	unsigned t = time(0);
+	for (auto i = m_future.begin(); i != m_future.end() && i->first < time(0); ++i)
+		import(&(i->second), _bc);
+
+	WriteGuard l(m_lock);
+	m_future.erase(m_future.begin(), m_future.upper_bound(t));
+}
+
+void BlockQueue::drain(std::vector<bytes>& o_out)
+{
+	WriteGuard l(m_lock);
+	if (m_drainingSet.empty())
+	{
+		swap(o_out, m_ready);
+		swap(m_drainingSet, m_readySet);
+	}
+}
+
+void BlockQueue::noteReadyWithoutWriteGuard(h256 _good)
+{
+	list<h256> goodQueue(1, _good);
+	while (goodQueue.size())
+	{
+		auto r = m_unknown.equal_range(goodQueue.front());
+		goodQueue.pop_front();
+		for (auto it = r.first; it != r.second; ++it)
+		{
+			m_ready.push_back(it->second.second);
+			auto newReady = it->second.first;
+			m_unknownSet.erase(newReady);
+			m_readySet.insert(newReady);
+			goodQueue.push_back(newReady);
+		}
+		m_unknown.erase(r.first, r.second);
+	}
+}

libethereum/BlockQueue.h

@@ -0,0 +1,84 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file BlockQueue.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#pragma once
+
+#include <boost/thread.hpp>
+#include <libdevcore/Common.h>
+#include <libdevcore/Log.h>
+#include <libethcore/CommonEth.h>
+#include <libdevcore/Guards.h>
+
+namespace dev
+{
+namespace eth
+{
+
+class BlockChain;
+
+struct BlockQueueChannel: public LogChannel { static const char* name() { return "[]Q"; } static const int verbosity = 4; };
+#define cblockq dev::LogOutputStream<dev::eth::BlockQueueChannel, true>()
+
+/**
+ * @brief A queue of blocks. Sits between network or other I/O and the BlockChain.
+ * Sorts them ready for blockchain insertion (with the BlockChain::sync() method).
+ * @threadsafe
+ */
+class BlockQueue
+{
+public:
+	/// Import a block into the queue.
+	bool import(bytesConstRef _tx, BlockChain const& _bc);
+
+	/// Notes that time has moved on and some blocks that used to be "in the future" may no be valid.
+	void tick(BlockChain const& _bc);
+
+	/// Grabs the blocks that are ready, giving them in the correct order for insertion into the chain.
+	/// Don't forget to call doneDrain() once you're done importing.
+	void drain(std::vector<bytes>& o_out);
+
+	/// Must be called after a drain() call. Notes that the drained blocks have been imported into the blockchain, so we can forget about them.
+	void doneDrain() { WriteGuard l(m_lock); m_drainingSet.clear(); }
+
+	/// Notify the queue that the chain has changed and a new block has attained 'ready' status (i.e. is in the chain).
+	void noteReady(h256 _b) { WriteGuard l(m_lock); noteReadyWithoutWriteGuard(_b); }
+
+	/// Get information on the items queued.
+	std::pair<unsigned, unsigned> items() const { ReadGuard l(m_lock); return std::make_pair(m_ready.size(), m_unknown.size()); }
+
+	/// Clear everything.
+	void clear() { WriteGuard l(m_lock); m_readySet.clear(); m_drainingSet.clear(); m_ready.clear(); m_unknownSet.clear(); m_unknown.clear(); m_future.clear(); }
+
+private:
+	void noteReadyWithoutWriteGuard(h256 _b);
+	void notePresentWithoutWriteGuard(bytesConstRef _block);
+
+	mutable boost::shared_mutex m_lock;						///< General lock.
+	std::set<h256> m_readySet;								///< All blocks ready for chain-import.
+	std::set<h256> m_drainingSet;							///< All blocks being imported.
+	std::vector<bytes> m_ready;								///< List of blocks, in correct order, ready for chain-import.
+	std::set<h256> m_unknownSet;							///< Set of all blocks whose parents are not ready/in-chain.
+	std::multimap<h256, std::pair<h256, bytes>> m_unknown;	///< For transactions that have an unknown parent; we map their parent hash to the block stuff, and insert once the block appears.
+	std::multimap<unsigned, bytes> m_future;	///< Set of blocks that are not yet valid.
+};
+
+}
+}

libethereum/CMakeLists.txt

@@ -19,6 +19,9 @@ include_directories(..)
 
 target_link_libraries(${EXECUTABLE} evm)
 target_link_libraries(${EXECUTABLE} lll)
+target_link_libraries(${EXECUTABLE} whisper)
+target_link_libraries(${EXECUTABLE} p2p)
+target_link_libraries(${EXECUTABLE} devcrypto)
 target_link_libraries(${EXECUTABLE} ethcore)
 target_link_libraries(${EXECUTABLE} secp256k1)
 if(MINIUPNPC_LS)
@@ -30,6 +33,7 @@ target_link_libraries(${EXECUTABLE} gmp)
 
 if("${TARGET_PLATFORM}" STREQUAL "w64")
 	target_link_libraries(${EXECUTABLE} boost_system-mt-s)
+	target_link_libraries(${EXECUTABLE} boost_regex-mt-s)
 	target_link_libraries(${EXECUTABLE} boost_filesystem-mt-s)
 	target_link_libraries(${EXECUTABLE} boost_thread_win32-mt-s)
 	target_link_libraries(${EXECUTABLE} iphlpapi)
@@ -39,18 +43,21 @@ if("${TARGET_PLATFORM}" STREQUAL "w64")
 elseif (APPLE)
 	# Latest mavericks boost libraries only come with -mt
 	target_link_libraries(${EXECUTABLE} boost_system-mt)
+	target_link_libraries(${EXECUTABLE} boost_regex-mt)
 	target_link_libraries(${EXECUTABLE} boost_filesystem-mt)
 	target_link_libraries(${EXECUTABLE} boost_thread-mt)
 	find_package(Threads REQUIRED)
 	target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
 elseif (UNIX)
 	target_link_libraries(${EXECUTABLE} ${Boost_SYSTEM_LIBRARY})
+	target_link_libraries(${EXECUTABLE} ${Boost_REGEX_LIBRARY})
 	target_link_libraries(${EXECUTABLE} ${Boost_FILESYSTEM_LIBRARY})
 	target_link_libraries(${EXECUTABLE} ${Boost_THREAD_LIBRARY})
 	target_link_libraries(${EXECUTABLE} ${Boost_DATE_TIME_LIBRARY})
 	target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
 else ()
 	target_link_libraries(${EXECUTABLE} boost_system)
+	target_link_libraries(${EXECUTABLE} boost_regex)
 	target_link_libraries(${EXECUTABLE} boost_filesystem)
 	target_link_libraries(${EXECUTABLE} boost_thread)
 	find_package(Threads REQUIRED)

libethereum/Client.cpp

@@ -24,11 +24,14 @@
 #include <chrono>
 #include <thread>
 #include <boost/filesystem.hpp>
-#include <libethential/Common.h>
+#include <libdevcore/Log.h>
+#include <libp2p/Host.h>
 #include "Defaults.h"
-#include "PeerServer.h"
+#include "EthereumHost.h"
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
+using namespace p2p;
 
 VersionChecker::VersionChecker(string const& _dbPath):
 	m_path(_dbPath.size() ? _dbPath : Defaults::dbPath())
@@ -50,110 +53,262 @@ void VersionChecker::setOk()
 	}
 }
 
-Client::Client(std::string const& _clientVersion, Address _us, std::string const& _dbPath, bool _forceClean):
-	m_clientVersion(_clientVersion),
+Client::Client(p2p::Host* _extNet, std::string const& _dbPath, bool _forceClean, u256 _networkId):
+	Worker("eth"),
 	m_vc(_dbPath),
 	m_bc(_dbPath, !m_vc.ok() || _forceClean),
 	m_stateDB(State::openDB(_dbPath, !m_vc.ok() || _forceClean)),
-	m_preMine(_us, m_stateDB),
-	m_postMine(_us, m_stateDB),
-	m_workState(Active)
+	m_preMine(Address(), m_stateDB),
+	m_postMine(Address(), m_stateDB)
 {
+	m_host = _extNet->registerCapability(new EthereumHost(m_bc, m_tq, m_bq, _networkId));
+
+	setMiningThreads();
 	if (_dbPath.size())
 		Defaults::setDBPath(_dbPath);
 	m_vc.setOk();
-	m_changed = true;
+	doWork();
+
+	startWorking();
+}
+
+Client::~Client()
+{
+	stopWorking();
 }
 
-void Client::start() {
-	static const char* c_threadName = "eth";
+void Client::setNetworkId(u256 _n)
+{
+	if (auto h = m_host.lock())
+		h->setNetworkId(_n);
+}
 
-	m_work.reset(new thread([&](){
-		setThreadName(c_threadName);
-		while (m_workState.load(std::memory_order_acquire) != Deleting)
-			work();
-		m_workState.store(Deleted, std::memory_order_release);
+DownloadMan const* Client::downloadMan() const { if (auto h = m_host.lock()) return &(h->downloadMan()); return nullptr; }
+bool Client::isSyncing() const { if (auto h = m_host.lock()) return h->isSyncing(); return false; }
 
-		// Synchronise the state according to the head of the block chain.
-		// TODO: currently it contains keys for *all* blocks. Make it remove old ones.
-		m_preMine.sync(m_bc);
-		m_postMine = m_preMine;
-	}));
+void Client::doneWorking()
+{
+	// Synchronise the state according to the head of the block chain.
+	// TODO: currently it contains keys for *all* blocks. Make it remove old ones.
+	WriteGuard l(x_stateDB);
+	m_preMine.sync(m_bc);
+	m_postMine = m_preMine;
 }
 
-Client::~Client()
+void Client::flushTransactions()
 {
-	if (m_workState.load(std::memory_order_acquire) == Active)
-		m_workState.store(Deleting, std::memory_order_release);
-	while (m_workState.load(std::memory_order_acquire) != Deleted)
-		this_thread::sleep_for(chrono::milliseconds(10));
-	m_work->join();
+	doWork();
 }
 
-void Client::startNetwork(unsigned short _listenPort, std::string const& _seedHost, unsigned short _port, NodeMode _mode, unsigned _peers, string const& _publicIP, bool _upnp)
+void Client::killChain()
 {
-	ClientGuard l(this);
-	if (m_net.get())
-		return;
-	try
+	bool wasMining = isMining();
+	if (wasMining)
+		stopMining();
+	stopWorking();
+
+	m_tq.clear();
+	m_bq.clear();
+	m_miners.clear();
+	m_preMine = State();
+	m_postMine = State();
+
+	{
+		WriteGuard l(x_stateDB);
+		m_stateDB = OverlayDB();
+		m_stateDB = State::openDB(Defaults::dbPath(), true);
+	}
+	m_bc.reopen(Defaults::dbPath(), true);
+
+	m_preMine = State(Address(), m_stateDB);
+	m_postMine = State(Address(), m_stateDB);
+
+	if (auto h = m_host.lock())
+		h->reset();
+
+	doWork();
+
+	setMiningThreads(0);
+
+	startWorking();
+	if (wasMining)
+		startMining();
+}
+
+void Client::clearPending()
+{
+	h256Set changeds;
 	{
-		m_net.reset(new PeerServer(m_clientVersion, m_bc, 0, _listenPort, _mode, _publicIP, _upnp));
+		WriteGuard l(x_stateDB);
+		if (!m_postMine.pending().size())
+			return;
+		for (unsigned i = 0; i < m_postMine.pending().size(); ++i)
+			appendFromNewPending(m_postMine.bloom(i), changeds);
+		changeds.insert(PendingChangedFilter);
+		m_postMine = m_preMine;
 	}
-	catch (std::exception const&)
+
 	{
-		// Probably already have the port open.
-		cwarn << "Could not initialize with specified/default port. Trying system-assigned port";
-		m_net.reset(new PeerServer(m_clientVersion, m_bc, 0, _mode, _publicIP, _upnp));
+		ReadGuard l(x_miners);
+		for (auto& m: m_miners)
+			m.noteStateChange();
 	}
 
-	m_net->setIdealPeerCount(_peers);
-	if (_seedHost.size())
-		connect(_seedHost, _port);
+	noteChanged(changeds);
 }
 
-std::vector<PeerInfo> Client::peers()
+unsigned Client::installWatch(h256 _h)
 {
-	ClientGuard l(this);
-	return m_net ? m_net->peers() : std::vector<PeerInfo>();
+	auto ret = m_watches.size() ? m_watches.rbegin()->first + 1 : 0;
+	m_watches[ret] = ClientWatch(_h);
+	cwatch << "+++" << ret << _h;
+	return ret;
 }
 
-size_t Client::peerCount() const
+unsigned Client::installWatch(MessageFilter const& _f)
 {
-	ClientGuard l(this);
-	return m_net ? m_net->peerCount() : 0;
+	lock_guard<mutex> l(m_filterLock);
+
+	h256 h = _f.sha3();
+
+	if (!m_filters.count(h))
+		m_filters.insert(make_pair(h, _f));
+
+	return installWatch(h);
 }
 
-void Client::connect(std::string const& _seedHost, unsigned short _port)
+void Client::uninstallWatch(unsigned _i)
 {
-	ClientGuard l(this);
-	if (!m_net.get())
+	cwatch << "XXX" << _i;
+
+	lock_guard<mutex> l(m_filterLock);
+
+	auto it = m_watches.find(_i);
+	if (it == m_watches.end())
 		return;
-	m_net->connect(_seedHost, _port);
+	auto id = it->second.id;
+	m_watches.erase(it);
+
+	auto fit = m_filters.find(id);
+	if (fit != m_filters.end())
+		if (!--fit->second.refCount)
+			m_filters.erase(fit);
 }
 
-void Client::stopNetwork()
+void Client::noteChanged(h256Set const& _filters)
 {
-	ClientGuard l(this);
-	m_net.reset(nullptr);
+	lock_guard<mutex> l(m_filterLock);
+	for (auto& i: m_watches)
+		if (_filters.count(i.second.id))
+		{
+			cwatch << "!!!" << i.first << i.second.id;
+			i.second.changes++;
+		}
+}
+
+void Client::appendFromNewPending(h256 _bloom, h256Set& o_changed) const
+{
+	lock_guard<mutex> l(m_filterLock);
+	for (pair<h256, InstalledFilter> const& i: m_filters)
+		if ((unsigned)i.second.filter.latest() > m_bc.number() && i.second.filter.matches(_bloom))
+			o_changed.insert(i.first);
 }
 
-void Client::startMining()
+void Client::appendFromNewBlock(h256 _block, h256Set& o_changed) const
 {
-	m_doMine = true;
-	m_restartMining = true;
+	auto d = m_bc.details(_block);
+
+	lock_guard<mutex> l(m_filterLock);
+	for (pair<h256, InstalledFilter> const& i: m_filters)
+		if ((unsigned)i.second.filter.latest() >= d.number && (unsigned)i.second.filter.earliest() <= d.number && i.second.filter.matches(d.bloom))
+			o_changed.insert(i.first);
 }
 
-void Client::stopMining()
+void Client::setForceMining(bool _enable)
 {
-	m_doMine = false;
+	 m_forceMining = _enable;
+	 if (!m_host.lock())
+	 {
+		 ReadGuard l(x_miners);
+		 for (auto& m: m_miners)
+			 m.noteStateChange();
+	 }
+}
+
+void Client::setMiningThreads(unsigned _threads)
+{
+	stopMining();
+
+	auto t = _threads ? _threads : thread::hardware_concurrency();
+	WriteGuard l(x_miners);
+	m_miners.clear();
+	m_miners.resize(t);
+	unsigned i = 0;
+	for (auto& m: m_miners)
+		m.setup(this, i++);
+}
+
+MineProgress Client::miningProgress() const
+{
+	MineProgress ret;
+	ReadGuard l(x_miners);
+	for (auto& m: m_miners)
+		ret.combine(m.miningProgress());
+	return ret;
+}
+
+std::list<MineInfo> Client::miningHistory()
+{
+	std::list<MineInfo> ret;
+
+	ReadGuard l(x_miners);
+	if (m_miners.empty())
+		return ret;
+	ret = m_miners[0].miningHistory();
+	for (unsigned i = 1; i < m_miners.size(); ++i)
+	{
+		auto l = m_miners[i].miningHistory();
+		auto ri = ret.begin();
+		auto li = l.begin();
+		for (; ri != ret.end() && li != l.end(); ++ri, ++li)
+			ri->combine(*li);
+	}
+	return ret;
+}
+
+void Client::setupState(State& _s)
+{
+	{
+		ReadGuard l(x_stateDB);
+		cwork << "SETUP MINE";
+		_s = m_postMine;
+	}
+	if (m_paranoia)
+	{
+		if (_s.amIJustParanoid(m_bc))
+		{
+			cnote << "I'm just paranoid. Block is fine.";
+			_s.commitToMine(m_bc);
+		}
+		else
+		{
+			cwarn << "I'm not just paranoid. Cannot mine. Please file a bug report.";
+		}
+	}
+	else
+		_s.commitToMine(m_bc);
 }
 
 void Client::transact(Secret _secret, u256 _value, Address _dest, bytes const& _data, u256 _gas, u256 _gasPrice)
 {
-	ClientGuard l(this);
+	startWorking();
+
 	Transaction t;
-	cdebug << "Nonce at " << toAddress(_secret) << " pre:" << m_preMine.transactionsFrom(toAddress(_secret)) << " post:" << m_postMine.transactionsFrom(toAddress(_secret));
-	t.nonce = m_postMine.transactionsFrom(toAddress(_secret));
+//	cdebug << "Nonce at " << toAddress(_secret) << " pre:" << m_preMine.transactionsFrom(toAddress(_secret)) << " post:" << m_postMine.transactionsFrom(toAddress(_secret));
+	{
+		ReadGuard l(x_stateDB);
+		t.nonce = m_postMine.transactionsFrom(toAddress(_secret));
+	}
 	t.value = _value;
 	t.gasPrice = _gasPrice;
 	t.gas = _gas;
@@ -164,11 +319,37 @@ void Client::transact(Secret _secret, u256 _value, Address _dest, bytes const& _
 	m_tq.attemptImport(t.rlp());
 }
 
+bytes Client::call(Secret _secret, u256 _value, Address _dest, bytes const& _data, u256 _gas, u256 _gasPrice)
+{
+	State temp;
+	Transaction t;
+//	cdebug << "Nonce at " << toAddress(_secret) << " pre:" << m_preMine.transactionsFrom(toAddress(_secret)) << " post:" << m_postMine.transactionsFrom(toAddress(_secret));
+	{
+		ReadGuard l(x_stateDB);
+		temp = m_postMine;
+		t.nonce = temp.transactionsFrom(toAddress(_secret));
+	}
+	t.value = _value;
+	t.gasPrice = _gasPrice;
+	t.gas = _gas;
+	t.receiveAddress = _dest;
+	t.data = _data;
+	t.sign(_secret);
+	bytes out;
+	u256 gasUsed = temp.execute(t.data, &out, false);
+	(void)gasUsed; // TODO: do something with gasused which it returns.
+	return out;
+}
+
 Address Client::transact(Secret _secret, u256 _endowment, bytes const& _init, u256 _gas, u256 _gasPrice)
 {
-	ClientGuard l(this);
+	startWorking();
+
 	Transaction t;
-	t.nonce = m_postMine.transactionsFrom(toAddress(_secret));
+	{
+		ReadGuard l(x_stateDB);
+		t.nonce = m_postMine.transactionsFrom(toAddress(_secret));
+	}
 	t.value = _endowment;
 	t.gasPrice = _gasPrice;
 	t.gas = _gas;
@@ -182,25 +363,39 @@ Address Client::transact(Secret _secret, u256 _endowment, bytes const& _init, u2
 
 void Client::inject(bytesConstRef _rlp)
 {
-	ClientGuard l(this);
+	startWorking();
+
 	m_tq.attemptImport(_rlp);
-	m_changed = true;
 }
 
-void Client::work()
+void Client::doWork()
 {
-	bool changed = false;
+	// TODO: Use condition variable rather than polling.
 
-	// Process network events.
-	// Synchronise block chain with network.
-	// Will broadcast any of our (new) transactions and blocks, and collect & add any of their (new) transactions and blocks.
-	if (m_net)
-	{
-		ClientGuard l(this);
-		m_net->process();	// must be in guard for now since it uses the blockchain. TODO: make BlockChain thread-safe.
+	cworkin << "WORK";
+	h256Set changeds;
 
-		if (m_net->sync(m_bc, m_tq, m_stateDB))
-			changed = true;
+	{
+		ReadGuard l(x_miners);
+		for (auto& m: m_miners)
+			if (m.isComplete())
+			{
+				cwork << "CHAIN <== postSTATE";
+				h256s hs;
+				{
+					WriteGuard l(x_stateDB);
+					hs = m_bc.attemptImport(m.blockData(), m_stateDB);
+				}
+				if (hs.size())
+				{
+					for (auto h: hs)
+						appendFromNewBlock(h, changeds);
+					changeds.insert(ChainChangedFilter);
+					//changeds.insert(PendingChangedFilter);	// if we mined the new block, then we've probably reset the pending transactions.
+				}
+				for (auto& m: m_miners)
+					m.noteStateChange();
+			}
 	}
 
 	// Synchronise state to block chain.
@@ -210,90 +405,60 @@ void Client::work()
 	//   if there are no checkpoints before our fork) reverting to the genesis block and replaying
 	//   all blocks.
 	// Resynchronise state with block chain & trans
+	bool rsm = false;
 	{
-		ClientGuard l(this);
+		WriteGuard l(x_stateDB);
+		cwork << "BQ ==> CHAIN ==> STATE";
+		OverlayDB db = m_stateDB;
+		x_stateDB.unlock();
+		h256s newBlocks = m_bc.sync(m_bq, db, 100);	// TODO: remove transactions from m_tq nicely rather than relying on out of date nonce later on.
+		if (newBlocks.size())
+		{
+			for (auto i: newBlocks)
+				appendFromNewBlock(i, changeds);
+			changeds.insert(ChainChangedFilter);
+		}
+		x_stateDB.lock();
+		if (newBlocks.size())
+			m_stateDB = db;
+
+		cwork << "preSTATE <== CHAIN";
 		if (m_preMine.sync(m_bc) || m_postMine.address() != m_preMine.address())
 		{
-			if (m_doMine)
+			if (isMining())
 				cnote << "New block on chain: Restarting mining operation.";
-			changed = true;
-			m_restartMining = true;	// need to re-commit to mine.
 			m_postMine = m_preMine;
+			rsm = true;
+			changeds.insert(PendingChangedFilter);
+			// TODO: Move transactions pending from m_postMine back to transaction queue.
 		}
-		if (m_postMine.sync(m_tq, &changed))
-		{
-			if (m_doMine)
-				cnote << "Additional transaction ready: Restarting mining operation.";
-			m_restartMining = true;
-		}
-	}
 
-	if (m_doMine)
-	{
-		if (m_restartMining)
+		// returns h256s as blooms, once for each transaction.
+		cwork << "postSTATE <== TQ";
+		h256s newPendingBlooms = m_postMine.sync(m_tq);
+		if (newPendingBlooms.size())
 		{
-			m_mineProgress.best = (double)-1;
-			m_mineProgress.hashes = 0;
-			m_mineProgress.ms = 0;
-			ClientGuard l(this);
-			if (m_paranoia)
-			{
-				if (m_postMine.amIJustParanoid(m_bc))
-				{
-					cnote << "I'm just paranoid. Block is fine.";
-					m_postMine.commitToMine(m_bc);
-				}
-				else
-				{
-					cwarn << "I'm not just paranoid. Cannot mine. Please file a bug report.";
-					m_doMine = false;
-				}
-			}
-			else
-				m_postMine.commitToMine(m_bc);
+			for (auto i: newPendingBlooms)
+				appendFromNewPending(i, changeds);
+			changeds.insert(PendingChangedFilter);
+
+			if (isMining())
+				cnote << "Additional transaction ready: Restarting mining operation.";
+			rsm = true;
 		}
 	}
-
-	if (m_doMine)
+	if (rsm)
 	{
-		m_restartMining = false;
-
-		// Mine for a while.
-		MineInfo mineInfo = m_postMine.mine(100);
-
-		m_mineProgress.best = min(m_mineProgress.best, mineInfo.best);
-		m_mineProgress.current = mineInfo.best;
-		m_mineProgress.requirement = mineInfo.requirement;
-		m_mineProgress.ms += 100;
-		m_mineProgress.hashes += mineInfo.hashes;
-		{
-			ClientGuard l(this);
-			m_mineHistory.push_back(mineInfo);
-		}
-
-		if (mineInfo.completed)
-		{
-			// Import block.
-			ClientGuard l(this);
-			m_postMine.completeMine();
-			m_bc.attemptImport(m_postMine.blockData(), m_stateDB);
-			m_changed = true;
-		}
+		ReadGuard l(x_miners);
+		for (auto& m: m_miners)
+			m.noteStateChange();
 	}
-	else
-		this_thread::sleep_for(chrono::milliseconds(100));
-
-	m_changed = m_changed || changed;
-}
 
-void Client::lock() const
-{
-	m_lock.lock();
-}
+	cwork << "noteChanged" << changeds.size() << "items";
+	noteChanged(changeds);
+	cworkout << "WORK";
 
-void Client::unlock() const
-{
-	m_lock.unlock();
+	this_thread::sleep_for(chrono::milliseconds(100));
 }
 
 unsigned Client::numberOf(int _n) const
@@ -308,6 +473,7 @@ unsigned Client::numberOf(int _n) const
 
 State Client::asOf(int _h) const
 {
+	ReadGuard l(x_stateDB);
 	if (_h == 0)
 		return m_postMine;
 	else if (_h == -1)
@@ -316,154 +482,81 @@ State Client::asOf(int _h) const
 		return State(m_stateDB, m_bc, m_bc.numberHash(numberOf(_h)));
 }
 
-u256 Client::balanceAt(Address _a, int _block) const
+State Client::state(unsigned _txi, h256 _block) const
 {
-	ClientGuard l(this);
-	return asOf(_block).balance(_a);
+	ReadGuard l(x_stateDB);
+	return State(m_stateDB, m_bc, _block).fromPending(_txi);
 }
 
-u256 Client::countAt(Address _a, int _block) const
+eth::State Client::state(h256 _block) const
 {
-	ClientGuard l(this);
-	return asOf(_block).transactionsFrom(_a);
+	ReadGuard l(x_stateDB);
+	return State(m_stateDB, m_bc, _block);
 }
 
-u256 Client::stateAt(Address _a, u256 _l, int _block) const
+eth::State Client::state(unsigned _txi) const
 {
-	ClientGuard l(this);
-	return asOf(_block).storage(_a, _l);
+	ReadGuard l(x_stateDB);
+	return m_postMine.fromPending(_txi);
 }
 
-bytes Client::codeAt(Address _a, int _block) const
+StateDiff Client::diff(unsigned _txi, int _block) const
 {
-	ClientGuard l(this);
-	return asOf(_block).code(_a);
+	State st = state(_block);
+	return st.fromPending(_txi).diff(st.fromPending(_txi + 1));
 }
 
-bool TransactionFilter::matches(h256 _bloom) const
+StateDiff Client::diff(unsigned _txi, h256 _block) const
 {
-	auto have = [=](Address const& a) { return _bloom.contains(a.bloom()); };
-	if (m_from.size())
-	{
-		for (auto i: m_from)
-			if (have(i))
-				goto OK1;
-		return false;
-	}
-	OK1:
-	if (m_to.size())
-	{
-		for (auto i: m_to)
-			if (have(i))
-				goto OK2;
-		return false;
-	}
-	OK2:
-	if (m_stateAltered.size() || m_altered.size())
-	{
-		for (auto i: m_altered)
-			if (have(i))
-				goto OK3;
-		for (auto i: m_stateAltered)
-			if (have(i.first) && _bloom.contains(h256(i.second).bloom()))
-				goto OK3;
-		return false;
-	}
-	OK3:
-	return true;
+	State st = state(_block);
+	return st.fromPending(_txi).diff(st.fromPending(_txi + 1));
 }
 
-bool TransactionFilter::matches(State const& _s, unsigned _i) const
+std::vector<Address> Client::addresses(int _block) const
 {
-	h256 b = _s.changesFromPending(_i).bloom();
-	if (!matches(b))
-		return false;
-
-	Transaction t = _s.pending()[_i];
-	if (!m_to.empty() && !m_to.count(t.receiveAddress))
-		return false;
-	if (!m_from.empty() && !m_from.count(t.sender()))
-		return false;
-	if (m_stateAltered.empty() && m_altered.empty())
-		return true;
-	StateDiff d = _s.pendingDiff(_i);
-	if (!m_altered.empty())
-	{
-		for (auto const& s: m_altered)
-			if (d.accounts.count(s))
-				return true;
-		return false;
-	}
-	if (!m_stateAltered.empty())
-	{
-		for (auto const& s: m_stateAltered)
-			if (d.accounts.count(s.first) && d.accounts.at(s.first).storage.count(s.second))
-				return true;
-		return false;
-	}
-	return true;
+	vector<Address> ret;
+	for (auto const& i: asOf(_block).addresses())
+		ret.push_back(i.first);
+	return ret;
 }
 
-PastMessages TransactionFilter::matches(Manifest const& _m, unsigned _i) const
+u256 Client::balanceAt(Address _a, int _block) const
 {
-	PastMessages ret;
-	matches(_m, vector<unsigned>(1, _i), _m.from, PastMessages(), ret);
-	return ret;
+	return asOf(_block).balance(_a);
 }
 
-bool TransactionFilter::matches(Manifest const& _m, vector<unsigned> _p, Address _o, PastMessages _limbo, PastMessages& o_ret) const
+std::map<u256, u256> Client::storageAt(Address _a, int _block) const
 {
-	bool ret;
-
-	if ((m_from.empty() || m_from.count(_m.from)) && (m_to.empty() || m_to.count(_m.to)))
-		_limbo.push_back(PastMessage(_m, _p, _o));
-
-	// Handle limbos, by checking against all addresses in alteration.
-	bool alters = m_altered.empty() && m_stateAltered.empty();
-	alters = alters || m_altered.count(_m.from) || m_altered.count(_m.to);
-
-	if (!alters)
-		for (auto const& i: _m.altered)
-			if (m_altered.count(_m.to) || m_stateAltered.count(make_pair(_m.to, i)))
-			{
-				alters = true;
-				break;
-			}
-	// If we do alter stuff,
-	if (alters)
-	{
-		o_ret += _limbo;
-		_limbo.clear();
-		ret = true;
-	}
+	return asOf(_block).storage(_a);
+}
 
-	_p.push_back(0);
-	for (auto const& m: _m.internal)
-	{
-		if (matches(m, _p, _o, _limbo, o_ret))
-		{
-			_limbo.clear();
-			ret = true;
-		}
-		_p.back()++;
-	}
+u256 Client::countAt(Address _a, int _block) const
+{
+	return asOf(_block).transactionsFrom(_a);
+}
 
-	return ret;
+u256 Client::stateAt(Address _a, u256 _l, int _block) const
+{
+	return asOf(_block).storage(_a, _l);
 }
 
-PastMessages Client::transactions(TransactionFilter const& _f) const
+bytes Client::codeAt(Address _a, int _block) const
 {
-	ClientGuard l(this);
+	return asOf(_block).code(_a);
+}
 
+PastMessages Client::messages(MessageFilter const& _f) const
+{
 	PastMessages ret;
-	unsigned begin = numberOf(_f.latest());
-	unsigned end = min(begin, numberOf(_f.earliest()));
+	unsigned begin = min<unsigned>(m_bc.number(), (unsigned)_f.latest());
+	unsigned end = min(begin, (unsigned)_f.earliest());
 	unsigned m = _f.max();
 	unsigned s = _f.skip();
 
 	// Handle pending transactions differently as they're not on the block chain.
-	if (_f.latest() == 0)
+	if (begin == m_bc.number())
 	{
+		ReadGuard l(x_stateDB);
 		for (unsigned i = 0; i < m_postMine.pending().size(); ++i)
 		{
 			// Might have a transaction that contains a matching message.
@@ -477,36 +570,29 @@ PastMessages Client::transactions(TransactionFilter const& _f) const
 						s--;
 					else
 						// Have a transaction that contains a matching message.
-						ret.insert(ret.begin(), pm[j].polish(h256(), ts, 0));
+						ret.insert(ret.begin(), pm[j].polish(h256(), ts, m_bc.number() + 1, m_postMine.address()));
 			}
 		}
-/*		for (unsigned i = m_postMine.pending().size(); i-- && ret.size() != m;)
-			if (_f.matches(m_postMine, i))
-			{
-				if (s)
-					s--;
-				else
-					ret.insert(ret.begin(), PastMessage(m_postMine.pending()[i], h256(), i, time(0), 0));
-			}*/
-		// Early exit here since we can't rely on begin/end, being out of the blockchain as we are.
-		if (_f.earliest() == 0)
-			return ret;
 	}
 
+#if ETH_DEBUG
 	unsigned skipped = 0;
 	unsigned falsePos = 0;
-	auto cn = m_bc.number();
+#endif
 	auto h = m_bc.numberHash(begin);
 	unsigned n = begin;
 	for (; ret.size() != m && n != end; n--, h = m_bc.details(h).parent)
 	{
 		auto d = m_bc.details(h);
+#if ETH_DEBUG
 		int total = 0;
+#endif
 		if (_f.matches(d.bloom))
 		{
 			// Might have a block that contains a transaction that contains a matching message.
 			auto bs = m_bc.blooms(h).blooms;
 			Manifests ms;
+			BlockInfo bi;
 			for (unsigned i = 0; i < bs.size(); ++i)
 				if (_f.matches(bs[i]))
 				{
@@ -517,45 +603,35 @@ PastMessages Client::transactions(TransactionFilter const& _f) const
 					PastMessages pm = _f.matches(changes, i);
 					if (pm.size())
 					{
+#if ETH_DEBUG
 						total += pm.size();
-						auto ts = BlockInfo(m_bc.block(h)).timestamp;
+#endif
+						if (!bi)
+							bi.populate(m_bc.block(h));
+						auto ts = bi.timestamp;
+						auto cb = bi.coinbaseAddress;
 						for (unsigned j = 0; j < pm.size() && ret.size() != m; ++j)
 							if (s)
 								s--;
 							else
 								// Have a transaction that contains a matching message.
-								ret.insert(ret.begin(), pm[j].polish(h, ts, cn - n + 2));
+								ret.push_back(pm[j].polish(h, ts, n, cb));
 					}
 				}
+#if ETH_DEBUG
 			if (!total)
 				falsePos++;
-/*			try
-			{
-				State st(m_stateDB, m_bc, h);
-				unsigned os = s;
-				for (unsigned i = st.pending().size(); i-- && ret.size() != m;)
-					if (_f.matches(st, i))
-					{
-						if (s)
-							s--;
-						else
-							ret.insert(ret.begin(), PastMessage(st.pending()[i], h, i, BlockInfo(m_bc.block(h)).timestamp, cn - n + 2));
-					}
-				if (os - s == st.pending().size())
-					falsePos++;
-			}
-			catch (...)
-			{
-				// Gaa. bad state. not good at all. bury head in sand for now.
-			}
-*/
 		}
 		else
 			skipped++;
-
+#else
+		}
+#endif
 		if (n == end)
 			break;
 	}
+#if ETH_DEBUG
 //	cdebug << (begin - n) << "searched; " << skipped << "skipped; " << falsePos << "false +ves";
+#endif
 	return ret;
 }

libethereum/Client.h

@@ -25,36 +25,30 @@
 #include <mutex>
 #include <list>
 #include <atomic>
-#include <libethential/Common.h>
+#include <boost/utility.hpp>
+#include <libdevcore/Common.h>
+#include <libdevcore/CommonIO.h>
+#include <libdevcore/Guards.h>
+#include <libdevcore/Worker.h>
+#include <libevm/FeeStructure.h>
 #include <libethcore/Dagger.h>
+#include <libp2p/Common.h>
 #include "BlockChain.h"
 #include "TransactionQueue.h"
 #include "State.h"
-#include "PeerNetwork.h"
+#include "CommonNet.h"
+#include "PastMessage.h"
+#include "MessageFilter.h"
+#include "Miner.h"
+#include "Interface.h"
 
-namespace eth
+namespace dev
 {
-
-struct MineProgress
+namespace eth
 {
-	double requirement;
-	double best;
-	double current;
-	uint hashes;
-	uint ms;
-};
 
 class Client;
-
-class ClientGuard
-{
-public:
-	inline ClientGuard(Client const* _c);
-	inline ~ClientGuard();
-
-private:
-	Client const* m_client;
-};
+class DownloadMan;
 
 enum ClientWorkState
 {
@@ -63,6 +57,12 @@ enum ClientWorkState
 	Deleted
 };
 
+enum class NodeMode
+{
+	PeerServer,
+	Full
+};
+
 class VersionChecker
 {
 public:
@@ -78,73 +78,45 @@ private:
 
 static const int GenesisBlock = INT_MIN;
 
-struct PastMessage
+struct InstalledFilter
 {
-	PastMessage(Manifest const& _m, std::vector<unsigned> _path, Address _o): to(_m.to), from(_m.from), value(_m.value), input(_m.input), output(_m.output), path(_path), origin(_o) {}
-
-	PastMessage& polish(h256 _b, u256 _ts, int _a) { block = _b; timestamp = _ts; age = _a; return *this; }
+	InstalledFilter(MessageFilter const& _f): filter(_f) {}
 
-	Address to;					///< The receiving address of the transaction. Address() in the case of a creation.
-	Address from;				///< The receiving address of the transaction. Address() in the case of a creation.
-	u256 value;					///< The value associated with the call.
-	bytes input;				///< The data associated with the message, or the initialiser if it's a creation transaction.
-	bytes output;				///< The data returned by the message, or the body code if it's a creation transaction.
-
-	std::vector<unsigned> path;	///< Call path into the block transaction. size() is always > 0. First item is the transaction index in the block.
-	Address origin;				///< Originating sender of the transaction.
-	h256 block;					///< Block hash.
-	u256 timestamp;			///< Block timestamp.
-	int age;					///< Transaction age.
+	MessageFilter filter;
+	unsigned refCount = 1;
 };
 
-typedef std::vector<PastMessage> PastMessages;
+static const h256 PendingChangedFilter = u256(0);
+static const h256 ChainChangedFilter = u256(1);
 
-class TransactionFilter
+struct ClientWatch
 {
-public:
-	TransactionFilter(int _earliest = GenesisBlock, int _latest = 0, unsigned _max = 10, unsigned _skip = 0): m_earliest(_earliest), m_latest(_latest), m_max(_max), m_skip(_skip) {}
-
-	int earliest() const { return m_earliest; }
-	int latest() const { return m_latest; }
-	unsigned max() const { return m_max; }
-	unsigned skip() const { return m_skip; }
-	bool matches(h256 _bloom) const;
-	bool matches(State const& _s, unsigned _i) const;
-	PastMessages matches(Manifest const& _m, unsigned _i) const;
-
-	TransactionFilter from(Address _a) { m_from.insert(_a); return *this; }
-	TransactionFilter to(Address _a) { m_to.insert(_a); return *this; }
-	TransactionFilter altered(Address _a, u256 _l) { m_stateAltered.insert(std::make_pair(_a, _l)); return *this; }
-	TransactionFilter altered(Address _a) { m_altered.insert(_a); return *this; }
-	TransactionFilter withMax(unsigned _m) { m_max = _m; return *this; }
-	TransactionFilter withSkip(unsigned _m) { m_skip = _m; return *this; }
-	TransactionFilter withEarliest(int _e) { m_earliest = _e; return *this; }
-	TransactionFilter withLatest(int _e) { m_latest = _e; return *this; }
+	ClientWatch() {}
+	explicit ClientWatch(h256 _id): id(_id) {}
 
-private:
-	bool matches(Manifest const& _m, std::vector<unsigned> _p, Address _o, PastMessages _limbo, PastMessages& o_ret) const;
-
-	std::set<Address> m_from;
-	std::set<Address> m_to;
-	std::set<std::pair<Address, u256>> m_stateAltered;
-	std::set<Address> m_altered;
-	int m_earliest;
-	int m_latest;
-	unsigned m_max;
-	unsigned m_skip;
+	h256 id;
+	unsigned changes = 1;
 };
 
+struct WatchChannel: public LogChannel { static const char* name() { return "(o)"; } static const int verbosity = 7; };
+#define cwatch dev::LogOutputStream<dev::eth::WatchChannel, true>()
+struct WorkInChannel: public LogChannel { static const char* name() { return ">W>"; } static const int verbosity = 16; };
+struct WorkOutChannel: public LogChannel { static const char* name() { return "<W<"; } static const int verbosity = 16; };
+struct WorkChannel: public LogChannel { static const char* name() { return "-W-"; } static const int verbosity = 16; };
+#define cwork dev::LogOutputStream<dev::eth::WorkChannel, true>()
+#define cworkin dev::LogOutputStream<dev::eth::WorkInChannel, true>()
+#define cworkout dev::LogOutputStream<dev::eth::WorkOutChannel, true>()
+
 /**
  * @brief Main API hub for interfacing with Ethereum.
  */
-class Client
+class Client: public MinerHost, public Interface, Worker
 {
-public:
-	/// Constructor.
-	explicit Client(std::string const& _clientVersion, Address _us = Address(), std::string const& _dbPath = std::string(), bool _forceClean = false);
+	friend class Miner;
 
-	// Start client. Boost require threads are started outside constructor.
-	void start();
+public:
+	/// New-style Constructor.
+	explicit Client(p2p::Host* _host, std::string const& _dbPath = std::string(), bool _forceClean = false, u256 _networkId = 0);
 
 	/// Destructor.
 	~Client();
@@ -156,107 +128,141 @@ public:
 	/// @returns the new contract's address (assuming it all goes through).
 	Address transact(Secret _secret, u256 _endowment, bytes const& _init, u256 _gas = 10000, u256 _gasPrice = 10 * szabo);
 
+	/// Injects the RLP-encoded transaction given by the _rlp into the transaction queue directly.
 	void inject(bytesConstRef _rlp);
 
-	/// Makes the given call. Nothing is recorded into the state. TODO
-//	bytes call(Secret _secret, u256 _amount, u256 _gasPrice, Address _dest, u256 _gas, bytes _data = bytes());
-
-	/// Requires transactions involving this address be queued for inspection.
-	void setInterest(Address _dest);
+	/// Blocks until all pending transactions have been processed.
+	void flushTransactions();
 
-	/// @returns incoming minable transactions that we wanted to be notified of. Clears the queue.
-	Transactions pendingQueue() { ClientGuard g(this); return m_tq.interestQueue(); }
+	/// Makes the given call. Nothing is recorded into the state.
+	bytes call(Secret _secret, u256 _value, Address _dest, bytes const& _data = bytes(), u256 _gas = 10000, u256 _gasPrice = 10 * szabo);
 
-	/// @returns alterations in state of a mined block that we wanted to be notified of. Clears the queue.
-	std::vector<std::pair<Address, AddressState>> minedQueue() { ClientGuard g(this); return m_bc.interestQueue(); }
+	// Informational stuff
 
-	// Not yet - probably best as using some sort of signals implementation.
-	/// Calls @a _f when a valid transaction is received that involves @a _dest and once per such transaction.
-//	void onPending(Address _dest, function<void(Transaction)> const& _f);
+	// [NEW API]
 
-	/// Calls @a _f when a transaction is mined that involves @a _dest and once per change.
-//	void onConfirmed(Address _dest, function<void(Transaction, AddressState)> const& _f);
+	using Interface::balanceAt;
+	using Interface::countAt;
+	using Interface::stateAt;
+	using Interface::codeAt;
+	using Interface::storageAt;
 
-	// Informational stuff
+	u256 balanceAt(Address _a, int _block) const;
+	u256 countAt(Address _a, int _block) const;
+	u256 stateAt(Address _a, u256 _l, int _block) const;
+	bytes codeAt(Address _a, int _block) const;
+	std::map<u256, u256> storageAt(Address _a, int _block) const;
 
-	/// Determines whether at least one of the state/blockChain/transactionQueue has changed since the last call to changed().
-	bool changed() const { auto ret = m_changed; m_changed = false; return ret; }
-	bool peekChanged() const { return m_changed; }
+	unsigned installWatch(MessageFilter const& _filter);
+	unsigned installWatch(h256 _filterId);
+	void uninstallWatch(unsigned _watchId);
+	bool peekWatch(unsigned _watchId) const { std::lock_guard<std::mutex> l(m_filterLock); try { return m_watches.at(_watchId).changes != 0; } catch (...) { return false; } }
+	bool checkWatch(unsigned _watchId) { std::lock_guard<std::mutex> l(m_filterLock); bool ret = false; try { ret = m_watches.at(_watchId).changes != 0; m_watches.at(_watchId).changes = 0; } catch (...) {} return ret; }
 
-	/// Get a map containing each of the pending transactions.
-	Transactions pending() const { return m_postMine.pending(); }
+	PastMessages messages(unsigned _watchId) const { try { std::lock_guard<std::mutex> l(m_filterLock); return messages(m_filters.at(m_watches.at(_watchId).id).filter); } catch (...) { return PastMessages(); } }
+	PastMessages messages(MessageFilter const& _filter) const;
 
-	// [OLD API]:
+	// [EXTRA API]:
 
-	/// Locks/unlocks the state/blockChain/transactionQueue for access.
-	void lock() const;
-	void unlock() const;
+	/// @returns the length of the chain.
+	virtual unsigned number() const { return m_bc.number(); }
 
-	/// Get the object representing the current state of Ethereum.
-	State const& state() const { return m_preMine; }
-	/// Get the object representing the current state of Ethereum.
-	State const& postState() const { return m_postMine; }
-	/// Get the object representing the current canonical blockchain.
-	BlockChain const& blockChain() const { return m_bc; }
-
-	// [NEW API]
+	/// Get a map containing each of the pending transactions.
+	/// @TODO: Remove in favour of transactions().
+	Transactions pending() const { return m_postMine.pending(); }
 
-	u256 balanceAt(Address _a, int _block = -1) const;
-	u256 countAt(Address _a, int _block = -1) const;
-	u256 stateAt(Address _a, u256 _l, int _block = -1) const;
-	bytes codeAt(Address _a, int _block = -1) const;
-	PastMessages transactions(TransactionFilter const& _f) const;
+	/// Differences between transactions.
+	using Interface::diff;
+	StateDiff diff(unsigned _txi, h256 _block) const;
+	StateDiff diff(unsigned _txi, int _block) const;
 
-	// Misc stuff:
+	/// Get a list of all active addresses.
+	using Interface::addresses;
+	std::vector<Address> addresses(int _block) const;
 
-	void setClientVersion(std::string const& _name) { m_clientVersion = _name; }
+	/// Get the remaining gas limit in this block.
+	u256 gasLimitRemaining() const { return m_postMine.gasLimitRemaining(); }
 
-	// Network stuff:
+	// [PRIVATE API - only relevant for base clients, not available in general]
 
-	/// Get information on the current peer set.
-	std::vector<PeerInfo> peers();
-	/// Same as peers().size(), but more efficient.
-	size_t peerCount() const;
+	dev::eth::State state(unsigned _txi, h256 _block) const;
+	dev::eth::State state(h256 _block) const;
+	dev::eth::State state(unsigned _txi) const;
 
-	/// Start the network subsystem.
-	void startNetwork(unsigned short _listenPort = 30303, std::string const& _remoteHost = std::string(), unsigned short _remotePort = 30303, NodeMode _mode = NodeMode::Full, unsigned _peers = 5, std::string const& _publicIP = std::string(), bool _upnp = true);
-	/// Connect to a particular peer.
-	void connect(std::string const& _seedHost, unsigned short _port = 30303);
-	/// Stop the network subsystem.
-	void stopNetwork();
-	/// Is the network subsystem up?
-	bool haveNetwork() { return !!m_net; }
-	/// Get access to the peer server object. This will be null if the network isn't online.
-	PeerServer* peerServer() const { return m_net.get(); }
+	/// Get the object representing the current state of Ethereum.
+	dev::eth::State postState() const { ReadGuard l(x_stateDB); return m_postMine; }
+	/// Get the object representing the current canonical blockchain.
+	BlockChain const& blockChain() const { return m_bc; }
 
 	// Mining stuff:
 
 	/// Check block validity prior to mining.
-	bool paranoia() const { return m_paranoia; }
+	bool miningParanoia() const { return m_paranoia; }
 	/// Change whether we check block validity prior to mining.
 	void setParanoia(bool _p) { m_paranoia = _p; }
+	/// Should we force mining to happen, even without transactions?
+	bool forceMining() const { return m_forceMining; }
+	/// Enable/disable forcing of mining to happen, even without transactions.
+	void setForceMining(bool _enable);
+	/// Are we mining as fast as we can?
+	bool turboMining() const { return m_turboMining; }
+	/// Enable/disable fast mining.
+	void setTurboMining(bool _enable = true) { m_turboMining = _enable; }
+
 	/// Set the coinbase address.
 	void setAddress(Address _us) { m_preMine.setAddress(_us); }
 	/// Get the coinbase address.
 	Address address() const { return m_preMine.address(); }
+	/// Stops mining and sets the number of mining threads (0 for automatic).
+	void setMiningThreads(unsigned _threads = 0);
+	/// Get the effective number of mining threads.
+	unsigned miningThreads() const { ReadGuard l(x_miners); return m_miners.size(); }
 	/// Start mining.
-	void startMining();
+	/// NOT thread-safe - call it & stopMining only from a single thread
+	void startMining() { startWorking(); ReadGuard l(x_miners); for (auto& m: m_miners) m.start(); }
 	/// Stop mining.
-	void stopMining();
+	/// NOT thread-safe
+	void stopMining() { ReadGuard l(x_miners); for (auto& m: m_miners) m.stop(); }
 	/// Are we mining now?
-	bool isMining() { return m_doMine; }
-	/// Register a callback for information concerning mining.
-	/// This callback will be in an arbitrary thread, blocking progress. JUST COPY THE DATA AND GET OUT.
+	bool isMining() { ReadGuard l(x_miners); return m_miners.size() && m_miners[0].isRunning(); }
 	/// Check the progress of the mining.
-	MineProgress miningProgress() const { return m_mineProgress; }
+	MineProgress miningProgress() const;
 	/// Get and clear the mining history.
-	std::list<MineInfo> miningHistory() { auto ret = m_mineHistory; m_mineHistory.clear(); return ret; }
+	std::list<MineInfo> miningHistory();
+
+	// Debug stuff:
 
+	DownloadMan const* downloadMan() const;
+	bool isSyncing() const;
+	/// Sets the network id.
+	void setNetworkId(u256 _n);
 	/// Clears pending transactions. Just for debug use.
-	void clearPending() { ClientGuard l(this); m_postMine = m_preMine; changed(); }
+	void clearPending();
+	/// Kills the blockchain. Just for debug use.
+	void killChain();
 
 private:
-	void work();
+	/// Do some work. Handles blockchain maintenance and mining.
+	virtual void doWork();
+
+	virtual void doneWorking();
+
+	/// Overrides for being a mining host.
+	virtual void setupState(State& _s);
+	virtual bool turbo() const { return m_turboMining; }
+	virtual bool force() const { return m_forceMining; }
+
+	/// Collate the changed filters for the bloom filter of the given pending transaction.
+	/// Insert any filters that are activated into @a o_changed.
+	void appendFromNewPending(h256 _pendingTransactionBloom, h256Set& o_changed) const;
+
+	/// Collate the changed filters for the hash of the given block.
+	/// Insert any filters that are activated into @a o_changed.
+	void appendFromNewBlock(h256 _blockHash, h256Set& o_changed) const;
+
+	/// Record that the set of filters @a _filters have changed.
+	/// This doesn't actually make any callbacks, but incrememnts some counters in m_watches.
+	void noteChanged(h256Set const& _filters);
 
 	/// Return the actual block number of the block with the given int-number (positive is the same, INT_MIN is genesis block, < 0 is negative age, thus -1 is most recently mined, 0 is pending.
 	unsigned numberOf(int _b) const;
@@ -264,36 +270,28 @@ private:
 	State asOf(int _h) const;
 	State asOf(unsigned _h) const;
 
-	std::string m_clientVersion;		///< Our end-application client's name/version.
-	VersionChecker m_vc;				///< Dummy object to check & update the protocol version.
-	BlockChain m_bc;					///< Maintains block database.
-	TransactionQueue m_tq;				///< Maintains list of incoming transactions not yet on the block chain.
+	VersionChecker m_vc;					///< Dummy object to check & update the protocol version.
+	BlockChain m_bc;						///< Maintains block database.
+	TransactionQueue m_tq;					///< Maintains a list of incoming transactions not yet in a block on the blockchain.
+	BlockQueue m_bq;						///< Maintains a list of incoming blocks not yet on the blockchain (to be imported).
+
+	mutable boost::shared_mutex x_stateDB;	///< Lock on the state DB, effectively a lock on m_postMine.
 	OverlayDB m_stateDB;					///< Acts as the central point for the state database, so multiple States can share it.
-	State m_preMine;					///< The present state of the client.
-	State m_postMine;					///< The state of the client which we're mining (i.e. it'll have all the rewards added).
-	std::unique_ptr<PeerServer> m_net;	///< Should run in background and send us events when blocks found and allow us to send blocks as required.
-	
-	std::unique_ptr<std::thread> m_work;///< The work thread.
-	
-	mutable std::recursive_mutex m_lock;
-	std::atomic<ClientWorkState> m_workState;
-	bool m_paranoia = false;
-	bool m_doMine = false;				///< Are we supposed to be mining?
-	MineProgress m_mineProgress;
-	std::list<MineInfo> m_mineHistory;
-	mutable bool m_restartMining = false;
-
-	mutable bool m_changed;
-};
+	State m_preMine;						///< The present state of the client.
+	State m_postMine;						///< The state of the client which we're mining (i.e. it'll have all the rewards added).
 
-inline ClientGuard::ClientGuard(Client const* _c): m_client(_c)
-{
-	m_client->lock();
-}
+	std::weak_ptr<EthereumHost> m_host;		///< Our Ethereum Host. Don't do anything if we can't lock.
 
-inline ClientGuard::~ClientGuard()
-{
-	m_client->unlock();
-}
+	std::vector<Miner> m_miners;
+	mutable boost::shared_mutex x_miners;
+	bool m_paranoia = false;				///< Should we be paranoid about our state?
+	bool m_turboMining = false;				///< Don't squander all of our time mining actually just sleeping.
+	bool m_forceMining = false;				///< Mine even when there are no transactions pending?
 
+	mutable std::mutex m_filterLock;
+	std::map<h256, InstalledFilter> m_filters;
+	std::map<unsigned, ClientWatch> m_watches;
+};
+
+}
 }

libethereum/CommonNet.cpp

@@ -0,0 +1,28 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file PeerNetwork.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "CommonNet.h"
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+#pragma GCC diagnostic ignored "-Wunused-variable"
+namespace { char dummy; };

libethereum/CommonNet.h

@@ -0,0 +1,74 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file PeerNetwork.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ *
+ * Miscellanea required for the PeerServer/Session classes.
+ */
+
+#pragma once
+
+#include <string>
+#include <chrono>
+#include <libdevcore/Common.h>
+#include <libdevcore/Log.h>
+
+namespace dev
+{
+namespace eth
+{
+
+#if ETH_DEBUG
+static const unsigned c_maxHashes = 64;		///< Maximum number of hashes BlockHashes will ever send.
+static const unsigned c_maxHashesAsk = 64;		///< Maximum number of hashes GetBlockHashes will ever ask for.
+static const unsigned c_maxBlocks = 32;		///< Maximum number of blocks Blocks will ever send.
+static const unsigned c_maxBlocksAsk = 32;		///< Maximum number of blocks we ask to receive in Blocks (when using GetChain).
+#else
+static const unsigned c_maxHashes = 256;		///< Maximum number of hashes BlockHashes will ever send.
+static const unsigned c_maxHashesAsk = 256;		///< Maximum number of hashes GetBlockHashes will ever ask for.
+static const unsigned c_maxBlocks = 128;		///< Maximum number of blocks Blocks will ever send.
+static const unsigned c_maxBlocksAsk = 128;		///< Maximum number of blocks we ask to receive in Blocks (when using GetChain).
+#endif
+class OverlayDB;
+class BlockChain;
+class TransactionQueue;
+class EthereumHost;
+class EthereumPeer;
+
+enum EthereumPacket
+{
+	StatusPacket = 0x10,
+	GetTransactionsPacket,
+	TransactionsPacket,
+	GetBlockHashesPacket,
+	BlockHashesPacket,
+	GetBlocksPacket,
+	BlocksPacket,
+};
+
+enum class Grabbing
+{
+	State,
+	Hashes,
+	Chain,
+	ChainHelper,
+	Nothing
+};
+
+}
+}

libethereum/Defaults.cpp

@@ -21,9 +21,10 @@
 
 #include "Defaults.h"
 
-#include <libethcore/FileSystem.h>
+#include <libdevcrypto/FileSystem.h>
 using namespace std;
-using namespace eth;
+using namespace dev;
+using namespace dev::eth;
 
 Defaults* Defaults::s_this = nullptr;
 

libethereum/Defaults.h

@@ -21,8 +21,10 @@
 
 #pragma once
 
-#include <libethential/Common.h>
+#include <libdevcore/Common.h>
 
+namespace dev
+{
 namespace eth
 {
 
@@ -45,3 +47,4 @@ private:
 };
 
 }
+}

libethereum/DownloadMan.cpp

@@ -0,0 +1,75 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file DownloadMan.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "DownloadMan.h"
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+
+DownloadSub::DownloadSub(DownloadMan& _man): m_man(&_man)
+{
+	WriteGuard l(m_man->x_subs);
+	m_man->m_subs.insert(this);
+}
+
+DownloadSub::~DownloadSub()
+{
+	if (m_man)
+	{
+		WriteGuard l(m_man->x_subs);
+		m_man->m_subs.erase(this);
+	}
+}
+
+h256Set DownloadSub::nextFetch(unsigned _n)
+{
+	Guard l(m_fetch);
+
+	if (m_remaining.size())
+		return m_remaining;
+
+	m_asked.clear();
+	m_indices.clear();
+	m_remaining.clear();
+
+	if (!m_man)
+		return h256Set();
+
+	m_asked = (~(m_man->taken() + m_attempted)).lowest(_n);
+	if (m_asked.empty())
+		m_asked = (~(m_man->taken(true) + m_attempted)).lowest(_n);
+	m_attempted += m_asked;
+	for (auto i: m_asked)
+	{
+		auto x = m_man->m_chain[i];
+		m_remaining.insert(x);
+		m_indices[x] = i;
+	}
+	return m_remaining;
+}
+
+void DownloadSub::noteBlock(h256 _hash)
+{
+	Guard l(m_fetch);
+	if (m_man && m_indices.count(_hash))
+		m_man->m_blocksGot += m_indices[_hash];
+	m_remaining.erase(_hash);
+}

libethereum/DownloadMan.h

@@ -0,0 +1,136 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file DownloadMan.h
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#pragma once
+
+#include <map>
+#include <vector>
+#include <set>
+#include <libdevcore/Guards.h>
+#include <libdevcore/Worker.h>
+#include <libdevcore/RangeMask.h>
+#include <libdevcore/FixedHash.h>
+
+namespace dev
+{
+
+namespace eth
+{
+
+class DownloadMan;
+
+class DownloadSub
+{
+	friend class DownloadMan;
+
+public:
+	DownloadSub(DownloadMan& _man);
+	~DownloadSub();
+
+	/// Finished last fetch - grab the next bunch of block hashes to download.
+	h256Set nextFetch(unsigned _n);
+
+	/// Note that we've received a particular block.
+	void noteBlock(h256 _hash);
+
+	/// Nothing doing here.
+	void doneFetch() { resetFetch(); }
+
+	RangeMask<unsigned> const& asked() const { return m_asked; }
+	RangeMask<unsigned> const& attemped() const { return m_attempted; }
+
+private:
+	void resetFetch()		// Called by DownloadMan when we need to reset the download.
+	{
+		Guard l(m_fetch);
+		m_remaining.clear();
+		m_indices.clear();
+		m_asked.clear();
+		m_attempted.clear();
+	}
+
+	DownloadMan* m_man = nullptr;
+
+	Mutex m_fetch;
+	h256Set m_remaining;
+	std::map<h256, unsigned> m_indices;
+	RangeMask<unsigned> m_asked;
+	RangeMask<unsigned> m_attempted;
+};
+
+class DownloadMan
+{
+	friend class DownloadSub;
+
+public:
+	~DownloadMan()
+	{
+		for (auto i: m_subs)
+			i->m_man = nullptr;
+	}
+
+	void resetToChain(h256s const& _chain)
+	{
+		{
+			ReadGuard l(x_subs);
+			for (auto i: m_subs)
+				i->resetFetch();
+		}
+		m_chain.clear();
+		m_chain.reserve(_chain.size());
+		for (auto i = _chain.rbegin(); i != _chain.rend(); ++i)
+			m_chain.push_back(*i);
+		m_blocksGot = RangeMask<unsigned>(0, m_chain.size());
+	}
+
+	RangeMask<unsigned> taken(bool _desperate = false) const
+	{
+		auto ret = m_blocksGot;
+		if (!_desperate)
+		{
+			ReadGuard l(x_subs);
+			for (auto i: m_subs)
+				ret += i->m_asked;
+		}
+		return ret;
+	}
+
+	bool isComplete() const
+	{
+		return m_blocksGot.full();
+	}
+
+	h256s chain() const { return m_chain; }
+	void foreachSub(std::function<void(DownloadSub const&)> const& _f) const { ReadGuard l(x_subs); for(auto i: m_subs) _f(*i); }
+	unsigned subCount() const { ReadGuard l(x_subs); return m_subs.size(); }
+	RangeMask<unsigned> blocksGot() const { return m_blocksGot; }
+
+private:
+	h256s m_chain;
+	RangeMask<unsigned> m_blocksGot;
+
+	mutable SharedMutex x_subs;
+	std::set<DownloadSub*> m_subs;
+};
+
+}
+
+}

libethereum/EthereumHost.cpp

@@ -0,0 +1,281 @@
+/*
+	This file is part of cpp-ethereum.
+
+	cpp-ethereum 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.
+
+	cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file EthereumHost.cpp
+ * @author Gav Wood <i@gavwood.com>
+ * @date 2014
+ */
+
+#include "EthereumHost.h"
+
+#include <set>
+#include <chrono>
+#include <thread>
+#include <libdevcore/Common.h>
+#include <libp2p/Host.h>
+#include <libp2p/Session.h>
+#include <libethcore/Exceptions.h>
+#include "BlockChain.h"
+#include "TransactionQueue.h"
+#include "BlockQueue.h"
+#include "EthereumPeer.h"
+#include "DownloadMan.h"
+using namespace std;
+using namespace dev;
+using namespace dev::eth;
+using namespace p2p;
+
+EthereumHost::EthereumHost(BlockChain const& _ch, TransactionQueue& _tq, BlockQueue& _bq, u256 _networkId):
+	HostCapability<EthereumPeer>(),
+	Worker		("ethsync"),
+	m_chain		(_ch),
+	m_tq		(_tq),
+	m_bq		(_bq),
+	m_networkId	(_networkId)
+{
+	m_latestBlockSent = _ch.currentHash();
+}
+
+EthereumHost::~EthereumHost()
+{
+	for (auto const& i: peers())
+		i->cap<EthereumPeer>()->giveUpOnFetch();
+}
+
+bool EthereumHost::ensureInitialised(TransactionQueue& _tq)
+{
+	if (!m_latestBlockSent)
+	{
+		// First time - just initialise.
+		m_latestBlockSent = m_chain.currentHash();
+		clog(NetNote) << "Initialising: latest=" << m_latestBlockSent.abridged();
+
+		for (auto const& i: _tq.transactions())
+			m_transactionsSent.insert(i.first);
+		return true;
+	}
+	return false;
+}
+
+void EthereumHost::noteHavePeerState(EthereumPeer* _who)
+{
+	clog(NetAllDetail) << "Have peer state.";
+
+	// if already downloading hash-chain, ignore.
+	if (m_grabbing != Grabbing::Nothing)
+	{
+		clog(NetAllDetail) << "Already downloading chain. Just set to help out.";
+		_who->ensureGettingChain();
+		return;
+	}
+
+	// otherwise check to see if we should be downloading...
+	_who->tryGrabbingHashChain();
+}
+
+void EthereumHost::updateGrabbing(Grabbing _g)
+{
+	m_grabbing = _g;
+	if (_g == Grabbing::Nothing)
+		readyForSync();
+	else if (_g == Grabbing::Chain)
+		for (auto j: peers())
+			j->cap<EthereumPeer>()->ensureGettingChain();
+}
+
+void EthereumHost::noteHaveChain(EthereumPeer* _from)
+{
+	auto td = _from->m_totalDifficulty;
+
+	if (_from->m_neededBlocks.empty())
+	{
+		_from->m_grabbing = Grabbing::Nothing;
+		updateGrabbing(Grabbing::Nothing);
+		return;
+	}
+
+	clog(NetNote) << "Hash-chain COMPLETE:" << _from->m_totalDifficulty << "vs" << m_chain.details().totalDifficulty << ";" << _from->m_neededBlocks.size() << " blocks, ends" << _from->m_neededBlocks.back().abridged();
+
+	if (td < m_chain.details().totalDifficulty || (td == m_chain.details().totalDifficulty && m_chain.currentHash() == _from->m_latestHash))
+	{
+		clog(NetNote) << "Difficulty of hashchain not HIGHER. Ignoring.";
+		_from->m_grabbing = Grabbing::Nothing;
+		updateGrabbing(Grabbing::Nothing);
+		return;
+	}
+
+	clog(NetNote) << "Difficulty of hashchain HIGHER. Replacing fetch queue [latest now" << _from->m_latestHash.abridged() << ", was" << m_latestBlockSent.abridged() << "]";
+
+	// Looks like it's the best yet for total difficulty. Set to download.
+	m_man.resetToChain(_from->m_neededBlocks);
+	m_latestBlockSent = _from->m_latestHash;
+
+	_from->m_grabbing = Grabbing::Chain;
+	updateGrabbing(Grabbing::Chain);
+}
+
+void EthereumHost::readyForSync()
+{
+	// start grabbing next hash chain if there is one.
+	for (auto j: peers())
+	{
+		j->cap<EthereumPeer>()->tryGrabbingHashChain();
+		if (j->cap<EthereumPeer>()->m_grabbing == Grabbing::Hashes)
+		{
+			m_grabbing = Grabbing::Hashes;
+			return;
+		}
+	}
+	clog(NetNote) << "No more peers to sync with.";
+}
+
+void EthereumHost::noteDoneBlocks(EthereumPeer* _who)
+{
+	if (m_man.isComplete())
+	{
+		// Done our chain-get.
+		clog(NetNote) << "Chain download complete.";
+		updateGrabbing(Grabbing::Nothing);
+	}
+	if (_who->m_grabbing == Grabbing::Chain)
+	{
+		// Done our chain-get.
+		clog(NetNote) << "Chain download failed. Peer with blocks didn't have them all. This peer is bad and should be punished.";
+		// TODO: note that peer is BADBADBAD!
+		updateGrabbing(Grabbing::Nothing);
+	}
+}
+
+bool EthereumHost::noteBlock(h256 _hash, bytesConstRef _data)
+{
+	if (!m_chain.details(_hash))
+	{
+		lock_guard<recursive_mutex> l(m_incomingLock);
+		m_incomingBlocks.push_back(_data.toBytes());
+		return true;
+	}
+	return false;
+}
+
+void EthereumHost::doWork()
+{
+	bool netChange = ensureInitialised(m_tq);
+	auto h = m_chain.currentHash();
+	maintainTransactions(m_tq, h);
+	maintainBlocks(m_bq, h);
+//	return netChange;
+	// TODO: Figure out what to do with netChange.
+	(void)netChange;
+}
+
+void EthereumHost::maintainTransactions(TransactionQueue& _tq, h256 _currentHash)
+{
+	bool resendAll = (_currentHash != m_latestBlockSent);
+	{
+		lock_guard<recursive_mutex> l(m_incomingLock);
+		for (auto it = m_incomingTransactions.begin(); it != m_incomingTransactions.end(); ++it)
+			if (_tq.import(&*it))
+			{}//ret = true;		// just putting a transaction in the queue isn't enough to change the state - it might have an invalid nonce...
+			else
+				m_transactionsSent.insert(sha3(*it));	// if we already had the transaction, then don't bother sending it on.
+		m_incomingTransactions.clear();
+	}
+
+	// Send any new transactions.
+	for (auto const& p: peers())
+	{
+		auto ep = p->cap<EthereumPeer>();
+		if (ep)
+		{
+			bytes b;
+			unsigned n = 0;
+			for (auto const& i: _tq.transactions())
+				if ((!m_transactionsSent.count(i.first) && !ep->m_knownTransactions.count(i.first)) || ep->m_requireTransactions || resendAll)
+				{
+					b += i.second;
+					++n;
+					m_transactionsSent.insert(i.first);
+				}
+			ep->clearKnownTransactions();
+			
+			if (n)
+			{
+				RLPStream ts;
+				EthereumPeer::prep(ts);
+				ts.appendList(n + 1) << TransactionsPacket;
+				ts.appendRaw(b, n).swapOut(b);
+				seal(b);
+				ep->send(&b);
+			}
+			ep->m_requireTransactions = false;
+		}
+	}
+}
+
+void EthereumHost::reset()
+{
+	m_grabbing = Grabbing::Nothing;
+
+	m_man.resetToChain(h256s());
+
+	m_incomingTransactions.clear();
+	m_incomingBlocks.clear();
+
+	m_latestBlockSent = h256();
+	m_transactionsSent.clear();
+}
+
+void EthereumHost::maintainBlocks(BlockQueue& _bq, h256 _currentHash)
+{
+	// Import new blocks
+	{
+		lock_guard<recursive_mutex> l(m_incomingLock);
+		for (auto it = m_incomingBlocks.rbegin(); it != m_incomingBlocks.rend(); ++it)
+			if (_bq.import(&*it, m_chain))
+			{}
+			else{} // TODO: don't forward it.
+		m_incomingBlocks.clear();
+	}
+
+	// If we've finished our initial sync send any new blocks.
+	if (m_grabbing == Grabbing::Nothing && m_chain.details(m_latestBlockSent) && m_chain.details(m_latestBlockSent).totalDifficulty < m_chain.details(_currentHash).totalDifficulty)
+	{
+		RLPStream ts;
+		EthereumPeer::prep(ts);
+		bytes bs;
+		unsigned c = 0;
+		for (auto h: m_chain.treeRoute(m_latestBlockSent, _currentHash, nullptr, false, true))
+		{
+			bs += m_chain.block(h);
+			++c;
+		}
+		clog(NetMessageSummary) << "Sending" << c << "new blocks (current is" << _currentHash << ", was" << m_latestBlockSent << ")";
+		ts.appendList(1 + c).append(BlocksPacket).appendRaw(bs, c);
+		bytes b;
+		ts.swapOut(b);
+		seal(b);
+
+		for (auto j: peers())
+		{
+			auto p = j->cap<EthereumPeer>();
+			Guard l(p->x_knownBlocks);
+			if (!p->m_knownBlocks.count(_currentHash))
+				p->send(&b);
+			p->m_knownBlocks.clear();
+		}
+		m_latestBlockSent = _currentHash;
+	}
+}