Licensing everywhere

38 files changed, 1924 insertions, 793 deletions

diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..be3f7b2
--- /dev/null
+++ b/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/>.
diff --git a/btc-wire/Cargo.toml b/btc-wire/Cargo.toml
index 6d8a9d6..3796da8 100644
--- a/btc-wire/Cargo.toml
+++ b/btc-wire/Cargo.toml
@@ -2,6 +2,7 @@
 name = "btc-wire"

 version = "0.1.0"

 edition = "2021"

+license = "AGPL-3.0-or-later"

 

 [features]

 # Enable random failures

diff --git a/btc-wire/benches/metadata.rs b/btc-wire/benches/metadata.rs
index e19eefd..5418e0f 100644
--- a/btc-wire/benches/metadata.rs
+++ b/btc-wire/benches/metadata.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use btc_wire::{

     segwit::{decode_segwit_msg, encode_segwit_key, rand_addresses},

     test::rand_key,

diff --git a/btc-wire/src/bin/btc-wire-cli.rs b/btc-wire/src/bin/btc-wire-cli.rs
index ce5b57b..46bd424 100644
--- a/btc-wire/src/bin/btc-wire-cli.rs
+++ b/btc-wire/src/bin/btc-wire-cli.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 use btc_wire::{
     config::{BitcoinConfig, WIRE_WALLET_NAME},
     rpc::{BtcRpc, Error, ErrorCode},
diff --git a/btc-wire/src/bin/btc-wire-utils.rs b/btc-wire/src/bin/btc-wire-utils.rs
index 72f1fb3..02db643 100644
--- a/btc-wire/src/bin/btc-wire-utils.rs
+++ b/btc-wire/src/bin/btc-wire-utils.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use std::path::PathBuf;

 

 use bitcoin::{Address, Amount, Network};

diff --git a/btc-wire/src/bin/test.rs b/btc-wire/src/bin/test.rs
index 09ca0a3..e1d5085 100644
--- a/btc-wire/src/bin/test.rs
+++ b/btc-wire/src/bin/test.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use core::panic;

 use std::{collections::HashSet, iter::repeat_with, panic::AssertUnwindSafe};

 

diff --git a/btc-wire/src/config.rs b/btc-wire/src/config.rs
index 52bafb8..40f74a8 100644
--- a/btc-wire/src/config.rs
+++ b/btc-wire/src/config.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 use std::{
     net::SocketAddr,
     path::{Path, PathBuf},
diff --git a/btc-wire/src/fail_point.rs b/btc-wire/src/fail_point.rs
index eb044ee..0579631 100644
--- a/btc-wire/src/fail_point.rs
+++ b/btc-wire/src/fail_point.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 /// Inject random failure when 'fail' feature is used
 #[allow(unused_variables)]
 pub fn fail_point(msg: &'static str, prob: f32) -> Result<(), &'static str> {
diff --git a/btc-wire/src/info.rs b/btc-wire/src/info.rs
index cc61b04..fd4ff08 100644
--- a/btc-wire/src/info.rs
+++ b/btc-wire/src/info.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 use bitcoin::{hashes::Hash, Txid};
 use url::Url;
 
diff --git a/btc-wire/src/lib.rs b/btc-wire/src/lib.rs
index 41598d6..9b865bf 100644
--- a/btc-wire/src/lib.rs
+++ b/btc-wire/src/lib.rs
@@ -1,140 +1,161 @@
-use std::str::FromStr;

-

-use bitcoin::{hashes::hex::FromHex, Address, Amount, Network, Txid};

-use rpc::{BtcRpc, Category, TransactionFull};

-use rpc_utils::{segwit_min_amount, sender_address};

-use segwit::{decode_segwit_msg, encode_segwit_key};

-

-pub mod config;

-pub mod rpc;

-pub mod rpc_utils;

-pub mod segwit;

-pub mod test;

-

-#[derive(Debug, thiserror::Error)]

-pub enum GetSegwitErr {

-    #[error(transparent)]

-    Decode(#[from] segwit::DecodeSegWitErr),

-    #[error(transparent)]

-    RPC(#[from] rpc::Error),

-}

-

-#[derive(Debug, thiserror::Error)]

-pub enum GetOpReturnErr {

-    #[error("Missing opreturn")]

-    MissingOpReturn,

-    #[error(transparent)]

-    RPC(#[from] rpc::Error),

-}

-

-/// An extended bitcoincore JSON-RPC api client who can send and retrieve metadata with their transaction

-impl BtcRpc {

-    /// Send a transaction with a 32B key as metadata encoded using fake segwit addresses

-    pub fn send_segwit_key(

-        &mut self,

-        to: &Address,

-        amount: &Amount,

-        metadata: &[u8; 32],

-    ) -> rpc::Result<Txid> {

-        let hrp = match to.network {

-            Network::Bitcoin => "bc",

-            Network::Testnet | Network::Signet => "tb",

-            Network::Regtest => "bcrt",

-        };

-        let addresses = encode_segwit_key(hrp, metadata);

-        let addresses = [

-            Address::from_str(&addresses[0]).unwrap(),

-            Address::from_str(&addresses[1]).unwrap(),

-        ];

-        let mut recipients = vec![(to, amount)];

-        let min = segwit_min_amount();

-        recipients.extend(addresses.iter().map(|addr| (addr, &min)));

-        self.send_many(recipients)

-    }

-

-    /// Get detailed information about an in-wallet transaction and it's 32B metadata key encoded using fake segwit addresses

-    pub fn get_tx_segwit_key(

-        &mut self,

-        id: &Txid,

-    ) -> Result<(TransactionFull, [u8; 32]), GetSegwitErr> {

-        let full = self.get_tx(id)?;

-

-        let addresses: Vec<String> = full

-            .decoded

-            .vout

-            .iter()

-            .filter_map(|it| {

-                it.script_pub_key

-                    .address

-                    .as_ref()

-                    .map(|addr| addr.to_string())

-            })

-            .collect();

-

-        let metadata = decode_segwit_msg(&addresses)?;

-

-        Ok((full, metadata))

-    }

-

-    /// Send a transaction with metadata encoded using OP_RETURN

-    pub fn send_op_return(

-        &mut self,

-        to: &Address,

-        amount: &Amount,

-        metadata: &[u8],

-        subtract_fee: bool,

-        replaceable: bool

-    ) -> rpc::Result<Txid> {

-        assert!(metadata.len() > 0, "No medatata");

-        assert!(metadata.len() <= 80, "Max 80 bytes");

-        self.send_custom(&[], [(to, amount)], Some(metadata), subtract_fee, replaceable)

-    }

-

-    /// Get detailed information about an in-wallet transaction and its op_return metadata

-    pub fn get_tx_op_return(

-        &mut self,

-        id: &Txid,

-    ) -> Result<(TransactionFull, Vec<u8>), GetOpReturnErr> {

-        let full = self.get_tx(id)?;

-

-        let op_return_out = full

-            .decoded

-            .vout

-            .iter()

-            .find(|it| it.script_pub_key.asm.starts_with("OP_RETURN"))

-            .ok_or(GetOpReturnErr::MissingOpReturn)?;

-

-        let hex = op_return_out.script_pub_key.asm.split_once(' ').unwrap().1;

-        // Op return payload is always encoded in hexadecimal

-        let metadata = Vec::from_hex(hex).unwrap();

-

-        Ok((full, metadata))

-    }

-

-    /// Bounce a transaction bask to its sender

-    ///

-    /// There is no reliable way to bounce a transaction as you cannot know if the addresses

-    /// used are shared or come from a third-party service. We only send back to the first input

-    /// address as a best-effort gesture.

-    pub fn bounce(

-        &mut self,

-        id: &Txid,

-        bounce_fee: &Amount,

-        metadata: &[u8],

-    ) -> Result<Txid, rpc::Error> {

-        let full = self.get_tx(id)?;

-        let detail = &full.details[0];

-        assert!(detail.category == Category::Receive);

-

-        let amount = detail.amount.to_unsigned().unwrap();

-        let sender = sender_address(self, &full)?;

-        let bounce_amount = Amount::from_sat(amount.as_sat().saturating_sub(bounce_fee.as_sat()));

-        // Send refund making recipient pay the transaction fees

-        let id = if metadata.is_empty() {

-            self.send(&sender, &bounce_amount, true)?

-        } else {

-            self.send_op_return(&sender, &bounce_amount, metadata, true, false)?

-        };

-        Ok(id)

-    }

-}

+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
+use std::str::FromStr;
+
+use bitcoin::{hashes::hex::FromHex, Address, Amount, Network, Txid};
+use rpc::{BtcRpc, Category, TransactionFull};
+use rpc_utils::{segwit_min_amount, sender_address};
+use segwit::{decode_segwit_msg, encode_segwit_key};
+
+pub mod config;
+pub mod rpc;
+pub mod rpc_utils;
+pub mod segwit;
+pub mod test;
+
+#[derive(Debug, thiserror::Error)]
+pub enum GetSegwitErr {
+    #[error(transparent)]
+    Decode(#[from] segwit::DecodeSegWitErr),
+    #[error(transparent)]
+    RPC(#[from] rpc::Error),
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum GetOpReturnErr {
+    #[error("Missing opreturn")]
+    MissingOpReturn,
+    #[error(transparent)]
+    RPC(#[from] rpc::Error),
+}
+
+/// An extended bitcoincore JSON-RPC api client who can send and retrieve metadata with their transaction
+impl BtcRpc {
+    /// Send a transaction with a 32B key as metadata encoded using fake segwit addresses
+    pub fn send_segwit_key(
+        &mut self,
+        to: &Address,
+        amount: &Amount,
+        metadata: &[u8; 32],
+    ) -> rpc::Result<Txid> {
+        let hrp = match to.network {
+            Network::Bitcoin => "bc",
+            Network::Testnet | Network::Signet => "tb",
+            Network::Regtest => "bcrt",
+        };
+        let addresses = encode_segwit_key(hrp, metadata);
+        let addresses = [
+            Address::from_str(&addresses[0]).unwrap(),
+            Address::from_str(&addresses[1]).unwrap(),
+        ];
+        let mut recipients = vec![(to, amount)];
+        let min = segwit_min_amount();
+        recipients.extend(addresses.iter().map(|addr| (addr, &min)));
+        self.send_many(recipients)
+    }
+
+    /// Get detailed information about an in-wallet transaction and it's 32B metadata key encoded using fake segwit addresses
+    pub fn get_tx_segwit_key(
+        &mut self,
+        id: &Txid,
+    ) -> Result<(TransactionFull, [u8; 32]), GetSegwitErr> {
+        let full = self.get_tx(id)?;
+
+        let addresses: Vec<String> = full
+            .decoded
+            .vout
+            .iter()
+            .filter_map(|it| {
+                it.script_pub_key
+                    .address
+                    .as_ref()
+                    .map(|addr| addr.to_string())
+            })
+            .collect();
+
+        let metadata = decode_segwit_msg(&addresses)?;
+
+        Ok((full, metadata))
+    }
+
+    /// Send a transaction with metadata encoded using OP_RETURN
+    pub fn send_op_return(
+        &mut self,
+        to: &Address,
+        amount: &Amount,
+        metadata: &[u8],
+        subtract_fee: bool,
+        replaceable: bool,
+    ) -> rpc::Result<Txid> {
+        assert!(metadata.len() > 0, "No medatata");
+        assert!(metadata.len() <= 80, "Max 80 bytes");
+        self.send_custom(
+            &[],
+            [(to, amount)],
+            Some(metadata),
+            subtract_fee,
+            replaceable,
+        )
+    }
+
+    /// Get detailed information about an in-wallet transaction and its op_return metadata
+    pub fn get_tx_op_return(
+        &mut self,
+        id: &Txid,
+    ) -> Result<(TransactionFull, Vec<u8>), GetOpReturnErr> {
+        let full = self.get_tx(id)?;
+
+        let op_return_out = full
+            .decoded
+            .vout
+            .iter()
+            .find(|it| it.script_pub_key.asm.starts_with("OP_RETURN"))
+            .ok_or(GetOpReturnErr::MissingOpReturn)?;
+
+        let hex = op_return_out.script_pub_key.asm.split_once(' ').unwrap().1;
+        // Op return payload is always encoded in hexadecimal
+        let metadata = Vec::from_hex(hex).unwrap();
+
+        Ok((full, metadata))
+    }
+
+    /// Bounce a transaction bask to its sender
+    ///
+    /// There is no reliable way to bounce a transaction as you cannot know if the addresses
+    /// used are shared or come from a third-party service. We only send back to the first input
+    /// address as a best-effort gesture.
+    pub fn bounce(
+        &mut self,
+        id: &Txid,
+        bounce_fee: &Amount,
+        metadata: &[u8],
+    ) -> Result<Txid, rpc::Error> {
+        let full = self.get_tx(id)?;
+        let detail = &full.details[0];
+        assert!(detail.category == Category::Receive);
+
+        let amount = detail.amount.to_unsigned().unwrap();
+        let sender = sender_address(self, &full)?;
+        let bounce_amount = Amount::from_sat(amount.as_sat().saturating_sub(bounce_fee.as_sat()));
+        // Send refund making recipient pay the transaction fees
+        let id = if metadata.is_empty() {
+            self.send(&sender, &bounce_amount, true)?
+        } else {
+            self.send_op_return(&sender, &bounce_amount, metadata, true, false)?
+        };
+        Ok(id)
+    }
+}
diff --git a/btc-wire/src/loops.rs b/btc-wire/src/loops.rs
index f28e2b1..5e80da0 100644
--- a/btc-wire/src/loops.rs
+++ b/btc-wire/src/loops.rs
@@ -1,3 +1,18 @@
-pub mod worker;
-pub mod listener;
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 pub mod analysis;
+pub mod listener;
+pub mod worker;
diff --git a/btc-wire/src/loops/analysis.rs b/btc-wire/src/loops/analysis.rs
index e1ff5bf..086d205 100644
--- a/btc-wire/src/loops/analysis.rs
+++ b/btc-wire/src/loops/analysis.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 use std::sync::atomic::Ordering;
 
 use btc_wire::rpc::ChainTipsStatus;
diff --git a/btc-wire/src/loops/listener.rs b/btc-wire/src/loops/listener.rs
index 41cfd7e..85210b4 100644
--- a/btc-wire/src/loops/listener.rs
+++ b/btc-wire/src/loops/listener.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 use taler_common::log::log::error;
 
 use crate::reconnect::{AutoReconnectRPC, AutoReconnectSql};
@@ -15,4 +30,4 @@ pub fn block_listener(mut rpc: AutoReconnectRPC, mut db: AutoReconnectSql) {
             error!("listener: {}", e);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/btc-wire/src/loops/worker.rs b/btc-wire/src/loops/worker.rs
index 1ad3069..2f4cc13 100644
--- a/btc-wire/src/loops/worker.rs
+++ b/btc-wire/src/loops/worker.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 use std::{
     collections::{HashMap, HashSet},
     fmt::Write,
diff --git a/btc-wire/src/main.rs b/btc-wire/src/main.rs
index 875281f..e551735 100644
--- a/btc-wire/src/main.rs
+++ b/btc-wire/src/main.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use bitcoin::Network;

 use btc_wire::{

     config::{BitcoinConfig, WIRE_WALLET_NAME},

diff --git a/btc-wire/src/reconnect.rs b/btc-wire/src/reconnect.rs
index ea63d10..ea37f82 100644
--- a/btc-wire/src/reconnect.rs
+++ b/btc-wire/src/reconnect.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 //! Wrapper for RPC or PostgreSQL connection which automatically reconnect on error
 
 use std::time::Duration;
diff --git a/btc-wire/src/rpc.rs b/btc-wire/src/rpc.rs
index 32b3424..f7b08b8 100644
--- a/btc-wire/src/rpc.rs
+++ b/btc-wire/src/rpc.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 //! This is a very simple RPC client designed only for a specific bitcoind version
 //! and to use on an secure localhost connection to a trusted node
 //!
@@ -140,7 +155,7 @@ impl BtcRpc {
             buf.clear();
             // Write body
             sock.write_all(&body)?;
-            sock.flush().unwrap();
+            sock.flush()?;
         }
         // Skip response
         let sock = &mut self.conn;
diff --git a/btc-wire/src/rpc_utils.rs b/btc-wire/src/rpc_utils.rs
index 89961a9..876293e 100644
--- a/btc-wire/src/rpc_utils.rs
+++ b/btc-wire/src/rpc_utils.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use std::{path::PathBuf, str::FromStr};

 

 use bitcoin::{Address, Amount};

diff --git a/btc-wire/src/segwit.rs b/btc-wire/src/segwit.rs
index 8e54dbc..f8c2a8f 100644
--- a/btc-wire/src/segwit.rs
+++ b/btc-wire/src/segwit.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use bech32::{u5, FromBase32, ToBase32, Variant};

 use rand::{rngs::OsRng, RngCore};

 

diff --git a/btc-wire/src/status.rs b/btc-wire/src/status.rs
index 3e4b987..3ad45f9 100644
--- a/btc-wire/src/status.rs
+++ b/btc-wire/src/status.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 //! Transactions status in database
 
 /// Outgoing transaction status
diff --git a/btc-wire/src/taler_util.rs b/btc-wire/src/taler_util.rs
index f45c8bd..65e8e39 100644
--- a/btc-wire/src/taler_util.rs
+++ b/btc-wire/src/taler_util.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 //! Utils function to convert taler API types to bitcoin API types
 
 use bitcoin::{Address, Amount as BtcAmount, SignedAmount};
diff --git a/btc-wire/src/test.rs b/btc-wire/src/test.rs
index 8c3f649..2a0ee58 100644
--- a/btc-wire/src/test.rs
+++ b/btc-wire/src/test.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 pub fn rand_key() -> [u8; 32] {

     let mut key = [0; 32];

     key.fill_with(|| fastrand::u8(..));

diff --git a/research.md b/research.md
deleted file mode 100644
index e4b823a..0000000
--- a/research.md
+++ /dev/null
@@ -1,20 +0,0 @@
-# Depolymerization

-

-## Ethereum

-

-- A transaction is from one address to another

-- Have a arbitrary data payload for smart contract

-

-Can we use smart contract to read metadata ?

-

-Rust client library OpenEthereum - JSON RCP API

-

-## TODO

-

-- Add and test bounce

-- check if transactions are abandoned

-- suicide after n operations

-- detect small fork -> warning

-- fork -> ERR panic

-

-add biggest soft fork to confirmation threshold
\ No newline at end of file
diff --git a/taler-common/Cargo.toml b/taler-common/Cargo.toml
index 8dc479a..5136126 100644
--- a/taler-common/Cargo.toml
+++ b/taler-common/Cargo.toml
@@ -2,6 +2,7 @@
 name = "taler-common"
 version = "0.1.0"
 edition = "2021"
+license = "AGPL-3.0-or-later"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/taler-common/src/api_common.rs b/taler-common/src/api_common.rs
index 05a657e..015cc40 100644
--- a/taler-common/src/api_common.rs
+++ b/taler-common/src/api_common.rs
@@ -1,334 +1,349 @@
-use std::{

-    fmt::Display,

-    num::ParseIntError,

-    ops::Deref,

-    str::FromStr,

-    time::{Duration, SystemTime},

-};

-

-use serde::{de::Error, ser::SerializeStruct, Deserialize, Deserializer};

-use serde_json::Value;

-

-/// <https://docs.taler.net/core/api-common.html#tsref-type-ErrorDetail>

-#[derive(Debug, Clone, serde::Serialize)]

-pub struct ErrorDetail {

-    pub code: i64,

-    pub hint: Option<String>,

-    pub detail: Option<String>,

-    pub parameter: Option<String>,

-    pub path: Option<String>,

-    pub offset: Option<String>,

-    pub index: Option<String>,

-    pub object: Option<String>,

-    pub currency: Option<String>,

-    pub type_expected: Option<String>,

-    pub type_actual: Option<String>,

-}

-

-/// <https://docs.taler.net/core/api-common.html#tsref-type-Timestamp>

-#[derive(Debug, Clone, Copy, PartialEq, Eq)]

-pub enum Timestamp {

-    Never,

-    Time(SystemTime),

-}

-

-#[derive(serde::Serialize, serde::Deserialize)]

-struct TimestampImpl {

-    t_ms: Value,

-}

-

-impl Timestamp {

-    pub fn now() -> Self {

-        Self::Time(SystemTime::now())

-    }

-}

-

-impl<'de> Deserialize<'de> for Timestamp {

-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

-    where

-        D: Deserializer<'de>,

-    {

-        let tmp = TimestampImpl::deserialize(deserializer)?;

-        match tmp.t_ms {

-            Value::Number(ms) => {

-                if let Some(since_epoch_ms) = ms.as_u64() {

-                    Ok(Self::Time(

-                        SystemTime::UNIX_EPOCH + Duration::from_millis(since_epoch_ms),

-                    ))

-                } else {

-                    Err(Error::custom("Expected epoch time millis"))

-                }

-            }

-            Value::String(str) if str == "never" => Ok(Self::Never),

-            _ => Err(Error::custom("Expected epoch time millis or 'never'")),

-        }

-    }

-}

-

-impl serde::Serialize for Timestamp {

-    fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>

-    where

-        S: serde::Serializer,

-    {

-        let mut se_struct = se.serialize_struct("Timestamp", 1)?;

-        match self {

-            Timestamp::Never => se_struct.serialize_field("t_ms", "never")?,

-            Timestamp::Time(time) => se_struct.serialize_field(

-                "t_ms",

-                &(time

-                    .duration_since(SystemTime::UNIX_EPOCH)

-                    .unwrap()

-                    .as_secs() as u128

-                    * 1000),

-            )?,

-        };

-

-        se_struct.end()

-    }

-}

-

-impl From<SystemTime> for Timestamp {

-    fn from(time: SystemTime) -> Self {

-        Self::Time(time)

-    }

-}

-

-/// <https://docs.taler.net/core/api-common.html#tsref-type-SafeUint64>

-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)]

-pub struct SafeUint64(u64);

-

-#[derive(Debug, thiserror::Error)]

-#[error("{0} unsafe, {0} > (2^53 - 1)")]

-pub struct UnsafeUint64(u64);

-

-impl TryFrom<u64> for SafeUint64 {

-    type Error = UnsafeUint64;

-

-    fn try_from(nb: u64) -> Result<Self, Self::Error> {

-        if nb < (1 << 53) - 1 {

-            Ok(SafeUint64(nb))

-        } else {

-            Err(UnsafeUint64(nb))

-        }

-    }

-}

-

-impl<'de> Deserialize<'de> for SafeUint64 {

-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

-    where

-        D: Deserializer<'de>,

-    {

-        SafeUint64::try_from(u64::deserialize(deserializer)?).map_err(D::Error::custom)

-    }

-}

-

-#[derive(Debug, thiserror::Error)]

-pub enum ParseSafeUint64Error {

-    #[error(transparent)]

-    Unsafe(#[from] UnsafeUint64),

-    #[error(transparent)]

-    Format(#[from] ParseIntError),

-}

-

-/// <https://docs.taler.net/core/api-common.html#tsref-type-Amount>

-#[derive(

-    Debug, Clone, PartialEq, Eq, serde_with::DeserializeFromStr, serde_with::SerializeDisplay,

-)]

-pub struct Amount {

-    pub currency: String,

-    pub value: u64,

-    pub fraction: u32,

-}

-

-impl Amount {

-    pub fn new(currency: impl Into<String>, value: u64, fraction: u32) -> Self {

-        Self {

-            currency: currency.into(),

-            value,

-            fraction,

-        }

-    }

-}

-

-#[derive(Debug, thiserror::Error)]

-pub enum ParseAmountError {

-    #[error("Invalid amount format")]

-    FormatAmount,

-    #[error("Amount overflow")]

-    AmountOverflow,

-    #[error(transparent)]

-    Format(#[from] ParseIntError),

-}

-

-impl FromStr for Amount {

-    type Err = ParseAmountError;

-

-    fn from_str(s: &str) -> Result<Self, Self::Err> {

-        let (currency, amount) = s

-            .trim()

-            .split_once(':')

-            .ok_or(ParseAmountError::FormatAmount)?;

-        if currency.len() > 12 {

-            return Err(ParseAmountError::FormatAmount);

-        }

-        let (value, fraction) = amount.split_once('.').unwrap_or((amount, ""));

-

-        let value: u64 = value.parse().map_err(|_| ParseAmountError::FormatAmount)?;

-        if value > 1 << 52 {

-            return Err(ParseAmountError::FormatAmount);

-        }

-

-        if fraction.len() > 8 {

-            return Err(ParseAmountError::FormatAmount);

-        }

-        let fraction: u32 = if fraction.is_empty() {

-            0

-        } else {

-            fraction

-                .parse::<u32>()

-                .map_err(|_| ParseAmountError::FormatAmount)?

-                * 10_u32.pow((8 - fraction.len()) as u32)

-        };

-

-        Ok(Self {

-            currency: currency.to_string(),

-            value,

-            fraction,

-        })

-    }

-}

-

-impl Display for Amount {

-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

-        f.write_fmt(format_args!(

-            "{}:{}.{:08}",

-            self.currency, self.value, self.fraction

-        ))

-    }

-}

-

-#[test]

-fn test_amount() {

-    const TALER_AMOUNT_FRAC_BASE: u32 = 100000000;

-    // https://git.taler.net/exchange.git/tree/src/util/test_amount.c

-

-    const INVALID_AMOUNTS: [&str; 6] = [

-        "EUR:4a",                                                                     // non-numeric,

-        "EUR:4.4a",                                                                   // non-numeric

-        "EUR:4.a4",                                                                   // non-numeric

-        ":4.a4",                                                                      // no currency

-        "EUR:4.123456789",                                                            // precision to high

-        "EUR:1234567890123456789012345678901234567890123456789012345678901234567890", // value to big

-    ];

-

-    for str in INVALID_AMOUNTS {

-        let amount = Amount::from_str(str);

-        assert!(amount.is_err(), "invalid {} got {:?}", str, amount);

-    }

-

-    let valid_amounts: Vec<(&str, Amount)> = vec![

-        ("EUR:4", Amount::new("EUR", 4, 0)), // without fraction

-        (

-            "eur:0.02",

-            Amount::new("eur", 0, TALER_AMOUNT_FRAC_BASE / 100 * 2),

-        ), // leading zero fraction

-        (

-            " eur:4.12",

-            Amount::new("eur", 4, TALER_AMOUNT_FRAC_BASE / 100 * 12),

-        ), // leading space and fraction

-        (

-            " *LOCAL:4444.1000",

-            Amount::new("*LOCAL", 4444, TALER_AMOUNT_FRAC_BASE / 10),

-        ), // local currency

-    ];

-    for (str, goal) in valid_amounts {

-        let amount = Amount::from_str(str);

-        assert!(amount.is_ok(), "Valid {} got {:?}", str, amount);

-        assert_eq!(

-            *amount.as_ref().unwrap(),

-            goal,

-            "Expected {:?} got {:?} for {}",

-            goal,

-            amount,

-            str

-        );

-        let amount = amount.unwrap();

-        let str = amount.to_string();

-        assert_eq!(amount, Amount::from_str(&str).unwrap(), "{:?}", str);

-    }

-}

-

-#[derive(Debug, thiserror::Error)]

-pub enum ParseBase32Error {

-    #[error("Invalid Crockford’s base32 format")]

-    Format,

-    #[error("Invalid length: expected {0} bytes got {1}")]

-    Length(usize, usize),

-}

-

-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]

-pub struct Base32<const L: usize>([u8; L]);

-

-impl<const L: usize> From<[u8; L]> for Base32<L> {

-    fn from(array: [u8; L]) -> Self {

-        Self(array)

-    }

-}

-

-impl<const L: usize> Deref for Base32<L> {

-    type Target = [u8; L];

-

-    fn deref(&self) -> &Self::Target {

-        &self.0

-    }

-}

-

-impl<const L: usize> FromStr for Base32<L> {

-    type Err = ParseBase32Error;

-

-    fn from_str(s: &str) -> Result<Self, Self::Err> {

-        let bytes =

-            base32::decode(base32::Alphabet::Crockford, s).ok_or(ParseBase32Error::Format)?;

-        let exact: [u8; L] = bytes

-            .try_into()

-            .map_err(|vec: Vec<u8>| ParseBase32Error::Length(L, vec.len()))?;

-        Ok(Self(exact))

-    }

-}

-

-pub fn base32(bytes: &[u8]) -> String {

-    base32::encode(base32::Alphabet::Crockford, bytes)

-}

-

-impl<const L: usize> Display for Base32<L> {

-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

-        f.write_str(&base32(&self.0))

-    }

-}

-

-impl<const L: usize> serde::Serialize for Base32<L> {

-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

-    where

-        S: serde::Serializer,

-    {

-        serializer.serialize_str(&self.to_string())

-    }

-}

-

-impl<'de, const L: usize> Deserialize<'de> for Base32<L> {

-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

-    where

-        D: Deserializer<'de>,

-    {

-        Base32::from_str(&String::deserialize(deserializer)?).map_err(D::Error::custom)

-    }

-}

-

-/// EdDSA and ECDHE public keys always point on Curve25519

-/// and represented  using the standard 256 bits Ed25519 compact format,

-/// converted to Crockford Base32.

-pub type EddsaPublicKey = Base32<32>;

-/// 64-byte hash code

-pub type HashCode = Base32<64>;

-/// 32-bytes hash code

-pub type ShortHashCode = Base32<32>;

+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
+use std::{
+    fmt::Display,
+    num::ParseIntError,
+    ops::Deref,
+    str::FromStr,
+    time::{Duration, SystemTime},
+};
+
+use serde::{de::Error, ser::SerializeStruct, Deserialize, Deserializer};
+use serde_json::Value;
+
+/// <https://docs.taler.net/core/api-common.html#tsref-type-ErrorDetail>
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct ErrorDetail {
+    pub code: i64,
+    pub hint: Option<String>,
+    pub detail: Option<String>,
+    pub parameter: Option<String>,
+    pub path: Option<String>,
+    pub offset: Option<String>,
+    pub index: Option<String>,
+    pub object: Option<String>,
+    pub currency: Option<String>,
+    pub type_expected: Option<String>,
+    pub type_actual: Option<String>,
+}
+
+/// <https://docs.taler.net/core/api-common.html#tsref-type-Timestamp>
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Timestamp {
+    Never,
+    Time(SystemTime),
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+struct TimestampImpl {
+    t_ms: Value,
+}
+
+impl Timestamp {
+    pub fn now() -> Self {
+        Self::Time(SystemTime::now())
+    }
+}
+
+impl<'de> Deserialize<'de> for Timestamp {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let tmp = TimestampImpl::deserialize(deserializer)?;
+        match tmp.t_ms {
+            Value::Number(ms) => {
+                if let Some(since_epoch_ms) = ms.as_u64() {
+                    Ok(Self::Time(
+                        SystemTime::UNIX_EPOCH + Duration::from_millis(since_epoch_ms),
+                    ))
+                } else {
+                    Err(Error::custom("Expected epoch time millis"))
+                }
+            }
+            Value::String(str) if str == "never" => Ok(Self::Never),
+            _ => Err(Error::custom("Expected epoch time millis or 'never'")),
+        }
+    }
+}
+
+impl serde::Serialize for Timestamp {
+    fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut se_struct = se.serialize_struct("Timestamp", 1)?;
+        match self {
+            Timestamp::Never => se_struct.serialize_field("t_ms", "never")?,
+            Timestamp::Time(time) => se_struct.serialize_field(
+                "t_ms",
+                &(time
+                    .duration_since(SystemTime::UNIX_EPOCH)
+                    .unwrap()
+                    .as_secs() as u128
+                    * 1000),
+            )?,
+        };
+
+        se_struct.end()
+    }
+}
+
+impl From<SystemTime> for Timestamp {
+    fn from(time: SystemTime) -> Self {
+        Self::Time(time)
+    }
+}
+
+/// <https://docs.taler.net/core/api-common.html#tsref-type-SafeUint64>
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)]
+pub struct SafeUint64(u64);
+
+#[derive(Debug, thiserror::Error)]
+#[error("{0} unsafe, {0} > (2^53 - 1)")]
+pub struct UnsafeUint64(u64);
+
+impl TryFrom<u64> for SafeUint64 {
+    type Error = UnsafeUint64;
+
+    fn try_from(nb: u64) -> Result<Self, Self::Error> {
+        if nb < (1 << 53) - 1 {
+            Ok(SafeUint64(nb))
+        } else {
+            Err(UnsafeUint64(nb))
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for SafeUint64 {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        SafeUint64::try_from(u64::deserialize(deserializer)?).map_err(D::Error::custom)
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ParseSafeUint64Error {
+    #[error(transparent)]
+    Unsafe(#[from] UnsafeUint64),
+    #[error(transparent)]
+    Format(#[from] ParseIntError),
+}
+
+/// <https://docs.taler.net/core/api-common.html#tsref-type-Amount>
+#[derive(
+    Debug, Clone, PartialEq, Eq, serde_with::DeserializeFromStr, serde_with::SerializeDisplay,
+)]
+pub struct Amount {
+    pub currency: String,
+    pub value: u64,
+    pub fraction: u32,
+}
+
+impl Amount {
+    pub fn new(currency: impl Into<String>, value: u64, fraction: u32) -> Self {
+        Self {
+            currency: currency.into(),
+            value,
+            fraction,
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ParseAmountError {
+    #[error("Invalid amount format")]
+    FormatAmount,
+    #[error("Amount overflow")]
+    AmountOverflow,
+    #[error(transparent)]
+    Format(#[from] ParseIntError),
+}
+
+impl FromStr for Amount {
+    type Err = ParseAmountError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (currency, amount) = s
+            .trim()
+            .split_once(':')
+            .ok_or(ParseAmountError::FormatAmount)?;
+        if currency.len() > 12 {
+            return Err(ParseAmountError::FormatAmount);
+        }
+        let (value, fraction) = amount.split_once('.').unwrap_or((amount, ""));
+
+        let value: u64 = value.parse().map_err(|_| ParseAmountError::FormatAmount)?;
+        if value > 1 << 52 {
+            return Err(ParseAmountError::FormatAmount);
+        }
+
+        if fraction.len() > 8 {
+            return Err(ParseAmountError::FormatAmount);
+        }
+        let fraction: u32 = if fraction.is_empty() {
+            0
+        } else {
+            fraction
+                .parse::<u32>()
+                .map_err(|_| ParseAmountError::FormatAmount)?
+                * 10_u32.pow((8 - fraction.len()) as u32)
+        };
+
+        Ok(Self {
+            currency: currency.to_string(),
+            value,
+            fraction,
+        })
+    }
+}
+
+impl Display for Amount {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!(
+            "{}:{}.{:08}",
+            self.currency, self.value, self.fraction
+        ))
+    }
+}
+
+#[test]
+fn test_amount() {
+    const TALER_AMOUNT_FRAC_BASE: u32 = 100000000;
+    // https://git.taler.net/exchange.git/tree/src/util/test_amount.c
+
+    const INVALID_AMOUNTS: [&str; 6] = [
+        "EUR:4a",                                                                     // non-numeric,
+        "EUR:4.4a",                                                                   // non-numeric
+        "EUR:4.a4",                                                                   // non-numeric
+        ":4.a4",                                                                      // no currency
+        "EUR:4.123456789", // precision to high
+        "EUR:1234567890123456789012345678901234567890123456789012345678901234567890", // value to big
+    ];
+
+    for str in INVALID_AMOUNTS {
+        let amount = Amount::from_str(str);
+        assert!(amount.is_err(), "invalid {} got {:?}", str, amount);
+    }
+
+    let valid_amounts: Vec<(&str, Amount)> = vec![
+        ("EUR:4", Amount::new("EUR", 4, 0)), // without fraction
+        (
+            "eur:0.02",
+            Amount::new("eur", 0, TALER_AMOUNT_FRAC_BASE / 100 * 2),
+        ), // leading zero fraction
+        (
+            " eur:4.12",
+            Amount::new("eur", 4, TALER_AMOUNT_FRAC_BASE / 100 * 12),
+        ), // leading space and fraction
+        (
+            " *LOCAL:4444.1000",
+            Amount::new("*LOCAL", 4444, TALER_AMOUNT_FRAC_BASE / 10),
+        ), // local currency
+    ];
+    for (str, goal) in valid_amounts {
+        let amount = Amount::from_str(str);
+        assert!(amount.is_ok(), "Valid {} got {:?}", str, amount);
+        assert_eq!(
+            *amount.as_ref().unwrap(),
+            goal,
+            "Expected {:?} got {:?} for {}",
+            goal,
+            amount,
+            str
+        );
+        let amount = amount.unwrap();
+        let str = amount.to_string();
+        assert_eq!(amount, Amount::from_str(&str).unwrap(), "{:?}", str);
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ParseBase32Error {
+    #[error("Invalid Crockford’s base32 format")]
+    Format,
+    #[error("Invalid length: expected {0} bytes got {1}")]
+    Length(usize, usize),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Base32<const L: usize>([u8; L]);
+
+impl<const L: usize> From<[u8; L]> for Base32<L> {
+    fn from(array: [u8; L]) -> Self {
+        Self(array)
+    }
+}
+
+impl<const L: usize> Deref for Base32<L> {
+    type Target = [u8; L];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<const L: usize> FromStr for Base32<L> {
+    type Err = ParseBase32Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let bytes =
+            base32::decode(base32::Alphabet::Crockford, s).ok_or(ParseBase32Error::Format)?;
+        let exact: [u8; L] = bytes
+            .try_into()
+            .map_err(|vec: Vec<u8>| ParseBase32Error::Length(L, vec.len()))?;
+        Ok(Self(exact))
+    }
+}
+
+pub fn base32(bytes: &[u8]) -> String {
+    base32::encode(base32::Alphabet::Crockford, bytes)
+}
+
+impl<const L: usize> Display for Base32<L> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&base32(&self.0))
+    }
+}
+
+impl<const L: usize> serde::Serialize for Base32<L> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl<'de, const L: usize> Deserialize<'de> for Base32<L> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Base32::from_str(&String::deserialize(deserializer)?).map_err(D::Error::custom)
+    }
+}
+
+/// EdDSA and ECDHE public keys always point on Curve25519
+/// and represented  using the standard 256 bits Ed25519 compact format,
+/// converted to Crockford Base32.
+pub type EddsaPublicKey = Base32<32>;
+/// 64-byte hash code
+pub type HashCode = Base32<64>;
+/// 32-bytes hash code
+pub type ShortHashCode = Base32<32>;
diff --git a/taler-common/src/api_wire.rs b/taler-common/src/api_wire.rs
index 33a4356..b36ec75 100644
--- a/taler-common/src/api_wire.rs
+++ b/taler-common/src/api_wire.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use url::Url;

 

 use crate::api_common::{Amount, EddsaPublicKey, HashCode, SafeUint64, ShortHashCode, Timestamp};

diff --git a/taler-common/src/config.rs b/taler-common/src/config.rs
index e700d17..5fd1f2a 100644
--- a/taler-common/src/config.rs
+++ b/taler-common/src/config.rs
@@ -1,3 +1,18 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 use ini::{Ini, Properties};
 use std::{
     path::{Path, PathBuf},
diff --git a/taler-common/src/error_codes.rs b/taler-common/src/error_codes.rs
index 38b9212..4959fda 100644
--- a/taler-common/src/error_codes.rs
+++ b/taler-common/src/error_codes.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 /// Error codes used by GNU Taler

 #[derive(Debug, Copy, Clone, PartialEq, Eq)]

 #[allow(non_camel_case_types, dead_code)]

diff --git a/taler-common/src/lib.rs b/taler-common/src/lib.rs
index 0ce4f1f..95c143a 100644
--- a/taler-common/src/lib.rs
+++ b/taler-common/src/lib.rs
@@ -1,7 +1,22 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
 pub use url;
 
 pub mod api_common;
 pub mod api_wire;
+pub mod config;
 pub mod error_codes;
 pub mod log;
-pub mod config;
\ No newline at end of file
diff --git a/taler-common/src/log.rs b/taler-common/src/log.rs
index f874270..4c67779 100644
--- a/taler-common/src/log.rs
+++ b/taler-common/src/log.rs
@@ -1,31 +1,46 @@
-use flexi_logger::{DeferredNow, LogSpecification, Record};

-use time::{format_description::FormatItem, macros::format_description};

-pub use log;

-

-const TIME_FORMAT: &[FormatItem<'static>] = format_description!(

-    "[year]-[month]-[day]T[hour]:[minute]:[second].[subsecond digits:6][offset_hour sign:mandatory][offset_minute]"

-);

-

-fn custom_format(

-    w: &mut dyn std::io::Write,

-    now: &mut DeferredNow,

-    record: &Record,

-) -> Result<(), std::io::Error> {

-    let path = record.module_path().unwrap_or("");

-    write!(

-        w,

-        "{} {} {} {}",

-        now.format(TIME_FORMAT),

-        path.split_once(':').map(|s| s.0).unwrap_or(path),

-        record.level(),

-        &record.args()

-    )

-}

-

-pub fn init() {

-    flexi_logger::Logger::with(LogSpecification::info())

-        .log_to_stderr()

-        .format(custom_format)

-        .start()

-        .unwrap();

-}

+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
+use flexi_logger::{DeferredNow, LogSpecification, Record};
+pub use log;
+use time::{format_description::FormatItem, macros::format_description};
+
+const TIME_FORMAT: &[FormatItem<'static>] = format_description!(
+    "[year]-[month]-[day]T[hour]:[minute]:[second].[subsecond digits:6][offset_hour sign:mandatory][offset_minute]"
+);
+
+fn custom_format(
+    w: &mut dyn std::io::Write,
+    now: &mut DeferredNow,
+    record: &Record,
+) -> Result<(), std::io::Error> {
+    let path = record.module_path().unwrap_or("");
+    write!(
+        w,
+        "{} {} {} {}",
+        now.format(TIME_FORMAT),
+        path.split_once(':').map(|s| s.0).unwrap_or(path),
+        record.level(),
+        &record.args()
+    )
+}
+
+pub fn init() {
+    flexi_logger::Logger::with(LogSpecification::info())
+        .log_to_stderr()
+        .format(custom_format)
+        .start()
+        .unwrap();
+}
diff --git a/uri-pack/Cargo.toml b/uri-pack/Cargo.toml
index e9d801a..b281c59 100644
--- a/uri-pack/Cargo.toml
+++ b/uri-pack/Cargo.toml
@@ -2,6 +2,7 @@
 name = "uri-pack"

 version = "0.1.0"

 edition = "2021"

+license = "AGPL-3.0-or-later"

 

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 

diff --git a/uri-pack/benches/pack.rs b/uri-pack/benches/pack.rs
index bc8d5b6..6b7a45a 100644
--- a/uri-pack/benches/pack.rs
+++ b/uri-pack/benches/pack.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};

 use uri_pack::{pack_uri, unpack_uri};

 

diff --git a/uri-pack/src/lib.rs b/uri-pack/src/lib.rs
index 674f801..78919b5 100644
--- a/uri-pack/src/lib.rs
+++ b/uri-pack/src/lib.rs
@@ -1,263 +1,278 @@
-//! 

-//! uri-pack is an efficient binary format for URI

-//! 

-//! ## Format

-//! 

-//! Most commonly used characters (a-z . / - %) are encoded using 5b, remaining 

-//! ascii characters are encoded using 11b.If more than half the characters in an 

-//! uri are encoded with 5b, the encoded size is smaller than a simple ascii 

-//! format.

-//! 

-//! On the majestic_million database, 98.77% of the domain name where smaller, 

-//! going from an average of 14b to an average of 10b.

-//! 

-//! ## Usage

-//! 

-//! ``` rust

-//! use uri_pack::{pack_uri, unpack_uri};

-//! 

-//! let domain = "http://example.com/static_file/image.png";

-//! let encoded = pack_uri(domain).unwrap();

-//! let decoded = unpack_uri(&encoded).unwrap();

-//! assert_eq!(domain, decoded);

-//! ```

-//! 

-

-/// Pack an URI ascii char

-/// Panic if char not supported

-fn pack_ascii(c: u8) -> u8 {

-    [

-        67, 68, 69, 70, 29, 71, 72, 73, 74, 75, 76, 77, 28, 26, 27, 57, 58, 59, 60, 61, 62, 63, 64,

-        65, 66, 78, 79, 80, 81, 82, 83, 84, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,

-        45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 85, 86, 87, 88, 30, 89, 0, 1, 2, 3, 4, 5,

-        6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 90, 91, 92, 93,

-    ][(c - b'!') as usize]

-}

-

-/// Unpack an URI ascii char

-/// Panic if char not supported

-fn unpack_ascii(c: u8) -> u8 {

-    [

-        b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',

-        b'p', b'q', b'r', b's', b't', b'u', b'v', b'w', b'x', b'y', b'z', b'.', b'/', b'-', b'%',

-        b'_', b'A', b'B', b'C', b'D', b'E', b'F', b'G', b'H', b'I', b'J', b'K', b'L', b'M', b'N',

-        b'O', b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W', b'X', b'Y', b'Z', b'0', b'1', b'2',

-        b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'!', b'"', b'#', b'$', b'&', b'\'', b'(', b')',

-        b'*', b'+', b',', b':', b';', b'<', b'=', b'>', b'?', b'@', b'[', b'\\', b']', b'^', b'`',

-        b'{', b'|', b'}', b'~',

-    ][c as usize]

-}

-

-/// Check if an ascii char is supported by the encoding

-fn supported_ascii(c: &u8) -> bool {

-    (b'!'..=b'~').contains(c)

-}

-

-/// Extended packing limit

-const EXTENDED: u8 = 30;

-/// EOF u5 encoding

-const TERMINATOR: u8 = 31;

-

-#[derive(Debug, Clone, Copy, thiserror::Error)]

-pub enum EncodeErr {

-    #[error("{0} is not a valid uri char")]

-    UnsupportedChar(u8),

-}

-

-#[derive(Debug, Clone, Copy, thiserror::Error)]

-pub enum DecodeErr {

-    #[error("An extended encoded char have been passed as an simple one")]

-    ExpectedExtended,

-    #[error("{0} is not an simple encoded char")]

-    UnexpectedSimpleChar(u8),

-    #[error("{0} is not an extended encoded char")]

-    UnexpectedExtendedChar(u8),

-    #[error("Missing bits")]

-    UnexpectedEOF,

-}

-

-/// Pack an uri string into an optimized binary format

-pub fn pack_uri(uri: &str) -> Result<Vec<u8>, EncodeErr> {

-    let len = uri.as_bytes().len();

-    let mut vec = Vec::with_capacity(len);

-

-    if let Some(char) = uri.as_bytes().iter().find(|c| !supported_ascii(c)) {

-        return Err(EncodeErr::UnsupportedChar(*char));

-    }

-

-    // Holds [buff_bits] pending bits beginning from the most significant bits

-    let (mut buff, mut buff_bits) = (0u8, 0u8);

-

-    // Write [nb_bits] less significant bits from [nb] to [buff]

-    let mut write_bits = |nb: u8, mut nb_bits: u8| {

-        while nb_bits > 0 {

-            // Amount of bits we can write in buffer

-            let writable = (8 - buff_bits).min(nb_bits);

-            // Remove non writable bits

-            let rmv_right = nb >> (nb_bits - writable);

-            let rmv_left = rmv_right << (8 - writable);

-            // Align remaining bits with buff blank bits

-            let align = rmv_left >> buff_bits;

-

-            // Write bits in buffer

-            buff |= align;

-            buff_bits += writable;

-            nb_bits -= writable;

-

-            // Store buffer if full

-            if buff_bits == 8 {

-                vec.push(buff);

-                buff = 0;

-                buff_bits = 0;

-            }

-        }

-    };

-

-    for c in uri.bytes() {

-        let nb = pack_ascii(c);

-        if nb < EXTENDED {

-            write_bits(nb, 5)

-        } else {

-            write_bits(EXTENDED, 5);

-            write_bits(nb - EXTENDED, 6);

-        }

-    }

-    write_bits(TERMINATOR, 5);

-

-    // Push pending buffer if not empty

-    if buff_bits > 0 {

-        vec.push(buff);

-    }

-

-    return Ok(vec);

-}

-

-/// Unpack an uri string from its optimized binary format

-pub fn unpack_uri(bytes: &[u8]) -> Result<String, DecodeErr> {

-    let mut buf = String::with_capacity(bytes.len());

-    let mut iter = bytes.iter();

-

-    // Holds [buff_bits] pending bits beginning from the most significant bits

-    let (mut buff, mut buff_bits) = (0u8, 0u8);

-

-    // Write [nb_bits] less significant bits from [buff] to [nb]

-    let mut read_nb = |mut nb_bits: u8| -> Result<u8, DecodeErr> {

-        let mut nb = 0;

-        while nb_bits > 0 {

-            // Load buff if empty

-            if buff_bits == 0 {

-                buff = *iter.next().ok_or(DecodeErr::UnexpectedEOF)?;

-                buff_bits = 8;

-            }

-            // Amount of bits we can read from buff

-            let readable = buff_bits.min(nb_bits);

-            // Remove non writable bits

-            let rmv_left = buff << (8 - buff_bits);

-            // Align remaining bits with nb blank bits

-            let align = rmv_left >> (8 - readable);

-            // Read bits from buff

-            nb = (nb << readable) | align;

-            buff_bits -= readable;

-            nb_bits -= readable;

-        }

-        return Ok(nb);

-    };

-

-    loop {

-        let encoded = match read_nb(5)? {

-            TERMINATOR => break,

-            EXTENDED => read_nb(6)? + EXTENDED,

-            nb => nb,

-        };

-        buf.push(unpack_ascii(encoded) as char);

-    }

-

-    return Ok(buf);

-}

-

-#[cfg(test)]

-#[macro_use(quickcheck)]

-extern crate quickcheck_macros;

-

-#[cfg(test)]

-mod test {

-    use std::str::FromStr;

-

-    use serde_json::Value;

-

-    use crate::{pack_ascii, pack_uri, supported_ascii, unpack_ascii, unpack_uri, EXTENDED};

-

-    /// Ascii char that can be packed into 5 bits

-    const PACKED: [u8; 30] = [

-        b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',

-        b'p', b'q', b'r', b's', b't', b'u', b'v', b'w', b'x', b'y', b'z', b'.', b'/', b'-', b'%',

-    ];

-

-    #[test]

-    /// Check support every packable ascii character is packed

-    fn packed() {

-        for c in PACKED {

-            assert!(pack_ascii(c) < EXTENDED);

-        }

-    }

-

-    #[test]

-    /// Check support every ascii graphic character and space

-    fn supported() {

-        for c in (0..=255u8).filter(supported_ascii) {

-            assert_eq!(unpack_ascii(pack_ascii(c)), c);

-        }

-    }

-

-    #[test]

-    /// Check error on unsupported char

-    fn unsupported() {

-        for c in (0..=255u8).filter(|c| !supported_ascii(c)) {

-            let string = String::from(c as char);

-            assert!(pack_uri(&string).is_err());

-        }

-    }

-

-    #[test]

-    fn url_simple() {

-        let mut majestic =

-            csv::Reader::from_reader(include_str!("majestic_million.csv").as_bytes());

-        for record in majestic.records() {

-            let domain = &record.unwrap()[2];

-            let encoded = pack_uri(domain).unwrap();

-            let decoded = unpack_uri(&encoded).unwrap();

-            assert_eq!(domain, decoded);

-        }

-    }

-

-    #[test]

-    fn url_complex() {

-        let mut json = Value::from_str(include_str!("urltestdata.json"))

-            .expect("JSON parse error in urltestdata.json");

-        for entry in json.as_array_mut().unwrap() {

-            if entry.is_string() {

-                continue; // ignore comments

-            }

-

-            let href = entry.get("href").and_then(|it| it.as_str()).unwrap_or("");

-            if href.chars().any(|c| !c.is_ascii_graphic() || c != ' ') {

-                continue; // extended ascii

-            }

-            let encoded = pack_uri(&href).expect(&format!("Failed to encode {}", &href));

-            let decoded =

-                unpack_uri(&encoded).expect(&format!("Failed to decode encoded {}", &href));

-            assert_eq!(href, decoded);

-        }

-    }

-

-    #[quickcheck]

-    fn fuzz(input: String) -> bool {

-        if input.as_bytes().iter().all(supported_ascii) {

-            let packed = pack_uri(&input).unwrap();

-            let unpacked = unpack_uri(&packed).unwrap();

-            input == unpacked

-        } else {

-            true

-        }

-    }

-}

+/*
+  This file is part of TALER
+  Copyright (C) 2022 Taler Systems SA
+
+  TALER 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, or (at your option) any later version.
+
+  TALER 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
+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+*/
+//!
+//! uri-pack is an efficient binary format for URI
+//!
+//! ## Format
+//!
+//! Most commonly used characters (a-z . / - %) are encoded using 5b, remaining
+//! ascii characters are encoded using 11b.If more than half the characters in an
+//! uri are encoded with 5b, the encoded size is smaller than a simple ascii
+//! format.
+//!
+//! On the majestic_million database, 98.77% of the domain name where smaller,
+//! going from an average of 14b to an average of 10b.
+//!
+//! ## Usage
+//!
+//! ``` rust
+//! use uri_pack::{pack_uri, unpack_uri};
+//!
+//! let domain = "http://example.com/static_file/image.png";
+//! let encoded = pack_uri(domain).unwrap();
+//! let decoded = unpack_uri(&encoded).unwrap();
+//! assert_eq!(domain, decoded);
+//! ```
+//!
+
+/// Pack an URI ascii char
+/// Panic if char not supported
+fn pack_ascii(c: u8) -> u8 {
+    [
+        67, 68, 69, 70, 29, 71, 72, 73, 74, 75, 76, 77, 28, 26, 27, 57, 58, 59, 60, 61, 62, 63, 64,
+        65, 66, 78, 79, 80, 81, 82, 83, 84, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
+        45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 85, 86, 87, 88, 30, 89, 0, 1, 2, 3, 4, 5,
+        6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 90, 91, 92, 93,
+    ][(c - b'!') as usize]
+}
+
+/// Unpack an URI ascii char
+/// Panic if char not supported
+fn unpack_ascii(c: u8) -> u8 {
+    [
+        b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
+        b'p', b'q', b'r', b's', b't', b'u', b'v', b'w', b'x', b'y', b'z', b'.', b'/', b'-', b'%',
+        b'_', b'A', b'B', b'C', b'D', b'E', b'F', b'G', b'H', b'I', b'J', b'K', b'L', b'M', b'N',
+        b'O', b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W', b'X', b'Y', b'Z', b'0', b'1', b'2',
+        b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'!', b'"', b'#', b'$', b'&', b'\'', b'(', b')',
+        b'*', b'+', b',', b':', b';', b'<', b'=', b'>', b'?', b'@', b'[', b'\\', b']', b'^', b'`',
+        b'{', b'|', b'}', b'~',
+    ][c as usize]
+}
+
+/// Check if an ascii char is supported by the encoding
+fn supported_ascii(c: &u8) -> bool {
+    (b'!'..=b'~').contains(c)
+}
+
+/// Extended packing limit
+const EXTENDED: u8 = 30;
+/// EOF u5 encoding
+const TERMINATOR: u8 = 31;
+
+#[derive(Debug, Clone, Copy, thiserror::Error)]
+pub enum EncodeErr {
+    #[error("{0} is not a valid uri char")]
+    UnsupportedChar(u8),
+}
+
+#[derive(Debug, Clone, Copy, thiserror::Error)]
+pub enum DecodeErr {
+    #[error("An extended encoded char have been passed as an simple one")]
+    ExpectedExtended,
+    #[error("{0} is not an simple encoded char")]
+    UnexpectedSimpleChar(u8),
+    #[error("{0} is not an extended encoded char")]
+    UnexpectedExtendedChar(u8),
+    #[error("Missing bits")]
+    UnexpectedEOF,
+}
+
+/// Pack an uri string into an optimized binary format
+pub fn pack_uri(uri: &str) -> Result<Vec<u8>, EncodeErr> {
+    let len = uri.as_bytes().len();
+    let mut vec = Vec::with_capacity(len);
+
+    if let Some(char) = uri.as_bytes().iter().find(|c| !supported_ascii(c)) {
+        return Err(EncodeErr::UnsupportedChar(*char));
+    }
+
+    // Holds [buff_bits] pending bits beginning from the most significant bits
+    let (mut buff, mut buff_bits) = (0u8, 0u8);
+
+    // Write [nb_bits] less significant bits from [nb] to [buff]
+    let mut write_bits = |nb: u8, mut nb_bits: u8| {
+        while nb_bits > 0 {
+            // Amount of bits we can write in buffer
+            let writable = (8 - buff_bits).min(nb_bits);
+            // Remove non writable bits
+            let rmv_right = nb >> (nb_bits - writable);
+            let rmv_left = rmv_right << (8 - writable);
+            // Align remaining bits with buff blank bits
+            let align = rmv_left >> buff_bits;
+
+            // Write bits in buffer
+            buff |= align;
+            buff_bits += writable;
+            nb_bits -= writable;
+
+            // Store buffer if full
+            if buff_bits == 8 {
+                vec.push(buff);
+                buff = 0;
+                buff_bits = 0;
+            }
+        }
+    };
+
+    for c in uri.bytes() {
+        let nb = pack_ascii(c);
+        if nb < EXTENDED {
+            write_bits(nb, 5)
+        } else {
+            write_bits(EXTENDED, 5);
+            write_bits(nb - EXTENDED, 6);
+        }
+    }
+    write_bits(TERMINATOR, 5);
+
+    // Push pending buffer if not empty
+    if buff_bits > 0 {
+        vec.push(buff);
+    }
+
+    return Ok(vec);
+}
+
+/// Unpack an uri string from its optimized binary format
+pub fn unpack_uri(bytes: &[u8]) -> Result<String, DecodeErr> {
+    let mut buf = String::with_capacity(bytes.len());
+    let mut iter = bytes.iter();
+
+    // Holds [buff_bits] pending bits beginning from the most significant bits
+    let (mut buff, mut buff_bits) = (0u8, 0u8);
+
+    // Write [nb_bits] less significant bits from [buff] to [nb]
+    let mut read_nb = |mut nb_bits: u8| -> Result<u8, DecodeErr> {
+        let mut nb = 0;
+        while nb_bits > 0 {
+            // Load buff if empty
+            if buff_bits == 0 {
+                buff = *iter.next().ok_or(DecodeErr::UnexpectedEOF)?;
+                buff_bits = 8;
+            }
+            // Amount of bits we can read from buff
+            let readable = buff_bits.min(nb_bits);
+            // Remove non writable bits
+            let rmv_left = buff << (8 - buff_bits);
+            // Align remaining bits with nb blank bits
+            let align = rmv_left >> (8 - readable);
+            // Read bits from buff
+            nb = (nb << readable) | align;
+            buff_bits -= readable;
+            nb_bits -= readable;
+        }
+        return Ok(nb);
+    };
+
+    loop {
+        let encoded = match read_nb(5)? {
+            TERMINATOR => break,
+            EXTENDED => read_nb(6)? + EXTENDED,
+            nb => nb,
+        };
+        buf.push(unpack_ascii(encoded) as char);
+    }
+
+    return Ok(buf);
+}
+
+#[cfg(test)]
+#[macro_use(quickcheck)]
+extern crate quickcheck_macros;
+
+#[cfg(test)]
+mod test {
+    use std::str::FromStr;
+
+    use serde_json::Value;
+
+    use crate::{pack_ascii, pack_uri, supported_ascii, unpack_ascii, unpack_uri, EXTENDED};
+
+    /// Ascii char that can be packed into 5 bits
+    const PACKED: [u8; 30] = [
+        b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',
+        b'p', b'q', b'r', b's', b't', b'u', b'v', b'w', b'x', b'y', b'z', b'.', b'/', b'-', b'%',
+    ];
+
+    #[test]
+    /// Check support every packable ascii character is packed
+    fn packed() {
+        for c in PACKED {
+            assert!(pack_ascii(c) < EXTENDED);
+        }
+    }
+
+    #[test]
+    /// Check support every ascii graphic character and space
+    fn supported() {
+        for c in (0..=255u8).filter(supported_ascii) {
+            assert_eq!(unpack_ascii(pack_ascii(c)), c);
+        }
+    }
+
+    #[test]
+    /// Check error on unsupported char
+    fn unsupported() {
+        for c in (0..=255u8).filter(|c| !supported_ascii(c)) {
+            let string = String::from(c as char);
+            assert!(pack_uri(&string).is_err());
+        }
+    }
+
+    #[test]
+    fn url_simple() {
+        let mut majestic =
+            csv::Reader::from_reader(include_str!("majestic_million.csv").as_bytes());
+        for record in majestic.records() {
+            let domain = &record.unwrap()[2];
+            let encoded = pack_uri(domain).unwrap();
+            let decoded = unpack_uri(&encoded).unwrap();
+            assert_eq!(domain, decoded);
+        }
+    }
+
+    #[test]
+    fn url_complex() {
+        let mut json = Value::from_str(include_str!("urltestdata.json"))
+            .expect("JSON parse error in urltestdata.json");
+        for entry in json.as_array_mut().unwrap() {
+            if entry.is_string() {
+                continue; // ignore comments
+            }
+
+            let href = entry.get("href").and_then(|it| it.as_str()).unwrap_or("");
+            if href.chars().any(|c| !c.is_ascii_graphic() || c != ' ') {
+                continue; // extended ascii
+            }
+            let encoded = pack_uri(&href).expect(&format!("Failed to encode {}", &href));
+            let decoded =
+                unpack_uri(&encoded).expect(&format!("Failed to decode encoded {}", &href));
+            assert_eq!(href, decoded);
+        }
+    }
+
+    #[quickcheck]
+    fn fuzz(input: String) -> bool {
+        if input.as_bytes().iter().all(supported_ascii) {
+            let packed = pack_uri(&input).unwrap();
+            let unpacked = unpack_uri(&packed).unwrap();
+            input == unpacked
+        } else {
+            true
+        }
+    }
+}
diff --git a/uri-pack/src/main.rs b/uri-pack/src/main.rs
index 955e2af..1b8dcc6 100644
--- a/uri-pack/src/main.rs
+++ b/uri-pack/src/main.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use std::cmp::Ordering;

 

 use uri_pack::pack_uri;

diff --git a/wire-gateway/Cargo.toml b/wire-gateway/Cargo.toml
index 2d32e09..0fc4c86 100644
--- a/wire-gateway/Cargo.toml
+++ b/wire-gateway/Cargo.toml
@@ -2,6 +2,7 @@
 name = "wire-gateway"

 version = "0.1.0"

 edition = "2021"

+license = "AGPL-3.0-or-later"

 

 [features]

 # Enable test admin endpoint

diff --git a/wire-gateway/src/error.rs b/wire-gateway/src/error.rs
index 32582fe..34d10d3 100644
--- a/wire-gateway/src/error.rs
+++ b/wire-gateway/src/error.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use hyper::{header, Body, Response, StatusCode};

 use taler_common::{api_common::ErrorDetail, error_codes::ErrorCode};

 

diff --git a/wire-gateway/src/json.rs b/wire-gateway/src/json.rs
index 78139f1..4e97c3f 100644
--- a/wire-gateway/src/json.rs
+++ b/wire-gateway/src/json.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use hyper::{body::HttpBody, header, http::request::Parts, Body, Response, StatusCode};

 use miniz_oxide::inflate::TINFLStatus;

 

diff --git a/wire-gateway/src/main.rs b/wire-gateway/src/main.rs
index b37c89c..1a979ff 100644
--- a/wire-gateway/src/main.rs
+++ b/wire-gateway/src/main.rs
@@ -1,3 +1,18 @@
+/*

+  This file is part of TALER

+  Copyright (C) 2022 Taler Systems SA

+

+  TALER 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, or (at your option) any later version.

+

+  TALER 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

+  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>

+*/

 use deadpool_postgres::{Pool, Runtime};

 use error::{CatchResult, ServerError};

 use hyper::{