Merge pull request #672 from hermeznetwork/feature/configurable-recommendedfee-strategy

Add configuration option to choose recommended fee strategy, and add …

.github/workflows/release.yml

@@ -0,0 +1,29 @@
+name: goreleaser
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      -
+        name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.16
+      -
+        name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v2
+        with:
+          version: latest
+          args: release --rm-dist
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.goreleaser.yml

@@ -0,0 +1,36 @@
+before:
+  hooks:
+    - go mod download
+
+builds:
+  - main: ./cli/node/main.go
+    binary: node
+    id: node
+    goos:
+      - linux
+      - darwin
+      - windows
+    hooks:
+      pre: make migration-pack
+      post: make migration-clean
+
+archives:
+  - replacements:
+      darwin: Darwin
+      linux: Linux
+      windows: Windows
+      386: i386
+      amd64: x86_64
+
+checksum:
+  name_template: 'checksums.txt'
+
+snapshot:
+  name_template: "{{ .Tag }}-next"
+
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are 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.
+
+  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.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  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 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 work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero 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 Affero 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 Affero 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 Affero 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 Affero 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 Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  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 AGPL, see
+<https://www.gnu.org/licenses/>.

Makefile

@@ -3,8 +3,8 @@
 # Project variables.
 PACKAGE := github.com/hermeznetwork/hermez-node
 VERSION := $(shell git describe --tags --always)
-BUILD := $(shell git rev-parse --short HEAD)
+COMMIT := $(shell git rev-parse --short HEAD)
-BUILD_DATE := $(shell date +%Y-%m-%dT%H:%M:%S%z)
+DATE := $(shell date +%Y-%m-%dT%H:%M:%S%z)
 PROJECT_NAME := $(shell basename "$(PWD)")
 
 # Go related variables.
@@ -23,7 +23,7 @@ CONFIG ?= $(GOBASE)/cli/node/cfg.buidler.toml
 POSTGRES_PASS ?= yourpasswordhere
 
 # Use linker flags to provide version/build settings.
-LDFLAGS=-ldflags "-X=main.Version=$(VERSION) -X=main.Build=$(BUILD) -X=main.Date=$(BUILD_DATE)"
+LDFLAGS=-ldflags "-X main.version=$(VERSION) -X main.commit=$(COMMIT) -X main.date=$(DATE)"
 
 # PID file will keep the process id of the server.
 PID_PROOF_MOCK := /tmp/.$(PROJECT_NAME).proof.pid
@@ -94,11 +94,11 @@ install:
 	@echo "  >  Checking if there is any missing dependencies..."
 	$(GOENVVARS) go get $(GOCMD)/... $(get)
 
-## run: Run Hermez node.
+## run-node: Run Hermez node.
-run:
+run-node:
 	@bash -c "$(MAKE) clean build"
 	@echo "  >  Running $(PROJECT_NAME)"
-	@$(GOBIN)/$(GOBINARY) --mode $(MODE) --cfg $(CONFIG) run
+	@$(GOBIN)/$(GOBINARY) run --mode $(MODE) --cfg $(CONFIG)
 
 ## run-proof-mock: Run proof server mock API.
 run-proof-mock: stop-proof-mock

README.md

@@ -25,13 +25,13 @@ there are more information about the config file into [cli/node/README.md](cli/n
 After setting the config, you can build and run the Hermez Node as a synchronizer:
 
 ```shell
-$ make run
+$ make run-node
 ```
 
 Or build and run as a coordinator, and also passing the config file from other location:
 
 ```shell
-$ MODE=sync CONFIG=cli/node/cfg.buidler.toml make run
+$ MODE=sync CONFIG=cli/node/cfg.buidler.toml make run-node
 ```
 
 To check the useful make commands:

api/account_test.go

@@ -5,7 +5,7 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/mitchellh/copystructure"

api/accountcreationauths.go

@@ -7,7 +7,7 @@ import (
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/gin-gonic/gin"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 )

api/api.go

@@ -50,38 +50,40 @@ func NewAPI(
 		hermezAddress: consts.HermezAddress,
 	}
 
+	v1 := server.Group("/v1")
+
 	// Add coordinator endpoints
 	if coordinatorEndpoints {
 		// Account
-		server.POST("/account-creation-authorization", a.postAccountCreationAuth)
+		v1.POST("/account-creation-authorization", a.postAccountCreationAuth)
-		server.GET("/account-creation-authorization/:hezEthereumAddress", a.getAccountCreationAuth)
+		v1.GET("/account-creation-authorization/:hezEthereumAddress", a.getAccountCreationAuth)
 		// Transaction
-		server.POST("/transactions-pool", a.postPoolTx)
+		v1.POST("/transactions-pool", a.postPoolTx)
-		server.GET("/transactions-pool/:id", a.getPoolTx)
+		v1.GET("/transactions-pool/:id", a.getPoolTx)
 	}
 
 	// Add explorer endpoints
 	if explorerEndpoints {
 		// Account
-		server.GET("/accounts", a.getAccounts)
+		v1.GET("/accounts", a.getAccounts)
-		server.GET("/accounts/:accountIndex", a.getAccount)
+		v1.GET("/accounts/:accountIndex", a.getAccount)
-		server.GET("/exits", a.getExits)
+		v1.GET("/exits", a.getExits)
-		server.GET("/exits/:batchNum/:accountIndex", a.getExit)
+		v1.GET("/exits/:batchNum/:accountIndex", a.getExit)
 		// Transaction
-		server.GET("/transactions-history", a.getHistoryTxs)
+		v1.GET("/transactions-history", a.getHistoryTxs)
-		server.GET("/transactions-history/:id", a.getHistoryTx)
+		v1.GET("/transactions-history/:id", a.getHistoryTx)
 		// Status
-		server.GET("/batches", a.getBatches)
+		v1.GET("/batches", a.getBatches)
-		server.GET("/batches/:batchNum", a.getBatch)
+		v1.GET("/batches/:batchNum", a.getBatch)
-		server.GET("/full-batches/:batchNum", a.getFullBatch)
+		v1.GET("/full-batches/:batchNum", a.getFullBatch)
-		server.GET("/slots", a.getSlots)
+		v1.GET("/slots", a.getSlots)
-		server.GET("/slots/:slotNum", a.getSlot)
+		v1.GET("/slots/:slotNum", a.getSlot)
-		server.GET("/bids", a.getBids)
+		v1.GET("/bids", a.getBids)
-		server.GET("/state", a.getState)
+		v1.GET("/state", a.getState)
-		server.GET("/config", a.getConfig)
+		v1.GET("/config", a.getConfig)
-		server.GET("/tokens", a.getTokens)
+		v1.GET("/tokens", a.getTokens)
-		server.GET("/tokens/:id", a.getToken)
+		v1.GET("/tokens/:id", a.getToken)
-		server.GET("/coordinators", a.getCoordinators)
+		v1.GET("/coordinators", a.getCoordinators)
 	}
 
 	return a, nil

api/api_test.go

@@ -19,12 +19,12 @@ import (
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	swagger "github.com/getkin/kin-openapi/openapi3filter"
 	"github.com/gin-gonic/gin"
+	"github.com/hermeznetwork/hermez-node/api/stateapiupdater"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
 	"github.com/hermeznetwork/hermez-node/log"
-	"github.com/hermeznetwork/hermez-node/stateapiupdater"
 	"github.com/hermeznetwork/hermez-node/test"
 	"github.com/hermeznetwork/hermez-node/test/til"
 	"github.com/hermeznetwork/hermez-node/test/txsets"
@@ -40,8 +40,8 @@ type Pendinger interface {
 	New() Pendinger
 }
 
-const apiAddr = ":4010"
+const apiPort = "4010"
-const apiURL = "http://localhost" + apiAddr + "/"
+const apiURL = "http://localhost:" + apiPort + "/v1/"
 
 var SetBlockchain = `
 	Type: Blockchain
@@ -209,7 +209,7 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 	// L2DB
-	l2DB := l2db.NewL2DB(database, database, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
+	l2DB := l2db.NewL2DB(database, database, 10, 1000, 0.0, 1000.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB()) // this will clean HistoryDB and L2DB
 	// Config (smart contract constants)
 	chainID := uint16(0)
@@ -240,6 +240,7 @@ func TestMain(m *testing.M) {
 	nodeConfig := &historydb.NodeConfig{
 		MaxPoolTxs: 10,
 		MinFeeUSD:  0,
+		MaxFeeUSD:  10000000000,
 	}
 	if err := hdb.SetNodeConfig(nodeConfig); err != nil {
 		panic(err)
@@ -257,7 +258,7 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 	// Start server
-	listener, err := net.Listen("tcp", apiAddr) //nolint:gosec
+	listener, err := net.Listen("tcp", ":"+apiPort) //nolint:gosec
 	if err != nil {
 		panic(err)
 	}
@@ -521,11 +522,16 @@ func TestMain(m *testing.M) {
 		WithdrawalDelay: uint64(3000),
 	}
 
-	stateAPIUpdater = stateapiupdater.NewUpdater(hdb, nodeConfig, &common.SCVariables{
+	stateAPIUpdater, err = stateapiupdater.NewUpdater(hdb, nodeConfig, &common.SCVariables{
 		Rollup:   rollupVars,
 		Auction:  auctionVars,
 		WDelayer: wdelayerVars,
-	}, constants)
+	}, constants, &stateapiupdater.RecommendedFeePolicy{
+		PolicyType: stateapiupdater.RecommendedFeePolicyTypeAvgLastHour,
+	})
+	if err != nil {
+		panic(err)
+	}
 
 	// Generate test data, as expected to be received/sended from/to the API
 	testCoords := genTestCoordinators(commonCoords)
@@ -615,13 +621,13 @@ func TestTimeout(t *testing.T) {
 	hdbTO := historydb.NewHistoryDB(databaseTO, databaseTO, apiConnConTO)
 	require.NoError(t, err)
 	// L2DB
-	l2DBTO := l2db.NewL2DB(databaseTO, databaseTO, 10, 1000, 1.0, 24*time.Hour, apiConnConTO)
+	l2DBTO := l2db.NewL2DB(databaseTO, databaseTO, 10, 1000, 1.0, 1000.0, 24*time.Hour, apiConnConTO)
 
 	// API
 	apiGinTO := gin.Default()
 	finishWait := make(chan interface{})
 	startWait := make(chan interface{})
-	apiGinTO.GET("/wait", func(c *gin.Context) {
+	apiGinTO.GET("/v1/wait", func(c *gin.Context) {
 		cancel, err := apiConnConTO.Acquire()
 		defer cancel()
 		require.NoError(t, err)
@@ -649,9 +655,9 @@ func TestTimeout(t *testing.T) {
 	require.NoError(t, err)
 
 	client := &http.Client{}
-	httpReq, err := http.NewRequest("GET", "http://localhost:4444/tokens", nil)
+	httpReq, err := http.NewRequest("GET", "http://localhost:4444/v1/tokens", nil)
 	require.NoError(t, err)
-	httpReqWait, err := http.NewRequest("GET", "http://localhost:4444/wait", nil)
+	httpReqWait, err := http.NewRequest("GET", "http://localhost:4444/v1/wait", nil)
 	require.NoError(t, err)
 	// Request that will get timed out
 	var wg sync.WaitGroup

api/batch_test.go

@@ -7,7 +7,7 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/mitchellh/copystructure"

api/exits_test.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/mitchellh/copystructure"

api/state_test.go

@@ -4,7 +4,7 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/stretchr/testify/assert"
@@ -145,8 +145,8 @@ func TestUpdateMetrics(t *testing.T) {
 	assert.Greater(t, ni.StateAPI.Metrics.TransactionsPerBatch, float64(0))
 	assert.Greater(t, ni.StateAPI.Metrics.BatchFrequency, float64(0))
 	assert.Greater(t, ni.StateAPI.Metrics.TransactionsPerSecond, float64(0))
-	assert.Greater(t, ni.StateAPI.Metrics.TotalAccounts, int64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.TokenAccounts, int64(0))
-	assert.Greater(t, ni.StateAPI.Metrics.TotalBJJs, int64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.Wallets, int64(0))
 	assert.Greater(t, ni.StateAPI.Metrics.AvgTransactionFee, float64(0))
 }
 
@@ -210,8 +210,8 @@ func TestGetState(t *testing.T) {
 	assert.Greater(t, status.Metrics.TransactionsPerBatch, float64(0))
 	assert.Greater(t, status.Metrics.BatchFrequency, float64(0))
 	assert.Greater(t, status.Metrics.TransactionsPerSecond, float64(0))
-	assert.Greater(t, status.Metrics.TotalAccounts, int64(0))
+	assert.Greater(t, status.Metrics.TokenAccounts, int64(0))
-	assert.Greater(t, status.Metrics.TotalBJJs, int64(0))
+	assert.Greater(t, status.Metrics.Wallets, int64(0))
 	assert.Greater(t, status.Metrics.AvgTransactionFee, float64(0))
 	// Recommended fee
 	// TODO: perform real asserts (not just greater than 0)

api/stateapiupdater/stateapiupdater.go

@@ -2,10 +2,12 @@ package stateapiupdater
 
 import (
 	"database/sql"
+	"fmt"
 	"sync"
 
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
+	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/tracerr"
 )
 
@@ -17,23 +19,58 @@ type Updater struct {
 	vars   common.SCVariablesPtr
 	consts historydb.Constants
 	rw     sync.RWMutex
+	rfp    *RecommendedFeePolicy
+}
+
+// RecommendedFeePolicy describes how the recommended fee is calculated
+type RecommendedFeePolicy struct {
+	PolicyType  RecommendedFeePolicyType `validate:"required"`
+	StaticValue float64
+}
+
+// RecommendedFeePolicyType describes the different available recommended fee strategies
+type RecommendedFeePolicyType string
+
+const (
+	// RecommendedFeePolicyTypeStatic always give the same StaticValue as recommended fee
+	RecommendedFeePolicyTypeStatic RecommendedFeePolicyType = "Static"
+	// RecommendedFeePolicyTypeAvgLastHour set the recommended fee using the average fee of the last hour
+	RecommendedFeePolicyTypeAvgLastHour RecommendedFeePolicyType = "AvgLastHour"
+)
+
+func (rfp *RecommendedFeePolicy) valid() bool {
+	switch rfp.PolicyType {
+	case RecommendedFeePolicyTypeStatic:
+		if rfp.StaticValue == 0 {
+			log.Warn("RcommendedFee is set to 0 USD, and the policy is static")
+		}
+		return true
+	case RecommendedFeePolicyTypeAvgLastHour:
+		return true
+	default:
+		return false
+	}
 }
 
 // NewUpdater creates a new Updater
 func NewUpdater(hdb *historydb.HistoryDB, config *historydb.NodeConfig, vars *common.SCVariables,
-	consts *historydb.Constants) *Updater {
+	consts *historydb.Constants, rfp *RecommendedFeePolicy) (*Updater, error) {
+	if ok := rfp.valid(); !ok {
+		return nil, tracerr.Wrap(fmt.Errorf("Invalid recommended fee policy: %v", rfp.PolicyType))
+	}
 	u := Updater{
 		hdb:    hdb,
 		config: *config,
 		consts: *consts,
 		state: historydb.StateAPI{
-			NodePublicConfig: historydb.NodePublicConfig{
+			NodePublicInfo: historydb.NodePublicInfo{
 				ForgeDelay: config.ForgeDelay,
 			},
 		},
+		rfp: rfp,
 	}
 	u.SetSCVars(vars.AsPtr())
-	return &u
+	return &u, nil
 }
 
 // Store the State in the HistoryDB
@@ -65,13 +102,27 @@ func (u *Updater) SetSCVars(vars *common.SCVariablesPtr) {
 
 // UpdateRecommendedFee update Status.RecommendedFee information
 func (u *Updater) UpdateRecommendedFee() error {
-	recommendedFee, err := u.hdb.GetRecommendedFee(u.config.MinFeeUSD)
+	switch u.rfp.PolicyType {
-	if err != nil {
+	case RecommendedFeePolicyTypeStatic:
-		return tracerr.Wrap(err)
+		u.rw.Lock()
+		u.state.RecommendedFee = common.RecommendedFee{
+			ExistingAccount:        u.rfp.StaticValue,
+			CreatesAccount:         u.rfp.StaticValue,
+			CreatesAccountInternal: u.rfp.StaticValue,
+		}
+		u.rw.Unlock()
+	case RecommendedFeePolicyTypeAvgLastHour:
+		recommendedFee, err := u.hdb.GetRecommendedFee(u.config.MinFeeUSD, u.config.MaxFeeUSD)
+		if err != nil {
+			return tracerr.Wrap(err)
+		}
+		u.rw.Lock()
+		u.state.RecommendedFee = *recommendedFee
+		u.rw.Unlock()
+	default:
+		return tracerr.New("Invalid recommende fee policy")
 	}
-	u.rw.Lock()
+
-	u.state.RecommendedFee = *recommendedFee
-	u.rw.Unlock()
 	return nil
 }
 
@@ -84,12 +135,13 @@ func (u *Updater) UpdateMetrics() error {
 		return nil
 	}
 	lastBatchNum := lastBatch.BatchNum
-	metrics, err := u.hdb.GetMetricsInternalAPI(lastBatchNum)
+	metrics, poolLoad, err := u.hdb.GetMetricsInternalAPI(lastBatchNum)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
 	u.rw.Lock()
 	u.state.Metrics = *metrics
+	u.state.NodePublicInfo.PoolLoad = poolLoad
 	u.rw.Unlock()
 	return nil
 }
@@ -145,11 +197,17 @@ func (u *Updater) UpdateNetworkInfo(
 			}
 		}
 	}
+	// Update pending L1s
+	pendingL1s, err := u.hdb.GetUnforgedL1UserTxsCount()
+	if err != nil {
+		return tracerr.Wrap(err)
+	}
 	u.state.Network.LastSyncBlock = lastSyncBlock.Num
 	u.state.Network.LastEthBlock = lastEthBlock.Num
 	u.state.Network.LastBatch = lastBatch
 	u.state.Network.CurrentSlot = currentSlot
 	u.state.Network.NextForgers = nextForgers
+	u.state.Network.PendingL1Txs = pendingL1s
 	u.rw.Unlock()
 	return nil
 }

api/swagger.yml

@@ -60,9 +60,9 @@ externalDocs:
   url: 'https://hermez.io'
 servers:
   - description: Hosted mock up
-    url: https://apimock.hermez.network
+    url: https://apimock.hermez.network/v1
   - description: Localhost mock Up
-    url: http://localhost:4010
+    url: http://localhost:4010/v1
 tags:
   - name: Coordinator
     description: Endpoints used by the nodes running in coordinator mode. They are used to interact with the network.
@@ -2569,9 +2569,9 @@ components:
       description: List of next coordinators to forge.
       items: 
         $ref: '#/components/schemas/NextForger'
-    NodeConfig:
+    Node:
       type: object
-      description: Configuration of the coordinator node. Note that this is specific for each coordinator.
+      description: Configuration and metrics of the coordinator node. Note that this is specific for each coordinator.
       properties:
         forgeDelay:
           type: number
@@ -2581,9 +2581,14 @@ components:
             forge at the maximum rate. Note that this is a configuration parameter of a node,
             so each coordinator may have a different value.
           example: 193.4
+        poolLoad:
+          type: number
+          description: Number of pending transactions in the pool
+          example: 23201
       additionalProperties: false
       required: 
         - forgeDelay
+        - poolLoad
     State:
       type: object
       description: Gobal variables of the network
@@ -2600,8 +2605,8 @@ components:
           $ref: '#/components/schemas/StateWithdrawDelayer'
         recommendedFee:
           $ref: '#/components/schemas/RecommendedFee'
-        nodeConfig:
+        node:
-          $ref: '#/components/schemas/NodeConfig'
+          $ref: '#/components/schemas/Node'
       additionalProperties: false
       required: 
         - network
@@ -2610,7 +2615,7 @@ components:
         - auction
         - withdrawalDelayer
         - recommendedFee
-        - nodeConfig
+        - node
     StateNetwork:
       type: object
       description: Gobal statistics of the network
@@ -2634,6 +2639,10 @@ components:
             - example: 2334
         nextForgers:
           $ref: '#/components/schemas/NextForgers'
+        pendingL1Transactions:
+          type: number
+          description: Number of pending L1 transactions (added in the smart contract queue but not forged).
+          example: 22
       additionalProperties: false
       required: 
         - lastEthereumBlock
@@ -2809,11 +2818,11 @@ components:
           type: number
           description: Average transactions per second in the last 24 hours.
           example: 302.3
-        totalAccounts:
+        tokenAccounts:
           type: integer
           description: Number of created accounts.
           example: 90473
-        totalBJJs:
+        wallets:
           type: integer
           description: Number of different registered BJJs.
           example: 23067
@@ -2830,8 +2839,8 @@ components:
         - transactionsPerBatch
         - batchFrequency
         - transactionsPerSecond
-        - totalAccounts
+        - tokenAccounts
-        - totalBJJs
+        - wallets
         - avgTransactionFee
         - estimatedTimeToForgeL1
     PendingItems:

api/txshistory_test.go

@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/historydb"
 	"github.com/hermeznetwork/hermez-node/test"

api/txspool.go

@@ -8,7 +8,7 @@ import (
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/gin-gonic/gin"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db/l2db"
 	"github.com/hermeznetwork/tracerr"

cli/node/README.md

@@ -24,6 +24,7 @@ COMMANDS:
    genbjj     Generate a new BabyJubJub key
    wipesql    Wipe the SQL DB (HistoryDB and L2DB) and the StateDBs, leaving the DB in a clean state
    run        Run the hermez-node in the indicated mode
+   serveapi   Serve the API only
    discard    Discard blocks up to a specified block number
    help, h    Shows a list of commands or help for one command
 
@@ -54,6 +55,10 @@ To read the documentation of each configuration parameter, please check the
 with `Coordinator` are only used in coord mode, and don't need to be defined
 when running the coordinator in sync mode
 
+When running the API in standalone mode, the required configuration is a subset
+of the node configuration.  Please, check the `type APIServer` at
+[config/config.go](../../config/config.go) to learn about all the parametes.
+
 ### Notes
 
 - The private key corresponding to the parameter `Coordinator.ForgerAddress` needs to be imported in the ethereum keystore
@@ -68,6 +73,9 @@ when running the coordinator in sync mode
   monitor the size of the folder to avoid running out of space.
 - The node requires a PostgreSQL database.  The parameters of the server and
   database must be set in the `PostgreSQL` section.
+- The node requires a web3 RPC server to work.  The node has only been tested
+  with geth and may not work correctly with other ethereum nodes
+  implementations.
 
 ## Building
 
@@ -107,6 +115,14 @@ Run the node in mode coordinator:
 ./node run --mode coord --cfg cfg.buidler.toml
 ```
 
+Serve the API in standalone mode.  This command allows serving the API just
+with access to the PostgreSQL database that a node is using.  Several instances
+of `serveapi` can be running at the same time with a single PostgreSQL
+database:
+```shell
+./node serveapi --mode coord --cfg cfg.buidler.toml
+```
+
 Import an ethereum private key into the keystore:
 ```shell
 ./node importkey --mode coord --cfg cfg.buidler.toml --privatekey  0x618b35096c477aab18b11a752be619f0023a539bb02dd6c813477a6211916cde

cli/node/cfg.buidler.toml

@@ -99,6 +99,7 @@ BJJ = "0x1b176232f78ba0d388ecc5f4896eca2d3b3d4f272092469f559247297f5c0c13"
 SafetyPeriod = 10
 MaxTxs       = 512
 MinFeeUSD    = 0.0
+MaxFeeUSD    = 50.0
 TTL          = "24h"
 PurgeBatchDelay = 10
 InvalidateBatchDelay = 20
@@ -144,3 +145,11 @@ Coordinator = true
 BatchPath = "/tmp/iden3-test/hermez/batchesdebug"
 LightScrypt = true
 # RollupVerifierIndex = 0
+
+[RecommendedFeePolicy]
+# Strategy used to calculate the recommended fee that the API will expose.
+# Available options:
+# - Static: always return the same value (StaticValue) in USD
+# - AvgLastHour: calculate using the average fee of the forged transactions during the last hour
+PolicyType = "Static"
+StaticValue = 0.99

cli/node/load-sk-example.sh

@@ -1,10 +1,10 @@
 #!/bin/sh
 
 # Non-Boot Coordinator
-go run . --mode coord --cfg cfg.buidler.toml importkey --privatekey 0x30f5fddb34cd4166adb2c6003fa6b18f380fd2341376be42cf1c7937004ac7a3
+go run . importkey --mode coord --cfg cfg.buidler.toml --privatekey 0x30f5fddb34cd4166adb2c6003fa6b18f380fd2341376be42cf1c7937004ac7a3
 
 # Boot Coordinator
-go run . --mode coord --cfg cfg.buidler.toml importkey --privatekey 0xa8a54b2d8197bc0b19bb8a084031be71835580a01e70a45a13babd16c9bc1563
+go run . importkey --mode coord --cfg cfg.buidler.toml --privatekey 0xa8a54b2d8197bc0b19bb8a084031be71835580a01e70a45a13babd16c9bc1563
 
 # FeeAccount
-go run . --mode coord --cfg cfg.buidler.toml importkey --privatekey 0x3a9270c020e169097808da4b02e8d9100be0f8a38cfad3dcfc0b398076381fdd
+go run . importkey --mode coord --cfg cfg.buidler.toml --privatekey 0x3a9270c020e169097808da4b02e8d9100be0f8a38cfad3dcfc0b398076381fdd

cli/node/main.go

@@ -35,18 +35,18 @@ const (
 )
 
 var (
-	// Version represents the program based on the git tag
+	// version represents the program based on the git tag
-	Version = "v0.1.0"
+	version = "v0.1.0"
-	// Build represents the program based on the git commit
+	// commit represents the program based on the git commit
-	Build = "dev"
+	commit = "dev"
-	// Date represents the date of application was built
+	// date represents the date of application was built
-	Date = ""
+	date = ""
 )
 
 func cmdVersion(c *cli.Context) error {
-	fmt.Printf("Version = \"%v\"\n", Version)
+	fmt.Printf("Version = \"%v\"\n", version)
-	fmt.Printf("Build = \"%v\"\n", Build)
+	fmt.Printf("Build = \"%v\"\n", commit)
-	fmt.Printf("Date = \"%v\"\n", Date)
+	fmt.Printf("Date = \"%v\"\n", date)
 	return nil
 }
 
@@ -318,6 +318,7 @@ func cmdDiscard(c *cli.Context) error {
 		cfg.Coordinator.L2DB.SafetyPeriod,
 		cfg.Coordinator.L2DB.MaxTxs,
 		cfg.Coordinator.L2DB.MinFeeUSD,
+		cfg.Coordinator.L2DB.MaxFeeUSD,
 		cfg.Coordinator.L2DB.TTL.Duration,
 		nil,
 	)
@@ -420,7 +421,7 @@ func getConfigAPIServer(c *cli.Context) (*ConfigAPIServer, error) {
 func main() {
 	app := cli.NewApp()
 	app.Name = "hermez-node"
-	app.Version = Version
+	app.Version = version
 	flags := []cli.Flag{
 		&cli.StringFlag{
 			Name:     flagMode,
@@ -484,6 +485,7 @@ func main() {
 			Aliases: []string{},
 			Usage:   "Serve the API only",
 			Action:  cmdServeAPI,
+			Flags:   flags,
 		},
 		{
 			Name:    "discard",

config/config.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/BurntSushi/toml"
 	ethCommon "github.com/ethereum/go-ethereum/common"
+	"github.com/hermeznetwork/hermez-node/api/stateapiupdater"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/priceupdater"
 	"github.com/hermeznetwork/tracerr"
@@ -144,6 +145,10 @@ type Coordinator struct {
 		// order to be accepted into the pool.  Txs with lower than
 		// minimum fee will be rejected at the API level.
 		MinFeeUSD float64
+		// MaxFeeUSD is the maximum fee in USD that a tx must pay in
+		// order to be accepted into the pool.  Txs with greater than
+		// maximum fee will be rejected at the API level.
+		MaxFeeUSD float64 `validate:"required"`
 		// TTL is the Time To Live for L2Txs in the pool.  Once MaxTxs
 		// L2Txs is reached, L2Txs older than TTL will be deleted.
 		TTL Duration `validate:"required"`
@@ -295,7 +300,8 @@ type Node struct {
 	} `validate:"required"`
 	PostgreSQL PostgreSQL `validate:"required"`
 	Web3       struct {
-		// URL is the URL of the web3 ethereum-node RPC server
+		// URL is the URL of the web3 ethereum-node RPC server.  Only
+		// geth is officially supported.
 		URL string `validate:"required"`
 	} `validate:"required"`
 	Synchronizer struct {
@@ -342,8 +348,9 @@ type Node struct {
 		// can wait to stablish a SQL connection
 		SQLConnectionTimeout Duration
 	} `validate:"required"`
-	Debug       NodeDebug   `validate:"required"`
+	RecommendedFeePolicy stateapiupdater.RecommendedFeePolicy `validate:"required"`
-	Coordinator Coordinator `validate:"-"`
+	Debug                NodeDebug                            `validate:"required"`
+	Coordinator          Coordinator                          `validate:"-"`
 }
 
 // APIServer is the api server configuration parameters
@@ -376,6 +383,10 @@ type APIServer struct {
 			// order to be accepted into the pool.  Txs with lower than
 			// minimum fee will be rejected at the API level.
 			MinFeeUSD float64
+			// MaxFeeUSD is the maximum fee in USD that a tx must pay in
+			// order to be accepted into the pool.  Txs with greater than
+			// maximum fee will be rejected at the API level.
+			MaxFeeUSD float64 `validate:"required"`
 		} `validate:"required"`
 	}
 	Debug NodeDebug `validate:"required"`

coordinator/coordinator.go

@@ -1,3 +1,43 @@
+/*
+Package coordinator handles all the logic related to forging batches as a
+coordinator in the hermez network.
+
+The forging of batches is done with a pipeline in order to allow multiple
+batches being forged in parallel.  The maximum number of batches that can be
+forged in parallel is determined by the number of available proof servers.
+
+The Coordinator begins with the pipeline stopped.  The main Coordinator
+goroutine keeps listening for synchronizer events sent by the node package,
+which allow the coordinator to determine if the configured forger address is
+allowed to forge at the current block or not.  When the forger address becomes
+allowed to forge, the pipeline is started, and when it terminates being allowed
+to forge, the pipeline is stopped.
+
+The Pipeline consists of two goroutines.  The first one is in charge of
+preparing a batch internally, which involves making a selection of transactions
+and calculating the ZKInputs for the batch proof, and sending these ZKInputs to
+an idle proof server.  This goroutine will keep preparing batches while there
+are idle proof servers, if the forging policy determines that a batch should be
+forged in the current state.  The second goroutine is in charge of waiting for
+the proof server to finish computing the proof, retreiving it, prepare the
+arguments for the `forgeBatch` Rollup transaction, and sending the result to
+the TxManager.  All the batch information moves between functions and
+goroutines via the BatchInfo struct.
+
+Finally, the TxManager contains a single goroutine that makes forgeBatch
+ethereum transactions for the batches sent by the Pipeline, and keeps them in a
+list to check them periodically.  In the periodic checks, the ethereum
+transaction is checked for successfulness, and it's only forgotten after a
+number of confirmation blocks have passed after being successfully mined.  At
+any point if a transaction failure is detected, the TxManager can signal the
+Coordinator to reset the Pipeline in order to reforge the failed batches.
+
+The Coordinator goroutine acts as a manager.  The synchronizer events (which
+notify about new blocks and associated new state) that it receives are
+broadcasted to the Pipeline and the TxManager.  This allows the Coordinator,
+Pipeline and TxManager to have a copy of the current hermez network state
+required to perform their duties.
+*/
 package coordinator
 
 import (

coordinator/coordinator_test.go

@@ -105,7 +105,7 @@ func newTestModules(t *testing.T) modules {
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	test.WipeDB(db)
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
 	historyDB := historydb.NewHistoryDB(db, db, nil)
 
 	txSelDBPath, err = ioutil.TempDir("", "tmpTxSelDB")

coordinator/purger_test.go

@@ -21,7 +21,7 @@ func newL2DB(t *testing.T) *l2db.L2DB {
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	test.WipeDB(db)
-	return l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	return l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
 }
 
 func newStateDB(t *testing.T) *statedb.LocalStateDB {

db/historydb/apiqueries.go

@@ -8,7 +8,7 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/db"
 	"github.com/hermeznetwork/tracerr"
@@ -1083,12 +1083,8 @@ func (hdb *HistoryDB) GetNextForgersInternalAPI(auctionVars *common.AuctionVaria
 }
 
 // GetMetricsInternalAPI returns the MetricsAPI
-func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (*MetricsAPI, error) {
+func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (metrics *MetricsAPI, poolLoad int64, err error) {
-	var metrics MetricsAPI
+	metrics = &MetricsAPI{}
-	// Get the first and last batch of the last 24h and their timestamps
-	// if u.state.Network.LastBatch == nil {
-	// 	return &metrics, nil
-	// }
 	type period struct {
 		FromBatchNum  common.BatchNum `meddler:"from_batch_num"`
 		FromTimestamp time.Time       `meddler:"from_timestamp"`
@@ -1106,7 +1102,7 @@ func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (*Metr
 			FROM batch INNER JOIN block ON batch.eth_block_num = block.eth_block_num
 			WHERE block.timestamp >= NOW() - INTERVAL '24 HOURS';`,
 	); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	// Get the amount of txs of that period
 	row := hdb.dbRead.QueryRow(
@@ -1115,7 +1111,7 @@ func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (*Metr
 	)
 	var nTxs int
 	if err := row.Scan(&nTxs); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	// Set txs/s
 	seconds := p.ToTimestamp.Sub(p.FromTimestamp).Seconds()
@@ -1141,7 +1137,7 @@ func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (*Metr
 	)
 	var totalFee float64
 	if err := row.Scan(&totalFee); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	// Set batch frequency
 	metrics.BatchFrequency = seconds / float64(nBatches)
@@ -1152,7 +1148,7 @@ func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (*Metr
 	)
 	var nL2Txs int
 	if err := row.Scan(&nL2Txs); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	if nL2Txs > 0 {
 		metrics.AvgTransactionFee = totalFee / float64(nL2Txs)
@@ -1161,18 +1157,18 @@ func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (*Metr
 	}
 	// Get and set amount of registered accounts
 	type registeredAccounts struct {
-		TotalIdx int64 `meddler:"total_idx"`
+		TokenAccounts int64 `meddler:"token_accounts"`
-		TotalBJJ int64 `meddler:"total_bjj"`
+		Wallets       int64 `meddler:"wallets"`
 	}
 	ra := &registeredAccounts{}
 	if err := meddler.QueryRow(
 		hdb.dbRead, ra,
-		`SELECT COUNT(*) AS total_bjj, COUNT(DISTINCT(bjj)) AS total_idx FROM account;`,
+		`SELECT COUNT(*) AS token_accounts, COUNT(DISTINCT(bjj)) AS wallets FROM account;`,
 	); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
-	metrics.TotalAccounts = ra.TotalIdx
+	metrics.TokenAccounts = ra.TokenAccounts
-	metrics.TotalBJJs = ra.TotalBJJ
+	metrics.Wallets = ra.Wallets
 	// Get and set estimated time to forge L1 tx
 	row = hdb.dbRead.QueryRow(
 		`SELECT COALESCE (AVG(EXTRACT(EPOCH FROM (forged.timestamp - added.timestamp))), 0) FROM tx
@@ -1184,10 +1180,18 @@ func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (*Metr
 	)
 	var timeToForgeL1 float64
 	if err := row.Scan(&timeToForgeL1); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	metrics.EstimatedTimeToForgeL1 = timeToForgeL1
-	return &metrics, nil
+	// Get amount of txs in the pool
+	row = hdb.dbRead.QueryRow(
+		`SELECT COUNT(*) FROM tx_pool WHERE state = $1 AND NOT external_delete;`,
+		common.PoolL2TxStatePending,
+	)
+	if err := row.Scan(&poolLoad); err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	return metrics, poolLoad, nil
 }
 
 // GetStateAPI returns the StateAPI

db/historydb/historydb.go

@@ -1181,7 +1181,7 @@ const (
 )
 
 // GetRecommendedFee returns the RecommendedFee information
-func (hdb *HistoryDB) GetRecommendedFee(minFeeUSD float64) (*common.RecommendedFee, error) {
+func (hdb *HistoryDB) GetRecommendedFee(minFeeUSD, maxFeeUSD float64) (*common.RecommendedFee, error) {
 	var recommendedFee common.RecommendedFee
 	// Get total txs and the batch of the first selected tx of the last hour
 	type totalTxsSinceBatchNum struct {
@@ -1217,11 +1217,11 @@ func (hdb *HistoryDB) GetRecommendedFee(minFeeUSD float64) (*common.RecommendedF
 	} else {
 		avgTransactionFee = 0
 	}
-	recommendedFee.ExistingAccount =
+	recommendedFee.ExistingAccount = math.Min(maxFeeUSD,
-		math.Max(avgTransactionFee, minFeeUSD)
+		math.Max(avgTransactionFee, minFeeUSD))
-	recommendedFee.CreatesAccount =
+	recommendedFee.CreatesAccount = math.Min(maxFeeUSD,
-		math.Max(CreateAccountExtraFeePercentage*avgTransactionFee, minFeeUSD)
+		math.Max(CreateAccountExtraFeePercentage*avgTransactionFee, minFeeUSD))
-	recommendedFee.CreatesAccountInternal =
+	recommendedFee.CreatesAccountInternal = math.Min(maxFeeUSD,
-		math.Max(CreateAccountInternalExtraFeePercentage*avgTransactionFee, minFeeUSD)
+		math.Max(CreateAccountInternalExtraFeePercentage*avgTransactionFee, minFeeUSD))
 	return &recommendedFee, nil
 }

db/historydb/historydb_test.go

@@ -11,7 +11,7 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	dbUtils "github.com/hermeznetwork/hermez-node/db"
 	"github.com/hermeznetwork/hermez-node/log"
@@ -1177,7 +1177,7 @@ func TestGetMetricsAPI(t *testing.T) {
 		assert.NoError(t, err)
 	}
 
-	res, err := historyDB.GetMetricsInternalAPI(common.BatchNum(numBatches))
+	res, _, err := historyDB.GetMetricsInternalAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
 	assert.Equal(t, float64(numTx)/float64(numBatches), res.TransactionsPerBatch)
@@ -1186,8 +1186,8 @@ func TestGetMetricsAPI(t *testing.T) {
 	// There is a -2 as time for first and last batch is not taken into account
 	assert.InEpsilon(t, float64(frequency)*float64(numBatches-2)/float64(numBatches), res.BatchFrequency, 0.01)
 	assert.InEpsilon(t, float64(numTx)/float64(frequency*blockNum-frequency), res.TransactionsPerSecond, 0.01)
-	assert.Equal(t, int64(3), res.TotalAccounts)
+	assert.Equal(t, int64(3), res.TokenAccounts)
-	assert.Equal(t, int64(3), res.TotalBJJs)
+	assert.Equal(t, int64(3), res.Wallets)
 	// Til does not set fees
 	assert.Equal(t, float64(0), res.AvgTransactionFee)
 }
@@ -1255,22 +1255,22 @@ func TestGetMetricsAPIMoreThan24Hours(t *testing.T) {
 		assert.NoError(t, err)
 	}
 
-	res, err := historyDBWithACC.GetMetricsInternalAPI(common.BatchNum(numBatches))
+	res, _, err := historyDBWithACC.GetMetricsInternalAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
 	assert.InEpsilon(t, 1.0, res.TransactionsPerBatch, 0.1)
 
 	assert.InEpsilon(t, res.BatchFrequency, float64(blockTime/time.Second), 0.1)
 	assert.InEpsilon(t, 1.0/float64(blockTime/time.Second), res.TransactionsPerSecond, 0.1)
-	assert.Equal(t, int64(3), res.TotalAccounts)
+	assert.Equal(t, int64(3), res.TokenAccounts)
-	assert.Equal(t, int64(3), res.TotalBJJs)
+	assert.Equal(t, int64(3), res.Wallets)
 	// Til does not set fees
 	assert.Equal(t, float64(0), res.AvgTransactionFee)
 }
 
 func TestGetMetricsAPIEmpty(t *testing.T) {
 	test.WipeDB(historyDB.DB())
-	_, err := historyDBWithACC.GetMetricsInternalAPI(0)
+	_, _, err := historyDBWithACC.GetMetricsInternalAPI(0)
 	assert.NoError(t, err)
 }
 
@@ -1485,7 +1485,7 @@ func TestNodeInfo(t *testing.T) {
 	addr := ethCommon.HexToAddress("0x1234")
 	hash := ethCommon.HexToHash("0x5678")
 	stateAPI := &StateAPI{
-		NodePublicConfig: NodePublicConfig{
+		NodePublicInfo: NodePublicInfo{
 			ForgeDelay: 3.1,
 		},
 		Network: NetworkAPI{
@@ -1544,7 +1544,7 @@ func TestNodeInfo(t *testing.T) {
 		},
 		Metrics: MetricsAPI{
 			TransactionsPerBatch: 1.1,
-			TotalAccounts:        42,
+			TokenAccounts:        42,
 		},
 		Rollup:            *NewRollupVariablesAPI(clientSetup.RollupVariables),
 		Auction:           *NewAuctionVariablesAPI(clientSetup.AuctionVariables),

db/historydb/nodeinfo.go

@@ -4,7 +4,7 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/tracerr"
 	"github.com/russross/meddler"
@@ -32,18 +32,20 @@ type NetworkAPI struct {
 	LastBatch     *BatchAPI       `json:"lastBatch"`
 	CurrentSlot   int64           `json:"currentSlot"`
 	NextForgers   []NextForgerAPI `json:"nextForgers"`
+	PendingL1Txs  int             `json:"pendingL1Transactions"`
 }
 
-// NodePublicConfig is the configuration of the node that is exposed via API
+// NodePublicInfo is the configuration and metrics of the node that is exposed via API
-type NodePublicConfig struct {
+type NodePublicInfo struct {
 	// ForgeDelay in seconds
 	ForgeDelay float64 `json:"forgeDelay"`
+	// PoolLoad amount of transactions in the pool
+	PoolLoad int64 `json:"poolLoad"`
 }
 
 // StateAPI is an object representing the node and network state exposed via the API
 type StateAPI struct {
-	// NodePublicConfig is the configuration of the node that is exposed via API
+	NodePublicInfo    NodePublicInfo           `json:"node"`
-	NodePublicConfig  NodePublicConfig         `json:"nodeConfig"`
 	Network           NetworkAPI               `json:"network"`
 	Metrics           MetricsAPI               `json:"metrics"`
 	Rollup            RollupVariablesAPI       `json:"rollup"`
@@ -63,6 +65,7 @@ type Constants struct {
 type NodeConfig struct {
 	MaxPoolTxs uint32
 	MinFeeUSD  float64
+	MaxFeeUSD  float64
 	ForgeDelay float64
 }
 

db/historydb/views.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 	"github.com/iden3/go-merkletree"
@@ -314,8 +314,8 @@ type MetricsAPI struct {
 	TransactionsPerBatch   float64 `json:"transactionsPerBatch"`
 	BatchFrequency         float64 `json:"batchFrequency"`
 	TransactionsPerSecond  float64 `json:"transactionsPerSecond"`
-	TotalAccounts          int64   `json:"totalAccounts" meddler:"total_accounts"`
+	TokenAccounts          int64   `json:"tokenAccounts"`
-	TotalBJJs              int64   `json:"totalBJJs" meddler:"total_bjjs"`
+	Wallets                int64   `json:"wallets"`
 	AvgTransactionFee      float64 `json:"avgTransactionFee"`
 	EstimatedTimeToForgeL1 float64 `json:"estimatedTimeToForgeL1" meddler:"estimated_time_to_forge_l1"`
 }

db/l2db/apiqueries.go

@@ -62,6 +62,10 @@ func (l2db *L2DB) AddTxAPI(tx *PoolL2TxWrite) error {
 		return tracerr.Wrap(fmt.Errorf("tx.feeUSD (%v) < minFeeUSD (%v)",
 			feeUSD, l2db.minFeeUSD))
 	}
+	if feeUSD > l2db.maxFeeUSD {
+		return tracerr.Wrap(fmt.Errorf("tx.feeUSD (%v) > maxFeeUSD (%v)",
+			feeUSD, l2db.maxFeeUSD))
+	}
 
 	// Prepare insert SQL query argument parameters
 	namesPart, err := meddler.Default.ColumnsQuoted(tx, false)

db/l2db/l2db.go

@@ -27,6 +27,7 @@ type L2DB struct {
 	ttl          time.Duration
 	maxTxs       uint32 // limit of txs that are accepted in the pool
 	minFeeUSD    float64
+	maxFeeUSD    float64
 	apiConnCon   *db.APIConnectionController
 }
 
@@ -38,6 +39,7 @@ func NewL2DB(
 	safetyPeriod common.BatchNum,
 	maxTxs uint32,
 	minFeeUSD float64,
+	maxFeeUSD float64,
 	TTL time.Duration,
 	apiConnCon *db.APIConnectionController,
 ) *L2DB {
@@ -48,6 +50,7 @@ func NewL2DB(
 		ttl:          TTL,
 		maxTxs:       maxTxs,
 		minFeeUSD:    minFeeUSD,
+		maxFeeUSD:    maxFeeUSD,
 		apiConnCon:   apiConnCon,
 	}
 }

db/l2db/l2db_test.go

@@ -37,9 +37,9 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
-	l2DB = NewL2DB(db, db, 10, 1000, 0.0, 24*time.Hour, nil)
+	l2DB = NewL2DB(db, db, 10, 1000, 0.0, 1000.0, 24*time.Hour, nil)
 	apiConnCon := dbUtils.NewAPIConnectionController(1, time.Second)
-	l2DBWithACC = NewL2DB(db, db, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
+	l2DBWithACC = NewL2DB(db, db, 10, 1000, 0.0, 1000.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB())
 	historyDB = historydb.NewHistoryDB(db, db, nil)
 	// Run tests

db/l2db/views.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
-	"github.com/hermeznetwork/hermez-node/apitypes"
+	"github.com/hermeznetwork/hermez-node/api/apitypes"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 )

db/migrations/0001.sql

@@ -677,12 +677,22 @@ CREATE TABLE node_info (
 );
 INSERT INTO node_info(item_id) VALUES (1); -- Always have a single row that we will update
 
+CREATE VIEW account_state AS SELECT DISTINCT idx,
+first_value(nonce) OVER w AS nonce,
+first_value(balance) OVER w AS balance,
+first_value(eth_block_num) OVER w AS eth_block_num,
+first_value(batch_num) OVER w AS batch_num
+FROM account_update
+window w AS (partition by idx ORDER BY item_id desc);
+
 -- +migrate Down
 -- triggers
 DROP TRIGGER IF EXISTS trigger_token_usd_update ON token;
 DROP TRIGGER IF EXISTS trigger_set_tx ON tx;
 DROP TRIGGER IF EXISTS trigger_forge_l1_txs ON batch;
 DROP TRIGGER IF EXISTS trigger_set_pool_tx ON tx_pool;
+-- drop views IF EXISTS
+DROP VIEW IF EXISTS account_state;
 -- functions
 DROP FUNCTION IF EXISTS hez_idx;
 DROP FUNCTION IF EXISTS set_token_usd_update;

eth/auction.go

@@ -260,7 +260,7 @@ type AuctionInterface interface {
 
 	AuctionConstants() (*common.AuctionConstants, error)
 	AuctionEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*AuctionEvents, error)
-	AuctionEventInit() (*AuctionEventInitialize, int64, error)
+	AuctionEventInit(genesisBlockNum int64) (*AuctionEventInitialize, int64, error)
 }
 
 //
@@ -809,12 +809,14 @@ var (
 )
 
 // AuctionEventInit returns the initialize event with its corresponding block number
-func (c *AuctionClient) AuctionEventInit() (*AuctionEventInitialize, int64, error) {
+func (c *AuctionClient) AuctionEventInit(genesisBlockNum int64) (*AuctionEventInitialize, int64, error) {
 	query := ethereum.FilterQuery{
 		Addresses: []ethCommon.Address{
 			c.address,
 		},
-		Topics: [][]ethCommon.Hash{{logAuctionInitialize}},
+		FromBlock: big.NewInt(max(0, genesisBlockNum-blocksPerDay)),
+		ToBlock:   big.NewInt(genesisBlockNum),
+		Topics:    [][]ethCommon.Hash{{logAuctionInitialize}},
 	}
 	logs, err := c.client.client.FilterLogs(context.Background(), query)
 	if err != nil {

eth/auction_test.go

@@ -28,7 +28,7 @@ func TestAuctionGetCurrentSlotNumber(t *testing.T) {
 }
 
 func TestAuctionEventInit(t *testing.T) {
-	auctionInit, blockNum, err := auctionClientTest.AuctionEventInit()
+	auctionInit, blockNum, err := auctionClientTest.AuctionEventInit(genesisBlock)
 	require.NoError(t, err)
 	assert.Equal(t, int64(18), blockNum)
 	assert.Equal(t, donationAddressConst, auctionInit.DonationAddress)

eth/client.go

@@ -12,6 +12,17 @@ import (
 
 var errTODO = fmt.Errorf("TODO: Not implemented yet")
 
+const (
+	blocksPerDay = (3600 * 24) / 15
+)
+
+func max(x, y int64) int64 {
+	if x > y {
+		return x
+	}
+	return y
+}
+
 // ClientInterface is the eth Client interface used by hermez-node modules to
 // interact with Ethereum Blockchain and smart contracts.
 type ClientInterface interface {

eth/rollup.go

@@ -273,7 +273,7 @@ type RollupInterface interface {
 	RollupConstants() (*common.RollupConstants, error)
 	RollupEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*RollupEvents, error)
 	RollupForgeBatchArgs(ethCommon.Hash, uint16) (*RollupForgeBatchArgs, *ethCommon.Address, error)
-	RollupEventInit() (*RollupEventInitialize, int64, error)
+	RollupEventInit(genesisBlockNum int64) (*RollupEventInitialize, int64, error)
 }
 
 //
@@ -749,12 +749,14 @@ var (
 )
 
 // RollupEventInit returns the initialize event with its corresponding block number
-func (c *RollupClient) RollupEventInit() (*RollupEventInitialize, int64, error) {
+func (c *RollupClient) RollupEventInit(genesisBlockNum int64) (*RollupEventInitialize, int64, error) {
 	query := ethereum.FilterQuery{
 		Addresses: []ethCommon.Address{
 			c.address,
 		},
-		Topics: [][]ethCommon.Hash{{logHermezInitialize}},
+		FromBlock: big.NewInt(max(0, genesisBlockNum-blocksPerDay)),
+		ToBlock:   big.NewInt(genesisBlockNum),
+		Topics:    [][]ethCommon.Hash{{logHermezInitialize}},
 	}
 	logs, err := c.client.client.FilterLogs(context.Background(), query)
 	if err != nil {

eth/rollup_test.go

@@ -56,7 +56,7 @@ func genKeysBjj(i int64) *keys {
 }
 
 func TestRollupEventInit(t *testing.T) {
-	rollupInit, blockNum, err := rollupClient.RollupEventInit()
+	rollupInit, blockNum, err := rollupClient.RollupEventInit(genesisBlock)
 	require.NoError(t, err)
 	assert.Equal(t, int64(19), blockNum)
 	assert.Equal(t, uint8(10), rollupInit.ForgeL1L2BatchTimeout)

eth/wdelayer.go

@@ -137,7 +137,7 @@ type WDelayerInterface interface {
 
 	WDelayerEventsByBlock(blockNum int64, blockHash *ethCommon.Hash) (*WDelayerEvents, error)
 	WDelayerConstants() (*common.WDelayerConstants, error)
-	WDelayerEventInit() (*WDelayerEventInitialize, int64, error)
+	WDelayerEventInit(genesisBlockNum int64) (*WDelayerEventInitialize, int64, error)
 }
 
 //
@@ -415,12 +415,14 @@ var (
 )
 
 // WDelayerEventInit returns the initialize event with its corresponding block number
-func (c *WDelayerClient) WDelayerEventInit() (*WDelayerEventInitialize, int64, error) {
+func (c *WDelayerClient) WDelayerEventInit(genesisBlockNum int64) (*WDelayerEventInitialize, int64, error) {
 	query := ethereum.FilterQuery{
 		Addresses: []ethCommon.Address{
 			c.address,
 		},
-		Topics: [][]ethCommon.Hash{{logWDelayerInitialize}},
+		FromBlock: big.NewInt(max(0, genesisBlockNum-blocksPerDay)),
+		ToBlock:   big.NewInt(genesisBlockNum),
+		Topics:    [][]ethCommon.Hash{{logWDelayerInitialize}},
 	}
 	logs, err := c.client.client.FilterLogs(context.Background(), query)
 	if err != nil {

eth/wdelayer_test.go

@@ -18,7 +18,7 @@ var maxEmergencyModeTime = time.Hour * 24 * 7 * 26
 var maxWithdrawalDelay = time.Hour * 24 * 7 * 2
 
 func TestWDelayerInit(t *testing.T) {
-	wDelayerInit, blockNum, err := wdelayerClientTest.WDelayerEventInit()
+	wDelayerInit, blockNum, err := wdelayerClientTest.WDelayerEventInit(genesisBlock)
 	require.NoError(t, err)
 	assert.Equal(t, int64(16), blockNum)
 	assert.Equal(t, uint64(initWithdrawalDelay), wDelayerInit.InitialWithdrawalDelay)

node/node.go

@@ -1,3 +1,18 @@
+/*
+Package node does the initialization of all the required objects to either run
+as a synchronizer or as a coordinator.
+
+The Node contains several goroutines that run in the background or that
+periodically perform tasks.  One of this goroutines periodically calls the
+`Synchronizer.Sync` function, allowing the synchronization of one block at a
+time.  After every call to `Synchronizer.Sync`, the Node sends a message to the
+Coordinator to notify it about the new synced block (and associated state) or
+reorg (and resetted state) in case one happens.
+
+Other goroutines perform tasks such as: updating the token prices, update
+metrics stored in the historyDB, update recommended fee stored in the
+historyDB, run the http API server, run the debug http API server, etc.
+*/
 package node
 
 import (
@@ -15,6 +30,7 @@ import (
 	"github.com/gin-contrib/cors"
 	"github.com/gin-gonic/gin"
 	"github.com/hermeznetwork/hermez-node/api"
+	"github.com/hermeznetwork/hermez-node/api/stateapiupdater"
 	"github.com/hermeznetwork/hermez-node/batchbuilder"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/config"
@@ -27,7 +43,6 @@ import (
 	"github.com/hermeznetwork/hermez-node/log"
 	"github.com/hermeznetwork/hermez-node/priceupdater"
 	"github.com/hermeznetwork/hermez-node/prover"
-	"github.com/hermeznetwork/hermez-node/stateapiupdater"
 	"github.com/hermeznetwork/hermez-node/synchronizer"
 	"github.com/hermeznetwork/hermez-node/test/debugapi"
 	"github.com/hermeznetwork/hermez-node/txprocessor"
@@ -230,6 +245,7 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 			cfg.Coordinator.L2DB.SafetyPeriod,
 			cfg.Coordinator.L2DB.MaxTxs,
 			cfg.Coordinator.L2DB.MinFeeUSD,
+			cfg.Coordinator.L2DB.MaxFeeUSD,
 			cfg.Coordinator.L2DB.TTL.Duration,
 			apiConnCon,
 		)
@@ -253,6 +269,7 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 	hdbNodeCfg := historydb.NodeConfig{
 		MaxPoolTxs: cfg.Coordinator.L2DB.MaxTxs,
 		MinFeeUSD:  cfg.Coordinator.L2DB.MinFeeUSD,
+		MaxFeeUSD:  cfg.Coordinator.L2DB.MaxFeeUSD,
 		ForgeDelay: cfg.Coordinator.ForgeDelay.Duration.Seconds(),
 	}
 	if err := historyDB.SetNodeConfig(&hdbNodeCfg); err != nil {
@@ -271,7 +288,16 @@ func NewNode(mode Mode, cfg *config.Node) (*Node, error) {
 		return nil, tracerr.Wrap(err)
 	}
 
-	stateAPIUpdater := stateapiupdater.NewUpdater(historyDB, &hdbNodeCfg, initSCVars, &hdbConsts)
+	stateAPIUpdater, err := stateapiupdater.NewUpdater(
+		historyDB,
+		&hdbNodeCfg,
+		initSCVars,
+		&hdbConsts,
+		&cfg.RecommendedFeePolicy,
+	)
+	if err != nil {
+		return nil, tracerr.Wrap(err)
+	}
 
 	var coord *coordinator.Coordinator
 	if mode == ModeCoordinator {
@@ -522,6 +548,7 @@ func NewAPIServer(mode Mode, cfg *config.APIServer) (*APIServer, error) {
 			0,
 			cfg.Coordinator.L2DB.MaxTxs,
 			cfg.Coordinator.L2DB.MinFeeUSD,
+			cfg.Coordinator.L2DB.MaxFeeUSD,
 			0,
 			apiConnCon,
 		)

synchronizer/synchronizer.go

@@ -1,3 +1,35 @@
+/*
+Package synchronizer synchronizes the hermez network state by querying events
+emitted by the three smart contracts: `Hermez.sol` (referred as Rollup here),
+`HermezAuctionProtocol.sol` (referred as Auction here) and
+`WithdrawalDelayer.sol` (referred as WDelayer here).
+
+The main entry point for synchronization is the `Sync` function, which at most
+will synchronize one ethereum block, and all the hermez events that happened in
+that block.  During a `Sync` call, a reorg can be detected; in such case, uncle
+blocks will be discarded, and only in a future `Sync` call correct blocks will
+be synced.
+
+The synchronization of the events in each smart contracts are done
+in the methods `rollupSync`, `auctionSync` and `wdelayerSync`, which in turn
+use the interface code to read each smart contract state and events found in
+"github.com/hermeznetwork/hermez-node/eth".  After these three methods are
+called, an object of type `common.BlockData` is built containing all the
+updates and events that happened in that block, and it is inserted in the
+HistoryDB in a single SQL transaction.
+
+`rollupSync` is the method that synchronizes batches sent via the `forgeBatch`
+transaction in `Hermez.sol`.  In `rollupSync`, for every batch,  the accounts
+state is updated in the StateDB by processing all transactions that have been
+forged in that batch.
+
+The consistency of the stored data is guaranteed by the HistoryDB: All the
+block information is inserted in a single SQL transaction at the end of the
+`Sync` method, once the StateDB has been updated.  And every time the
+Synchronizer starts, it continues from the last block in the HistoryDB.  The
+StateDB stores updates organized by checkpoints for every batch, and each batch
+is only accessed if it appears in the HistoryDB.
+*/
 package synchronizer
 
 import (
@@ -704,15 +736,15 @@ func (s *Synchronizer) reorg(uncleBlock *common.Block) (int64, error) {
 
 func getInitialVariables(ethClient eth.ClientInterface,
 	consts *common.SCConsts) (*common.SCVariables, *StartBlockNums, error) {
-	rollupInit, rollupInitBlock, err := ethClient.RollupEventInit()
+	rollupInit, rollupInitBlock, err := ethClient.RollupEventInit(consts.Auction.GenesisBlockNum)
 	if err != nil {
 		return nil, nil, tracerr.Wrap(fmt.Errorf("RollupEventInit: %w", err))
 	}
-	auctionInit, auctionInitBlock, err := ethClient.AuctionEventInit()
+	auctionInit, auctionInitBlock, err := ethClient.AuctionEventInit(consts.Auction.GenesisBlockNum)
 	if err != nil {
 		return nil, nil, tracerr.Wrap(fmt.Errorf("AuctionEventInit: %w", err))
 	}
-	wDelayerInit, wDelayerInitBlock, err := ethClient.WDelayerEventInit()
+	wDelayerInit, wDelayerInitBlock, err := ethClient.WDelayerEventInit(consts.Auction.GenesisBlockNum)
 	if err != nil {
 		return nil, nil, tracerr.Wrap(fmt.Errorf("WDelayerEventInit: %w", err))
 	}

synchronizer/synchronizer_test.go

@@ -323,7 +323,7 @@ func newTestModules(t *testing.T) (*statedb.StateDB, *historydb.HistoryDB, *l2db
 	test.WipeDB(historyDB.DB())
 
 	// Init L2 DB
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
 
 	return stateDB, historyDB, l2DB
 }

test/ethclient.go

@@ -1152,7 +1152,7 @@ func (c *Client) RollupEventsByBlock(blockNum int64,
 }
 
 // RollupEventInit returns the initialize event with its corresponding block number
-func (c *Client) RollupEventInit() (*eth.RollupEventInitialize, int64, error) {
+func (c *Client) RollupEventInit(genesisBlockNum int64) (*eth.RollupEventInitialize, int64, error) {
 	vars := c.blocks[0].Rollup.Vars
 	return &eth.RollupEventInitialize{
 		ForgeL1L2BatchTimeout: uint8(vars.ForgeL1L2BatchTimeout),
@@ -1628,7 +1628,7 @@ func (c *Client) AuctionEventsByBlock(blockNum int64,
 }
 
 // AuctionEventInit returns the initialize event with its corresponding block number
-func (c *Client) AuctionEventInit() (*eth.AuctionEventInitialize, int64, error) {
+func (c *Client) AuctionEventInit(genesisBlockNum int64) (*eth.AuctionEventInitialize, int64, error) {
 	vars := c.blocks[0].Auction.Vars
 	return &eth.AuctionEventInitialize{
 		DonationAddress:        vars.DonationAddress,
@@ -1863,7 +1863,7 @@ func (c *Client) WDelayerConstants() (*common.WDelayerConstants, error) {
 }
 
 // WDelayerEventInit returns the initialize event with its corresponding block number
-func (c *Client) WDelayerEventInit() (*eth.WDelayerEventInitialize, int64, error) {
+func (c *Client) WDelayerEventInit(genesisBlockNum int64) (*eth.WDelayerEventInitialize, int64, error) {
 	vars := c.blocks[0].WDelayer.Vars
 	return &eth.WDelayerEventInitialize{
 		InitialWithdrawalDelay:         vars.WithdrawalDelay,

test/zkproof/flows_test.go

@@ -77,7 +77,7 @@ func initTxSelector(t *testing.T, chainID uint16, hermezContractAddr ethCommon.A
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpSyncDB")
 	require.NoError(t, err)

txselector/txselector.go

@@ -164,30 +164,33 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 	// implementation that can be used ASAP.
 
 	// Steps of this method:
-	// - getPendingTxs
+	// - ProcessL1Txs (User txs)
-	// - ProcessL1Txs
+	// - getPendingTxs (forgable directly with current state & not forgable
-	// - getProfitable (sort by fee & nonce)
+	// yet)
-	// - loop over l2Txs
+	// - split between l2TxsForgable & l2TxsNonForgable, where:
-	//         - Fill tx.TokenID tx.Nonce
+	// 	- l2TxsForgable are the txs that are directly forgable with the
-	//         - Check enough Balance on sender
+	// 	current state
-	//         - Check Nonce
+	// 	- l2TxsNonForgable are the txs that are not directly forgable
-	//         - Create CoordAccount L1CoordTx for TokenID if needed
+	// 	with the current state, but that may be forgable once the
-	//                 - & ProcessL1Tx of L1CoordTx
+	// 	l2TxsForgable ones are processed
-	//         - Check validity of receiver Account for ToEthAddr / ToBJJ
+	// - for l2TxsForgable, and if needed, for l2TxsNonForgable:
-	//         - Create UserAccount L1CoordTx if needed (and possible)
+	// 	- sort by Fee & Nonce
-	//         - If everything is fine, store l2Tx to validTxs & update NoncesMap
+	// 	- loop over l2Txs (txsel.processL2Txs)
+	// 	        - Fill tx.TokenID tx.Nonce
+	// 	        - Check enough Balance on sender
+	// 	        - Check Nonce
+	// 	        - Create CoordAccount L1CoordTx for TokenID if needed
+	// 	                - & ProcessL1Tx of L1CoordTx
+	// 	        - Check validity of receiver Account for ToEthAddr / ToBJJ
+	// 	        - Create UserAccount L1CoordTx if needed (and possible)
+	// 	        - If everything is fine, store l2Tx to validTxs & update NoncesMap
 	// - Prepare coordIdxsMap & AccumulatedFees
 	// - Distribute AccumulatedFees to CoordIdxs
 	// - MakeCheckpoint
 
-	// get pending l2-tx from tx-pool
-	l2TxsRaw, err := txsel.l2db.GetPendingTxs()
-	if err != nil {
-		return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
-	}
-
 	txselStateDB := txsel.localAccountsDB.StateDB
 	tp := txprocessor.NewTxProcessor(txselStateDB, selectionConfig)
+	tp.AccumulatedFees = make(map[common.Idx]*big.Int)
 
 	// Process L1UserTxs
 	for i := 0; i < len(l1UserTxs); i++ {
@@ -198,21 +201,139 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 		}
 	}
 
-	var l1CoordinatorTxs []common.L1Tx
+	l2TxsFromDB, err := txsel.l2db.GetPendingTxs()
-	positionL1 := len(l1UserTxs)
+	if err != nil {
-	var accAuths [][]byte
+		return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+	}
+	l2TxsForgable, l2TxsNonForgable := splitL2ForgableAndNonForgable(tp, l2TxsFromDB)
 
-	// Sort l2TxsRaw (cropping at MaxTx at this point).
+	// in case that length of l2TxsForgable is 0, no need to continue, there
-	// discardedL2Txs contains an array of the L2Txs that have not been
+	// is no L2Txs to forge at all
-	// selected in this Batch.
+	if len(l2TxsForgable) == 0 {
-	l2Txs, discardedL2Txs := txsel.getL2Profitable(l2TxsRaw, selectionConfig.MaxTx-uint32(len(l1UserTxs)))
+		var discardedL2Txs []common.PoolL2Tx
-	for i := range discardedL2Txs {
+		for i := 0; i < len(l2TxsNonForgable); i++ {
-		discardedL2Txs[i].Info =
+			l2TxsNonForgable[i].Info =
-			"Tx not selected due to low absolute fee (does not fit inside the profitable set)"
+				"Tx not selected due impossibility to be forged with the current state"
+			discardedL2Txs = append(discardedL2Txs, l2TxsNonForgable[i])
+		}
+		err = tp.StateDB().MakeCheckpoint()
+		if err != nil {
+			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+		}
+
+		metricSelectedL1UserTxs.Set(float64(len(l1UserTxs)))
+		metricSelectedL1CoordinatorTxs.Set(0)
+		metricSelectedL2Txs.Set(0)
+		metricDiscardedL2Txs.Set(float64(len(discardedL2Txs)))
+		return nil, nil, l1UserTxs, nil, nil, discardedL2Txs, nil
 	}
 
-	var validTxs []common.PoolL2Tx
+	var accAuths [][]byte
-	tp.AccumulatedFees = make(map[common.Idx]*big.Int)
+	var l1CoordinatorTxs []common.L1Tx
+	var validTxs, discardedL2Txs []common.PoolL2Tx
+	l2TxsForgable = sortL2Txs(l2TxsForgable)
+	accAuths, l1CoordinatorTxs, validTxs, discardedL2Txs, err =
+		txsel.processL2Txs(tp, selectionConfig, len(l1UserTxs),
+			l2TxsForgable, validTxs, discardedL2Txs)
+	if err != nil {
+		return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+	}
+
+	// if there is space for more txs get also the NonForgable txs, that may
+	// be unblocked once the Forgable ones are processed
+	if len(validTxs) < int(selectionConfig.MaxTx)-(len(l1UserTxs)+len(l1CoordinatorTxs)) {
+		l2TxsNonForgable = sortL2Txs(l2TxsNonForgable)
+		var accAuths2 [][]byte
+		var l1CoordinatorTxs2 []common.L1Tx
+		accAuths2, l1CoordinatorTxs2, validTxs, discardedL2Txs, err =
+			txsel.processL2Txs(tp, selectionConfig,
+				len(l1UserTxs)+len(l1CoordinatorTxs), l2TxsNonForgable,
+				validTxs, discardedL2Txs)
+		if err != nil {
+			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+		}
+
+		accAuths = append(accAuths, accAuths2...)
+		l1CoordinatorTxs = append(l1CoordinatorTxs, l1CoordinatorTxs2...)
+	} else {
+		// if there is no space for NonForgable txs, put them at the
+		// discardedL2Txs array
+		for i := 0; i < len(l2TxsNonForgable); i++ {
+			l2TxsNonForgable[i].Info =
+				"Tx not selected due not available slots for L2Txs"
+			discardedL2Txs = append(discardedL2Txs, l2TxsNonForgable[i])
+		}
+	}
+
+	// get CoordIdxsMap for the TokenIDs
+	coordIdxsMap := make(map[common.TokenID]common.Idx)
+	for i := 0; i < len(validTxs); i++ {
+		// get TokenID from tx.Sender
+		accSender, err := tp.StateDB().GetAccount(validTxs[i].FromIdx)
+		if err != nil {
+			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+		}
+		tokenID := accSender.TokenID
+
+		coordIdx, err := txsel.getCoordIdx(tokenID)
+		if err != nil {
+			// if err is db.ErrNotFound, should not happen, as all
+			// the validTxs.TokenID should have a CoordinatorIdx
+			// created in the DB at this point
+			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+		}
+		coordIdxsMap[tokenID] = coordIdx
+	}
+
+	var coordIdxs []common.Idx
+	for _, idx := range coordIdxsMap {
+		coordIdxs = append(coordIdxs, idx)
+	}
+	// sort CoordIdxs
+	sort.SliceStable(coordIdxs, func(i, j int) bool {
+		return coordIdxs[i] < coordIdxs[j]
+	})
+
+	// distribute the AccumulatedFees from the processed L2Txs into the
+	// Coordinator Idxs
+	for idx, accumulatedFee := range tp.AccumulatedFees {
+		cmp := accumulatedFee.Cmp(big.NewInt(0))
+		if cmp == 1 { // accumulatedFee>0
+			// send the fee to the Idx of the Coordinator for the TokenID
+			accCoord, err := txsel.localAccountsDB.GetAccount(idx)
+			if err != nil {
+				log.Errorw("Can not distribute accumulated fees to coordinator "+
+					"account: No coord Idx to receive fee", "idx", idx)
+				return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+			}
+			accCoord.Balance = new(big.Int).Add(accCoord.Balance, accumulatedFee)
+			_, err = txsel.localAccountsDB.UpdateAccount(idx, accCoord)
+			if err != nil {
+				log.Error(err)
+				return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+			}
+		}
+	}
+
+	err = tp.StateDB().MakeCheckpoint()
+	if err != nil {
+		return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+	}
+
+	metricSelectedL1UserTxs.Set(float64(len(l1UserTxs)))
+	metricSelectedL1CoordinatorTxs.Set(float64(len(l1CoordinatorTxs)))
+	metricSelectedL2Txs.Set(float64(len(validTxs)))
+	metricDiscardedL2Txs.Set(float64(len(discardedL2Txs)))
+
+	return coordIdxs, accAuths, l1UserTxs, l1CoordinatorTxs, validTxs, discardedL2Txs, nil
+}
+
+func (txsel *TxSelector) processL2Txs(tp *txprocessor.TxProcessor,
+	selectionConfig txprocessor.Config, nL1Txs int, l2Txs, validTxs, discardedL2Txs []common.PoolL2Tx) (
+	[][]byte, []common.L1Tx, []common.PoolL2Tx, []common.PoolL2Tx, error) {
+	var l1CoordinatorTxs []common.L1Tx
+	positionL1 := nL1Txs
+	var accAuths [][]byte
 	// Iterate over l2Txs
 	// - check Nonces
 	// - check enough Balance for the Amount+Fee
@@ -221,20 +342,22 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 	// - put the valid txs into validTxs array
 	for i := 0; i < len(l2Txs); i++ {
 		// Check if there is space for more L2Txs in the selection
-		maxL2Txs := int(selectionConfig.MaxTx) -
+		maxL2Txs := int(selectionConfig.MaxTx) - nL1Txs - len(l1CoordinatorTxs)
-			len(l1UserTxs) - len(l1CoordinatorTxs)
 		if len(validTxs) >= maxL2Txs {
-			// no more available slots for L2Txs
+			// no more available slots for L2Txs, so mark this tx
-			l2Txs[i].Info =
+			// but also the rest of remaining txs as discarded
-				"Tx not selected due not available slots for L2Txs"
+			for j := i; j < len(l2Txs); j++ {
-			discardedL2Txs = append(discardedL2Txs, l2Txs[i])
+				l2Txs[j].Info =
-			continue
+					"Tx not selected due not available slots for L2Txs"
+				discardedL2Txs = append(discardedL2Txs, l2Txs[j])
+			}
+			break
 		}
 
 		// get Nonce & TokenID from the Account by l2Tx.FromIdx
 		accSender, err := tp.StateDB().GetAccount(l2Txs[i].FromIdx)
 		if err != nil {
-			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+			return nil, nil, nil, nil, tracerr.Wrap(err)
 		}
 		l2Txs[i].TokenID = accSender.TokenID
 
@@ -272,13 +395,13 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 			txsel.coordAccountForTokenID(l1CoordinatorTxs,
 				accSender.TokenID, positionL1)
 		if err != nil {
-			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+			return nil, nil, nil, nil, tracerr.Wrap(err)
 		}
 		if newL1CoordTx != nil {
 			// if there is no space for the L1CoordinatorTx as MaxL1Tx, or no space
 			// for L1CoordinatorTx + L2Tx as MaxTx, discard the L2Tx
-			if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1Tx)-len(l1UserTxs) ||
+			if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1Tx)-nL1Txs ||
-				len(l1CoordinatorTxs)+1 >= int(selectionConfig.MaxTx)-len(l1UserTxs) {
+				len(l1CoordinatorTxs)+1 >= int(selectionConfig.MaxTx)-nL1Txs {
 				// discard L2Tx, and update Info parameter of
 				// the tx, and add it to the discardedTxs array
 				l2Txs[i].Info = "Tx not selected because the L2Tx depends on a " +
@@ -294,7 +417,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 			// process the L1CoordTx
 			_, _, _, _, err := tp.ProcessL1Tx(nil, newL1CoordTx)
 			if err != nil {
-				return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+				return nil, nil, nil, nil, tracerr.Wrap(err)
 			}
 		}
 
@@ -309,7 +432,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 		if l2Txs[i].ToIdx == 0 { // ToEthAddr/ToBJJ case
 			validL2Tx, l1CoordinatorTx, accAuth, err :=
 				txsel.processTxToEthAddrBJJ(validTxs, selectionConfig,
-					len(l1UserTxs), l1CoordinatorTxs, positionL1, l2Txs[i])
+					nL1Txs, l1CoordinatorTxs, positionL1, l2Txs[i])
 			if err != nil {
 				log.Debugw("txsel.processTxToEthAddrBJJ", "err", err)
 				// Discard L2Tx, and update Info parameter of
@@ -321,8 +444,8 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 			}
 			// if there is no space for the L1CoordinatorTx as MaxL1Tx, or no space
 			// for L1CoordinatorTx + L2Tx as MaxTx, discard the L2Tx
-			if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1Tx)-len(l1UserTxs) ||
+			if len(l1CoordinatorTxs) >= int(selectionConfig.MaxL1Tx)-nL1Txs ||
-				len(l1CoordinatorTxs)+1 >= int(selectionConfig.MaxTx)-len(l1UserTxs) {
+				len(l1CoordinatorTxs)+1 >= int(selectionConfig.MaxTx)-nL1Txs {
 				// discard L2Tx, and update Info parameter of
 				// the tx, and add it to the discardedTxs array
 				l2Txs[i].Info = "Tx not selected because the L2Tx depends on a " +
@@ -351,7 +474,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 				// process the L1CoordTx
 				_, _, _, _, err := tp.ProcessL1Tx(nil, l1CoordinatorTx)
 				if err != nil {
-					return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
+					return nil, nil, nil, nil, tracerr.Wrap(err)
 				}
 			}
 			if validL2Tx == nil {
@@ -413,7 +536,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 			// if err is db.ErrNotFound, should not happen, as all
 			// the validTxs.TokenID should have a CoordinatorIdx
 			// created in the DB at this point
-			return nil, nil, nil, nil, nil, nil,
+			return nil, nil, nil, nil,
 				tracerr.Wrap(fmt.Errorf("Could not get CoordIdx for TokenID=%d, "+
 					"due: %s", tokenID, err))
 		}
@@ -439,68 +562,7 @@ func (txsel *TxSelector) getL1L2TxSelection(selectionConfig txprocessor.Config,
 		validTxs = append(validTxs, l2Txs[i])
 	} // after this loop, no checks to discard txs should be done
 
-	// get CoordIdxsMap for the TokenIDs
+	return accAuths, l1CoordinatorTxs, validTxs, discardedL2Txs, nil
-	coordIdxsMap := make(map[common.TokenID]common.Idx)
-	for i := 0; i < len(validTxs); i++ {
-		// get TokenID from tx.Sender
-		accSender, err := tp.StateDB().GetAccount(validTxs[i].FromIdx)
-		if err != nil {
-			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
-		}
-		tokenID := accSender.TokenID
-
-		coordIdx, err := txsel.getCoordIdx(tokenID)
-		if err != nil {
-			// if err is db.ErrNotFound, should not happen, as all
-			// the validTxs.TokenID should have a CoordinatorIdx
-			// created in the DB at this point
-			return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
-		}
-		coordIdxsMap[tokenID] = coordIdx
-	}
-
-	var coordIdxs []common.Idx
-	for _, idx := range coordIdxsMap {
-		coordIdxs = append(coordIdxs, idx)
-	}
-	// sort CoordIdxs
-	sort.SliceStable(coordIdxs, func(i, j int) bool {
-		return coordIdxs[i] < coordIdxs[j]
-	})
-
-	// distribute the AccumulatedFees from the processed L2Txs into the
-	// Coordinator Idxs
-	for idx, accumulatedFee := range tp.AccumulatedFees {
-		cmp := accumulatedFee.Cmp(big.NewInt(0))
-		if cmp == 1 { // accumulatedFee>0
-			// send the fee to the Idx of the Coordinator for the TokenID
-			accCoord, err := txsel.localAccountsDB.GetAccount(idx)
-			if err != nil {
-				log.Errorw("Can not distribute accumulated fees to coordinator "+
-					"account: No coord Idx to receive fee", "idx", idx)
-				return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
-			}
-			accCoord.Balance = new(big.Int).Add(accCoord.Balance, accumulatedFee)
-			_, err = txsel.localAccountsDB.UpdateAccount(idx, accCoord)
-			if err != nil {
-				log.Error(err)
-				return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
-			}
-		}
-	}
-
-	err = tp.StateDB().MakeCheckpoint()
-	if err != nil {
-		return nil, nil, nil, nil, nil, nil, tracerr.Wrap(err)
-	}
-
-	metricSelectedL1CoordinatorTxs.Set(float64(len(l1CoordinatorTxs)))
-	metricSelectedL1UserTxs.Set(float64(len(l1UserTxs)))
-	metricSelectedL2Txs.Set(float64(len(validTxs)))
-	metricDiscardedL2Txs.Set(float64(len(discardedL2Txs)))
-
-	// return coordIdxs, accAuths, l1UserTxs, l1CoordinatorTxs, validTxs, discardedL2Txs, nil
-	return coordIdxs, accAuths, l1UserTxs, l1CoordinatorTxs, validTxs, discardedL2Txs, nil
 }
 
 // processTxsToEthAddrBJJ process the common.PoolL2Tx in the case where
@@ -636,26 +698,14 @@ func checkAlreadyPendingToCreate(l1CoordinatorTxs []common.L1Tx, tokenID common.
 	return false
 }
 
-// getL2Profitable returns the profitable selection of L2Txssorted by Nonce
+// sortL2Txs sorts the PoolL2Txs by AbsoluteFee and then by Nonce
-func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) ([]common.PoolL2Tx,
+func sortL2Txs(l2Txs []common.PoolL2Tx) []common.PoolL2Tx {
-	[]common.PoolL2Tx) {
-	// First sort by nonce so that txs from the same account are sorted so
-	// that they could be applied in succession.
-	sort.Slice(l2Txs, func(i, j int) bool {
-		return l2Txs[i].Nonce < l2Txs[j].Nonce
-	})
 	// Sort by absolute fee with SliceStable, so that txs with same
 	// AbsoluteFee are not rearranged and nonce order is kept in such case
 	sort.SliceStable(l2Txs, func(i, j int) bool {
 		return l2Txs[i].AbsoluteFee > l2Txs[j].AbsoluteFee
 	})
 
-	discardedL2Txs := []common.PoolL2Tx{}
-	if len(l2Txs) > int(max) {
-		discardedL2Txs = l2Txs[max:]
-		l2Txs = l2Txs[:max]
-	}
-
 	// sort l2Txs by Nonce. This can be done in many different ways, what
 	// is needed is to output the l2Txs where the Nonce of l2Txs for each
 	// Account is sorted, but the l2Txs can not be grouped by sender Account
@@ -665,5 +715,29 @@ func (txsel *TxSelector) getL2Profitable(l2Txs []common.PoolL2Tx, max uint32) ([
 		return l2Txs[i].Nonce < l2Txs[j].Nonce
 	})
 
-	return l2Txs, discardedL2Txs
+	return l2Txs
+}
+
+func splitL2ForgableAndNonForgable(tp *txprocessor.TxProcessor,
+	l2Txs []common.PoolL2Tx) ([]common.PoolL2Tx, []common.PoolL2Tx) {
+	var l2TxsForgable, l2TxsNonForgable []common.PoolL2Tx
+	for i := 0; i < len(l2Txs); i++ {
+		accSender, err := tp.StateDB().GetAccount(l2Txs[i].FromIdx)
+		if err != nil {
+			l2TxsNonForgable = append(l2TxsNonForgable, l2Txs[i])
+			continue
+		}
+
+		if l2Txs[i].Nonce != accSender.Nonce {
+			l2TxsNonForgable = append(l2TxsNonForgable, l2Txs[i])
+			continue
+		}
+		enoughBalance, _, _ := tp.CheckEnoughBalance(l2Txs[i])
+		if !enoughBalance {
+			l2TxsNonForgable = append(l2TxsNonForgable, l2Txs[i])
+			continue
+		}
+		l2TxsForgable = append(l2TxsForgable, l2Txs[i])
+	}
+	return l2TxsForgable, l2TxsNonForgable
 }

txselector/txselector_test.go

@@ -26,11 +26,13 @@ import (
 )
 
 func initTest(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address,
-	coordUser *til.User) *TxSelector {
+	coordUser *til.User) (*TxSelector, *historydb.HistoryDB) {
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
+
+	historyDB := historydb.NewHistoryDB(db, db, nil)
 
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
@@ -65,7 +67,7 @@ func initTest(t *testing.T, chainID uint16, hermezContractAddr ethCommon.Address
 
 	test.WipeDB(txsel.l2db.DB())
 
-	return txsel
+	return txsel, historyDB
 }
 
 func addAccCreationAuth(t *testing.T, tc *til.Context, txsel *TxSelector, chainID uint16,
@@ -157,7 +159,7 @@ func TestGetL2TxSelectionMinimumFlow0(t *testing.T) {
 	assert.NoError(t, err)
 
 	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	txsel := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
+	txsel, _ := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
 
 	// restart nonces of TilContext, as will be set by generating directly
 	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
@@ -417,7 +419,7 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	assert.NoError(t, err)
 
 	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	txsel := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
+	txsel, _ := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
 
 	// restart nonces of TilContext, as will be set by generating directly
 	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
@@ -470,11 +472,6 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	tc.RestartNonces()
 
 	// batch3
-	// NOTE: this batch will result with 1 L2Tx, as the PoolExit tx is not
-	// possible, as the PoolTransferToEthAddr is not processed yet when
-	// checking availability of PoolExit.  This, in a near-future iteration
-	// of the TxSelector will return the 2 transactions as valid and
-	// selected, as the TxSelector will handle this kind of combinations.
 	batchPoolL2 = `
 	Type: PoolL2
 	PoolTransferToEthAddr(0) A-B: 50 (126)`
@@ -488,11 +485,11 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
-	assert.Equal(t, 1, len(oL2Txs)) // see 'NOTE' at the beginning of 'batch3' of this test
+	assert.Equal(t, 2, len(oL2Txs))
-	assert.Equal(t, 2, len(discardedL2Txs))
+	assert.Equal(t, 1, len(discardedL2Txs))
 	assert.Equal(t, expectedTxID2, oL2Txs[0].TxID.String())
+	assert.Equal(t, expectedTxID1, oL2Txs[1].TxID.String())
 	assert.Equal(t, expectedTxID0, discardedL2Txs[0].TxID.String())
-	assert.Equal(t, expectedTxID1, discardedL2Txs[1].TxID.String())
 	assert.Equal(t, common.TxTypeTransferToEthAddr, oL2Txs[0].Type)
 	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs),
 		txsel.localAccountsDB.CurrentBatch())
@@ -507,12 +504,8 @@ func TestPoolL2TxsWithoutEnoughBalance(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, 0, len(oL1UserTxs))
 	assert.Equal(t, 0, len(oL1CoordTxs))
-	assert.Equal(t, 1, len(oL2Txs))
+	assert.Equal(t, 0, len(oL2Txs))
 	assert.Equal(t, 1, len(discardedL2Txs))
-	// the Exit that was not accepted at the batch2
-	assert.Equal(t, expectedTxID1, oL2Txs[0].TxID.String())
-	assert.Equal(t, expectedTxID0, discardedL2Txs[0].TxID.String())
-	assert.Equal(t, common.TxTypeExit, oL2Txs[0].Type)
 	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs),
 		txsel.localAccountsDB.CurrentBatch())
 	require.NoError(t, err)
@@ -539,7 +532,7 @@ func TestTransferToBjj(t *testing.T) {
 	assert.NoError(t, err)
 
 	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	txsel := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
+	txsel, _ := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
 
 	// restart nonces of TilContext, as will be set by generating directly
 	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
@@ -670,7 +663,7 @@ func TestTransferManyFromSameAccount(t *testing.T) {
 	assert.NoError(t, err)
 
 	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	txsel := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
+	txsel, _ := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
 
 	// restart nonces of TilContext, as will be set by generating directly
 	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
@@ -752,7 +745,7 @@ func TestPoolL2TxInvalidNonces(t *testing.T) {
 	assert.NoError(t, err)
 
 	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	txsel := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
+	txsel, _ := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
 
 	// restart nonces of TilContext, as will be set by generating directly
 	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
@@ -865,7 +858,7 @@ func TestProcessL2Selection(t *testing.T) {
 	assert.NoError(t, err)
 
 	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
-	txsel := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
+	txsel, _ := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
 
 	// restart nonces of TilContext, as will be set by generating directly
 	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
@@ -921,3 +914,127 @@ func TestProcessL2Selection(t *testing.T) {
 		txsel.localAccountsDB.CurrentBatch())
 	require.NoError(t, err)
 }
+
+func TestValidTxsWithLowFeeAndInvalidTxsWithHighFee(t *testing.T) {
+	// This test recreates the case where there are
+
+	set := `
+		Type: Blockchain
+
+		CreateAccountDeposit(0) Coord: 0
+		CreateAccountDeposit(0) A: 100
+		CreateAccountDeposit(0) B: 0
+
+		> batchL1 // Batch1: freeze L1User{3}
+		> batchL1 // Batch2: forge L1User{3}
+		> block
+	`
+
+	chainID := uint16(0)
+	tc := til.NewContext(chainID, common.RollupConstMaxL1UserTx)
+	tilCfgExtra := til.ConfigExtra{
+		BootCoordAddr: ethCommon.HexToAddress("0xE39fEc6224708f0772D2A74fd3f9055A90E0A9f2"),
+		CoordUser:     "Coord",
+	}
+	blocks, err := tc.GenerateBlocks(set)
+	require.NoError(t, err)
+	err = tc.FillBlocksExtra(blocks, &tilCfgExtra)
+	require.NoError(t, err)
+	err = tc.FillBlocksForgedL1UserTxs(blocks)
+	require.NoError(t, err)
+
+	hermezContractAddr := ethCommon.HexToAddress("0xc344E203a046Da13b0B4467EB7B3629D0C99F6E6")
+	txsel, historyDB := initTest(t, chainID, hermezContractAddr, tc.Users["Coord"])
+
+	// Insert blocks into DB
+	for i := range blocks {
+		err = historyDB.AddBlockSCData(&blocks[i])
+		assert.NoError(t, err)
+	}
+
+	err = historyDB.UpdateTokenValue(common.EmptyAddr, 1000)
+	require.NoError(t, err)
+
+	// restart nonces of TilContext, as will be set by generating directly
+	// the PoolL2Txs for each specific batch with tc.GeneratePoolL2Txs
+	tc.RestartNonces()
+
+	tpc := txprocessor.Config{
+		NLevels:  16,
+		MaxFeeTx: 5,
+		MaxTx:    5,
+		MaxL1Tx:  3,
+		ChainID:  chainID,
+	}
+	// batch1 to freeze L1UserTxs
+	l1UserTxs := []common.L1Tx{}
+	_, _, _, _, _, _, err = txsel.GetL1L2TxSelection(tpc, l1UserTxs)
+	require.NoError(t, err)
+
+	// batch 2 to crate the accounts (from L1UserTxs)
+	l1UserTxs = til.L1TxsToCommonL1Txs(tc.Queues[*blocks[0].Rollup.Batches[1].Batch.ForgeL1TxsNum])
+
+	// select L1 & L2 txs
+	_, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err :=
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(oL1UserTxs))
+	require.Equal(t, 0, len(oL1CoordTxs))
+	require.Equal(t, 0, len(oL2Txs))
+	require.Equal(t, 0, len(discardedL2Txs))
+	require.Equal(t, 0, len(accAuths))
+
+	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs),
+		txsel.localAccountsDB.CurrentBatch())
+	require.NoError(t, err)
+
+	// batch 3. The A-B txs have lower fee, but are the only ones possible
+	// with the current Accounts Balances, as the B-A tx of amount 40 will
+	// not be included as will be processed first when there is not enough
+	// balance at B (processed first as the TxSelector sorts by Fee and then
+	// by Nonce).
+	batchPoolL2 := `
+	Type: PoolL2
+	PoolTransfer(0) B-A: 40 (130) // B-A txs are only possible once A-B txs are processed
+	PoolTransfer(0) B-A: 1 (126)
+	PoolTransfer(0) B-A: 1 (126)
+	PoolTransfer(0) B-A: 1 (126)
+	PoolTransfer(0) B-A: 1 (126)
+	PoolTransfer(0) B-A: 1 (126)
+	PoolTransfer(0) B-A: 1 (126)
+	PoolTransfer(0) B-A: 1 (126)
+	PoolTransfer(0) A-B: 20 (20)
+	PoolTransfer(0) A-B: 25 (150)
+	PoolTransfer(0) A-B: 20 (20)
+	`
+	poolL2Txs, err := tc.GeneratePoolL2Txs(batchPoolL2)
+	require.NoError(t, err)
+	require.Equal(t, 11, len(poolL2Txs))
+	// add the PoolL2Txs to the l2DB
+	addL2Txs(t, txsel, poolL2Txs)
+	l1UserTxs = []common.L1Tx{}
+	_, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
+	require.NoError(t, err)
+
+	require.Equal(t, 0, len(oL1UserTxs))
+	require.Equal(t, 0, len(oL1CoordTxs))
+	require.Equal(t, 3, len(oL2Txs))         // the 3 txs A-B
+	require.Equal(t, 8, len(discardedL2Txs)) // the 8 txs B-A
+	require.Equal(t, 0, len(accAuths))
+
+	err = txsel.l2db.StartForging(common.TxIDsFromPoolL2Txs(oL2Txs),
+		txsel.localAccountsDB.CurrentBatch())
+	require.NoError(t, err)
+
+	// batch 4. In this Batch, account B has enough balance to send the txs
+	_, accAuths, oL1UserTxs, oL1CoordTxs, oL2Txs, discardedL2Txs, err =
+		txsel.GetL1L2TxSelection(tpc, l1UserTxs)
+	require.NoError(t, err)
+
+	require.Equal(t, 0, len(oL1UserTxs))
+	require.Equal(t, 0, len(oL1CoordTxs))
+	require.Equal(t, 5, len(oL2Txs))
+	require.Equal(t, 3, len(discardedL2Txs))
+	require.Equal(t, 0, len(accAuths))
+}