commit 099cd806703e055f4f11de395d6723f8bfaa0a44
Author: Swrup <swrup@protonmail.com>
Date:   Sat Sep 13 15:56:19 2025 +0200

    init

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..94938f7e
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+_build
+
+# default output files of offline-tool
+response.json
+request.json
diff --git a/.ocamlformat b/.ocamlformat
new file mode 100644
index 00000000..43b12fc0
--- /dev/null
+++ b/.ocamlformat
@@ -0,0 +1,15 @@
+version=0.28.1
+exp-grouping=preserve
+type-decl=sparse
+break-infix=fit-or-vertical
+break-collection-expressions=fit-or-vertical
+break-sequences=false
+break-infix-before-func=false
+dock-collection-brackets=true
+break-separators=after
+field-space=tight
+if-then-else=compact
+break-sequences=false
+sequence-blank-line=compact
+exp-grouping=preserve
+sequence-blank-line=preserve-one
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..be3f7b28
--- /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/data/assets/default.config b/data/assets/default.config
new file mode 100644
index 00000000..ea32f28a
--- /dev/null
+++ b/data/assets/default.config
@@ -0,0 +1,73 @@
+[currency-EUR]
+enabled= YES
+code= EUR
+name= euro
+fractional_input_digits= 2
+fractional_normal_digits= 2
+fractional_trailing_zero_digits= 2
+alt_unit_names= "{"0":"€","3":"k€"}"
+
+[exchange]
+currency = EUR
+currency_round_unit = EUR:0.01
+db = postgres
+attribute_encryption_key = "deadbeef"
+port = 3434
+bind_to = localhost
+master_public_key = "SJ0NYND22VQP3MP7FM754RDX8HCKVWAXTHY9SQNBTPRJZ2SPM2S0===="
+stefan_abs = EUR:0.00
+stefan_log = EUR:0.00
+stefan_lin = 0.00
+aggregator_idle_sleep_interval = "1 hour"
+closer_idle_sleep_interval = "1 hour"
+transfer_idle_sleep_interval = "1 hour"
+wirewatch_idle_sleep_interval = "1 hour"
+signkey_legal_duration = "1 year"
+max_keys_caching = "4 weeks"
+enable_kyc = NO
+terms_etag = "0"
+privacy_etag = "0"
+
+[exchangedb]
+idle_reserve_expiration_time = "1 year 2 weeks 3 hours 4 minutes 5 seconds"
+legal_reserve_expiration_time = "1 year"
+aggregator_shift = "1 year"
+max_aml_program_runtime = "1 year"
+default_purse_limit = 9999
+
+[exchangedb-postgres]
+config = "pgx://mte:hunter2@localhost:5432/taler-exchange"
+
+[taler-exchange-secmod-rsa]
+lookahead_sign = "1 year"
+overlap_duration = "1 year"
+
+[taler-exchange-secmod-eddsa]
+lookahead_sign = "1 year"
+overlap_duration = "1 year"
+
+[coin_kudo_1]
+value= EUR:0.01
+duration_withdraw= "1 year"
+duration_spend= "1 year"
+duration_legal= "1 year"
+fee_withdraw= EUR:0.00
+fee_deposit= EUR:0.00
+fee_refresh= EUR:0.00
+fee_refund= EUR:0.00
+cipher= RSA
+rsa_keysize= 2048
+age_restricted= NO
+
+[coin_kudo_2]
+value= EUR:0.02
+duration_withdraw= "1 year"
+duration_spend= "1 year"
+duration_legal= "1 year"
+fee_withdraw= EUR:0.00
+fee_deposit= EUR:0.00
+fee_refresh= EUR:0.00
+fee_refund= EUR:0.00
+cipher= RSA
+rsa_keysize= 2048
+age_restricted= NO
diff --git a/data/assets/privacy/en/0.md b/data/assets/privacy/en/0.md
new file mode 100644
index 00000000..419e12ef
--- /dev/null
+++ b/data/assets/privacy/en/0.md
@@ -0,0 +1 @@
+# TODO dummy ToS
diff --git a/data/assets/privacy/en/0.txt b/data/assets/privacy/en/0.txt
new file mode 100644
index 00000000..419e12ef
--- /dev/null
+++ b/data/assets/privacy/en/0.txt
@@ -0,0 +1 @@
+# TODO dummy ToS
diff --git a/data/assets/terms/en/0.md b/data/assets/terms/en/0.md
new file mode 100644
index 00000000..419e12ef
--- /dev/null
+++ b/data/assets/terms/en/0.md
@@ -0,0 +1 @@
+# TODO dummy ToS
diff --git a/data/assets/terms/en/0.txt b/data/assets/terms/en/0.txt
new file mode 100644
index 00000000..419e12ef
--- /dev/null
+++ b/data/assets/terms/en/0.txt
@@ -0,0 +1 @@
+# TODO dummy ToS
diff --git a/data/master_offline_private_key b/data/master_offline_private_key
new file mode 100644
index 00000000..739df007
Binary files /dev/null and b/data/master_offline_private_key differ
diff --git a/data/secmod_denom/.gitkeep b/data/secmod_denom/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/data/secmod_signkey/.gitkeep b/data/secmod_signkey/.gitkeep
new file mode 100644
index 00000000..e69de29b
diff --git a/dune-project b/dune-project
new file mode 100644
index 00000000..5bd4e1f1
--- /dev/null
+++ b/dune-project
@@ -0,0 +1,46 @@
+(lang dune 3.20)
+
+(name mte)
+
+(generate_opam_files true)
+
+; (source
+; (github username/reponame))
+
+(authors "Olivier Pierre <swrup@protonmail.com>")
+
+(maintainers "Olivier Pierre <swrup@protonmail.com>")
+
+(license AGPL-3.0-only)
+
+; (documentation https://url/to/documentation)
+
+(package
+ (name mte)
+ (synopsis "MTE - the MirageOS Taler Exchange")
+ (description "A GNU Taler exchange implementation with the unikernel framework MirageOS")
+ (tags
+  ("GNU Taler" MirageOS unikernel OCaml crypto))
+ (depends
+   (ocaml (>= 5.3))
+   base32
+   caqti
+   caqti-miou
+   caqti-driver-pgx
+   crunch
+   vif
+   jsont
+   cohttp
+   fmt
+   bin
+   angstrom
+   zarith
+   mirage-crypto
+   digestif
+   duration
+   jsont
+   cohttp
+   ptime
+   logs
+  (ocamlformat :with-dev-setup)
+   ))
diff --git a/include/dune b/include/dune
new file mode 100644
index 00000000..3418869c
--- /dev/null
+++ b/include/dune
@@ -0,0 +1,5 @@
+(library
+ (name include)
+ ; (wrapped false)
+ (modules taler_signatures)
+ (libraries))
diff --git a/include/taler_signatures.ml b/include/taler_signatures.ml
new file mode 100644
index 00000000..d9211977
--- /dev/null
+++ b/include/taler_signatures.ml
@@ -0,0 +1,78 @@
+(* This file was generated by using data and/or code from the GNU Taler project,
+   under the AGPL-v3 licence.
+   Do not edit it. *)
+
+let master_aml_key : int32 = 1017_l
+let master_drain_profit : int32 = 1018_l
+let master_partner_details : int32 = 1019_l
+let master_signing_key_revoked : int32 = 1020_l
+let master_add_wire : int32 = 1021_l
+let master_global_fees : int32 = 1022_l
+let master_del_wire : int32 = 1023_l
+let master_signing_key_validity : int32 = 1024_l
+let master_denomination_key_validity : int32 = 1025_l
+let master_add_auditor : int32 = 1026_l
+let master_del_auditor : int32 = 1027_l
+let master_wire_fees : int32 = 1028_l
+let master_denomination_key_revoked : int32 = 1029_l
+let master_wire_details : int32 = 1030_l
+let master_extension : int32 = 1031_l
+let exchange_reserve_status : int32 = 1032_l
+let exchange_confirm_deposit : int32 = 1033_l
+let exchange_confirm_melt : int32 = 1034_l
+let exchange_key_set : int32 = 1035_l
+let exchange_confirm_wire : int32 = 1036_l
+let exchange_confirm_wire_deposit : int32 = 1037_l
+let exchange_confirm_refund : int32 = 1038_l
+let exchange_confirm_recoup : int32 = 1039_l
+let exchange_reserve_closed : int32 = 1040_l
+let exchange_confirm_recoup_refresh : int32 = 1041_l
+let exchange_affirm_denom_unknown : int32 = 1042_l
+let exchange_affirm_denom_expired : int32 = 1043_l
+let exchange_confirm_purse_creation : int32 = 1045_l
+let exchange_confirm_purse_merged : int32 = 1046_l
+let exchange_purse_status : int32 = 1047_l
+let exchange_reserve_attest_details : int32 = 1048_l
+let exchange_confirm_purse_refund : int32 = 1049_l
+let exchange_confirm_withdraw : int32 = 1050_l
+let auditor_exchange_keys : int32 = 1064_l
+let merchant_contract : int32 = 1101_l
+let merchant_refund : int32 = 1102_l
+let merchant_track_transaction : int32 = 1103_l
+let merchant_payment_ok : int32 = 1104_l
+let merchant_wire_details : int32 = 1107_l
+let merchant_token_issue : int32 = 1108_l
+let wallet_reserve_withdraw : int32 = 1200_l
+let wallet_coin_deposit : int32 = 1201_l
+let wallet_coin_melt : int32 = 1202_l
+let wallet_coin_recoup : int32 = 1203_l
+let wallet_coin_link : int32 = 1204_l
+let wallet_account_setup : int32 = 1205_l
+let wallet_coin_recoup_refresh : int32 = 1206_l
+let wallet_age_attestation : int32 = 1207_l
+let wallet_reserve_history : int32 = 1208_l
+let wallet_coin_history : int32 = 1209_l
+let wallet_purse_create : int32 = 1210_l
+let wallet_purse_deposit : int32 = 1211_l
+let wallet_purse_status : int32 = 1212_l
+let wallet_purse_merge : int32 = 1213_l
+let wallet_account_merge : int32 = 1214_l
+let wallet_reserve_close : int32 = 1215_l
+let wallet_purse_econtract : int32 = 1216_l
+let wallet_reserve_open : int32 = 1217_l
+let wallet_reserve_open_deposit : int32 = 1218_l
+let wallet_reserve_attest_details : int32 = 1219_l
+let wallet_purse_delete : int32 = 1220_l
+let wallet_reserve_age_withdraw : int32 = 1221_l
+let wallet_token_use : int32 = 1222_l
+let mailbox_messages_delete : int32 = 1223_l
+let sm_rsa_denomination_key : int32 = 1250_l
+let sm_signing_key : int32 = 1251_l
+let sm_cs_denomination_key : int32 = 1252_l
+let client_test_eddsa : int32 = 1302_l
+let exchange_test_eddsa : int32 = 1303_l
+let aml_decision : int32 = 1350_l
+let aml_query : int32 = 1351_l
+let kyc_auth : int32 = 1360_l
+let anastasis_policy_upload : int32 = 1400_l
+let sync_backup_upload : int32 = 1450_l
diff --git a/mte.opam b/mte.opam
new file mode 100644
index 00000000..8bdbc121
--- /dev/null
+++ b/mte.opam
@@ -0,0 +1,49 @@
+# This file is generated by dune, edit dune-project instead
+opam-version: "2.0"
+synopsis: "MTE - the MirageOS Taler Exchange"
+description:
+  "A GNU Taler exchange implementation with the unikernel framework MirageOS"
+maintainer: ["Olivier Pierre <swrup@protonmail.com>"]
+authors: ["Olivier Pierre <swrup@protonmail.com>"]
+license: "AGPL-3.0-only"
+tags: ["GNU Taler" "MirageOS" "unikernel" "OCaml" "crypto"]
+depends: [
+  "dune" {>= "3.20"}
+  "ocaml" {>= "5.3"}
+  "base32"
+  "caqti"
+  "caqti-miou"
+  "caqti-driver-pgx"
+  "crunch"
+  "vif"
+  "jsont"
+  "cohttp"
+  "fmt"
+  "bin"
+  "angstrom"
+  "zarith"
+  "mirage-crypto"
+  "digestif"
+  "duration"
+  "jsont"
+  "cohttp"
+  "ptime"
+  "logs"
+  "ocamlformat" {with-dev-setup}
+  "odoc" {with-doc}
+]
+build: [
+  ["dune" "subst"] {dev}
+  [
+    "dune"
+    "build"
+    "-p"
+    name
+    "-j"
+    jobs
+    "@install"
+    "@runtest" {with-test}
+    "@doc" {with-doc}
+  ]
+]
+x-maintenance-intent: ["(latest)"]
diff --git a/src/amount.ml b/src/amount.ml
new file mode 100644
index 00000000..2a49a548
--- /dev/null
+++ b/src/amount.ml
@@ -0,0 +1,119 @@
+(* TODO
+     have safe amount arithmetic
+     make type private
+     redefine an Amount module with currency enforced to be Config.currency? *)
+(* Amounts of currency, serialized as `<Currency>:<IntegerPart>.<FractionalPart>`
+     Fixed-precision numbers with 8 decimal places.
+     - <Currency> must be at most 11 characters long
+       only consist of ASCII letters (a-zA-Z).
+     - integer part of <DecimalAmount> may be at most 2^52.
+     - fractional part of <DecimalAmount> may contain at most 8 decimal digits.
+
+     Prefixed with '+' or '-' in certain contexts.
+     When no sign is present, the amount is assumed to be positive. *)
+type sign =
+  | Sign_plus
+  | Sign_minus
+
+type t = {
+  sign: sign option;
+  currency: string;
+  value: Int64.t;
+  fraction: Int32.t;
+}
+
+let ( let* ) o f = match o with Ok v -> f v | Error _ as e -> e
+let check_not msg = function false -> Ok () | true -> Error msg
+let value_upper_bound = Z.(pow (of_int 2) 52) |> Z.to_int64
+let fraction_upper_bound = Int32.of_int 100_000_000
+
+let make ~sign ~currency ~value ~fraction =
+  let* () = check_not "value is negative" (value < Int64.zero) in
+  let* () = check_not "fraction is negative" (fraction < Int32.zero) in
+  let* () =
+    check_not "value is greater than 2^52" (value > value_upper_bound)
+  in
+  let* () =
+    check_not "fraction has more than 8 decimal digits"
+      (fraction >= fraction_upper_bound)
+  in
+  Ok { sign; currency; value; fraction }
+
+let pp =
+  let open Fmt in
+  let pp_sign ppf = function
+    | Sign_plus -> char ppf '+'
+    | Sign_minus -> char ppf '-'
+  in
+  fun ppf { sign; currency; value; fraction } ->
+    pf ppf "%a%s:%Ld.%02ld" (Fmt.option pp_sign) sign currency value fraction
+
+let to_string = Fmt.str "%a" pp
+
+let of_string =
+  let open Angstrom in
+  let parse_sign =
+    choice
+      [
+        char '+' *> return (Some Sign_plus);
+        char '-' *> return (Some Sign_minus);
+        return None;
+      ]
+  in
+  let parse_currency =
+    (* TODO currency string constraint/format *)
+    take_while1 (function
+      | 'a' .. 'z' | 'A' .. 'Z' -> true
+      | _ -> false)
+  in
+  let parse_int64 =
+    take_while1 (function '0' .. '9' -> true | _ -> false)
+    >>| Int64.of_string_opt
+    >>= function
+    | None -> fail "invalid integer"
+    | Some n -> return n
+  in
+  let parse_int32 =
+    take_while1 (function '0' .. '9' -> true | _ -> false)
+    >>| Int32.of_string_opt
+    >>= function
+    | None -> fail "invalid integer"
+    | Some n -> return n
+  in
+  let parse_t =
+    lift4
+      (fun sign currency value fraction ->
+        make ~sign ~currency ~value ~fraction)
+      parse_sign parse_currency
+      (char ':' *> parse_int64)
+      (char '.' *> parse_int32)
+  in
+  fun s -> parse_string ~consume:Consume.All parse_t s |> Result.join
+
+let jsont = Jsont.of_of_string ~kind:"Amount" of_string ~enc:to_string
+let currency_len = 12
+
+let pad_currency s =
+  let len = String.length s in
+  assert (len <= 11);
+  let b = Bytes.make 12 '\x00' in
+  Bytes.blit_string s 0 b 0 len;
+  Bytes.to_string b
+
+let bin =
+  let open Bin in
+  record (fun _value _fraction _currency ->
+      (* no need to decode amount? *)
+      assert false)
+  |+ field neint64 (fun t -> t.value)
+  |+ field neint32 (fun t -> t.fraction)
+  |+ field (bytes currency_len) (fun t -> pad_currency t.currency)
+  |> sealr
+
+let bin_nbo =
+  let open Bin in
+  record (fun _value _fraction _currency -> assert false)
+  |+ field beint64 (fun t -> t.value)
+  |+ field beint32 (fun t -> t.fraction)
+  |+ field (bytes currency_len) (fun t -> pad_currency t.currency)
+  |> sealr
diff --git a/src/amount.mli b/src/amount.mli
new file mode 100644
index 00000000..e2572401
--- /dev/null
+++ b/src/amount.mli
@@ -0,0 +1,27 @@
+type sign =
+  | Sign_plus
+  | Sign_minus
+
+type t = private {
+  sign: sign option;
+  currency: string;
+  value: Int64.t;
+  fraction: Int32.t;
+}
+
+val make :
+  sign:sign option ->
+  currency:string ->
+  value:Int64.t ->
+  fraction:Int32.t ->
+  (t, string) result
+
+val pp : Format.formatter -> t -> unit
+val to_string : t -> string
+val of_string : string -> (t, string) result
+val currency_len : int
+val jsont : t Jsont.t
+
+(* only for encoding *)
+val bin : t Bin.t
+val bin_nbo : t Bin.t
diff --git a/src/api.ml b/src/api.ml
new file mode 100644
index 00000000..47d2156e
--- /dev/null
+++ b/src/api.ml
@@ -0,0 +1,317 @@
+(* TODO
+   number
+     - number is "float", but we probably want int everywhere instead
+     - numeric values capped at 2^53 -1 inclusive because json
+   time
+     - better types
+     - issues with "never" = uint64_max *)
+open Crypto
+
+let encode_exn jsont v = Jsont_bytesrw.encode_string jsont v |> Result.get_ok
+let encode jsont v = Jsont_bytesrw.encode_string jsont v
+let decode jsont v = Jsont_bytesrw.decode_string jsont v
+
+module ErrorDetail = struct
+  (* TODO GANA error codes
+     https://git.gnunet.org/gana.git/tree/gnu-taler-error-codes/registry.rec *)
+  type t = {
+    code: int;
+    hint: string option;
+  }
+
+  let jsont =
+    let make code hint = { code; hint } in
+    let enc_code v = v.code in
+    let enc_hint v = v.hint in
+    Jsont.Object.map ~kind:"ErrorDetail" make
+    |> Jsont.Object.mem "code" Jsont.int ~enc:enc_code
+    |> Jsont.Object.opt_mem "hint" Jsont.(string) ~enc:enc_hint
+    |> Jsont.Object.finish
+end
+
+module HashCode : sig
+  type t
+
+  val hash : string -> t
+  val jsont : t Jsont.t
+end = struct
+  type t = B32.t
+
+  let hash s =
+    let open Digestif.SHA512 in
+    s |> digest_string |> to_raw_string
+
+  let jsont = Jsont.of_of_string ~kind:"HashCode" B32.decode ~enc:B32.encode
+end
+
+module RelativeTime = struct
+  type t =
+    | Microseconds of float
+    | Forever
+
+  let number_or_forever_jsont =
+    let forever =
+      let dec s =
+        match s with
+        | "forever" -> Forever
+        | _ -> Jsont.Error.msg Jsont.Meta.none "unexpected string value"
+      in
+      let enc = function Forever -> "forever" | _ -> assert false in
+      Jsont.map ~dec ~enc Jsont.string
+    in
+    let number =
+      let dec n = Microseconds n in
+      let enc = function Microseconds n -> n | _ -> assert false in
+      Jsont.map ~dec ~enc Jsont.number
+    in
+    let enc = function Forever -> forever | Microseconds _ -> number in
+    Jsont.any ~dec_string:forever ~dec_number:number ~enc ()
+
+  let jsont =
+    let make t_s = t_s in
+    Jsont.Object.map ~kind:"RelativeTime" make
+    |> Jsont.Object.mem "t_s" number_or_forever_jsont ~enc:Fun.id
+    |> Jsont.Object.finish
+end
+
+module RsaDenominationKey = struct
+  type t = {
+    age_mask: int;
+    rsa_pub: RsaPublicKey.t;
+  }
+
+  let jsont =
+    let make age_mask rsa_pub = { age_mask; rsa_pub } in
+    let age_mask v = v.age_mask in
+    let rsa_pub v = v.rsa_pub in
+    Jsont.Object.map ~kind:"RsaDenominationKey" make
+    |> Jsont.Object.mem "age_mask" Jsont.int ~enc:age_mask
+    |> Jsont.Object.mem "rsa_pub" RsaPublicKey.jsont ~enc:rsa_pub
+    |> Jsont.Object.finish
+end
+
+(* ! Clause Schnorr cipher is not supported *)
+module CSDenominationKey = struct
+  type t = {
+    age_mask: int;
+    cs_pub: B32.t;
+  }
+
+  (* TODO B32.jsont *)
+  let b32_jsont = Jsont.of_of_string ~kind:"B32" B32.decode ~enc:B32.encode
+
+  let jsont =
+    let make age_mask cs_pub = { age_mask; cs_pub } in
+    let age_mask v = v.age_mask in
+    let cs_pub v = v.cs_pub in
+    Jsont.Object.map ~kind:"CSDenominationKey" make
+    |> Jsont.Object.mem "age_mask" Jsont.int ~enc:age_mask
+    |> Jsont.Object.mem "cs_pub" b32_jsont ~enc:cs_pub
+    |> Jsont.Object.finish
+end
+
+module DenominationKey = struct
+  type t = Rsa of RsaDenominationKey.t
+  (*| CS of CSDenominationKey.t*)
+
+  let to_octets = function Rsa denom -> RsaPublicKey.to_octets denom.rsa_pub
+
+  let of_cs _v =
+    Jsont.Error.msg Jsont.Meta.none "CSDenominationKey are not supported"
+
+  let of_rsa v = Rsa v
+
+  let jsont =
+    let open Jsont.Object in
+    let rsa = Case.map "RSA" RsaDenominationKey.jsont ~dec:of_rsa in
+    let cs = Case.map "CS" CSDenominationKey.jsont ~dec:of_cs in
+    let enc_case = function Rsa v -> Case.value rsa v in
+    let cases = Case.[ make rsa; make cs ] in
+    map ~kind:"DenominationKey" Fun.id
+    |> case_mem "cipher" Jsont.string ~enc:Fun.id ~enc_case cases
+    |> finish
+end
+
+module FutureSignKey = struct
+  type t = {
+    key: EddsaPublicKey.t;
+    stamp_start: Timestamp.t;
+    stamp_expire: Timestamp.t;
+    stamp_end: Timestamp.t;
+    signkey_secmod_sig: EddsaSignature.t;
+  }
+
+  let jsont =
+    let make key stamp_start stamp_expire stamp_end signkey_secmod_sig =
+      { key; stamp_start; stamp_expire; stamp_end; signkey_secmod_sig }
+    in
+    let key v = v.key in
+    let stamp_start v = v.stamp_start in
+    let stamp_expire v = v.stamp_expire in
+    let stamp_end v = v.stamp_end in
+    let signkey_secmod_sig v = v.signkey_secmod_sig in
+    let open Jsont.Object in
+    map ~kind:"FutureSignKey" make
+    |> mem "key" EddsaPublicKey.jsont ~enc:key
+    |> mem "stamp_start" Timestamp.jsont ~enc:stamp_start
+    |> mem "stamp_expire" Timestamp.jsont ~enc:stamp_expire
+    |> mem "stamp_end" Timestamp.jsont ~enc:stamp_end
+    |> mem "signkey_secmod_sig" EddsaSignature.jsont ~enc:signkey_secmod_sig
+    |> finish
+end
+
+module FutureDenom = struct
+  type t = {
+    section_name: string;
+    value: Amount.t;
+    stamp_start: Timestamp.t;
+    stamp_expire_withdraw: Timestamp.t;
+    stamp_expire_deposit: Timestamp.t;
+    stamp_expire_legal: Timestamp.t;
+    denom_pub: DenominationKey.t;
+    fee_withdraw: Amount.t;
+    fee_deposit: Amount.t;
+    fee_refresh: Amount.t;
+    fee_refund: Amount.t;
+    denom_secmod_sig: Bin_signature.DenominationKeyAnnouncementPS.Sig.t;
+  }
+
+  let jsont =
+    let make section_name value stamp_start stamp_expire_withdraw
+        stamp_expire_deposit stamp_expire_legal denom_pub fee_withdraw
+        fee_deposit fee_refresh fee_refund denom_secmod_sig =
+      {
+        section_name;
+        value;
+        stamp_start;
+        stamp_expire_withdraw;
+        stamp_expire_deposit;
+        stamp_expire_legal;
+        denom_pub;
+        fee_withdraw;
+        fee_deposit;
+        fee_refresh;
+        fee_refund;
+        denom_secmod_sig;
+      }
+    in
+    let section_name t = t.section_name in
+    let value t = t.value in
+    let stamp_start t = t.stamp_start in
+    let stamp_expire_withdraw t = t.stamp_expire_withdraw in
+    let stamp_expire_deposit t = t.stamp_expire_deposit in
+    let stamp_expire_legal t = t.stamp_expire_legal in
+    let denom_pub t = t.denom_pub in
+    let fee_withdraw t = t.fee_withdraw in
+    let fee_deposit t = t.fee_deposit in
+    let fee_refresh t = t.fee_refresh in
+    let fee_refund t = t.fee_refund in
+    let denom_secmod_sig t = t.denom_secmod_sig in
+    let open Jsont.Object in
+    map ~kind:"FutureDenom" make
+    |> mem "section_name" Jsont.string ~enc:section_name
+    |> mem "value" Amount.jsont ~enc:value
+    |> mem "stamp_start" Timestamp.jsont ~enc:stamp_start
+    |> mem "stamp_expire_withdraw" Timestamp.jsont ~enc:stamp_expire_withdraw
+    |> mem "stamp_expire_deposit" Timestamp.jsont ~enc:stamp_expire_deposit
+    |> mem "stamp_expire_legal" Timestamp.jsont ~enc:stamp_expire_legal
+    |> mem "denom_pub" DenominationKey.jsont ~enc:denom_pub
+    |> mem "fee_withdraw" Amount.jsont ~enc:fee_withdraw
+    |> mem "fee_deposit" Amount.jsont ~enc:fee_deposit
+    |> mem "fee_refresh" Amount.jsont ~enc:fee_refresh
+    |> mem "fee_refund" Amount.jsont ~enc:fee_refund
+    |> mem "denom_secmod_sig"
+         Bin_signature.DenominationKeyAnnouncementPS.Sig.jsont
+         ~enc:denom_secmod_sig
+    |> finish
+end
+
+module FutureKeysResponse = struct
+  type t = {
+    future_denoms: FutureDenom.t list;
+    future_signkeys: FutureSignKey.t list;
+    master_pub: EddsaPublicKey.t;
+    denom_secmod_public_key: EddsaPublicKey.t;
+    signkey_secmod_public_key: EddsaPublicKey.t;
+  }
+
+  let jsont =
+    let make future_denoms future_signkeys master_pub denom_secmod_public_key
+        signkey_secmod_public_key =
+      {
+        future_denoms;
+        future_signkeys;
+        master_pub;
+        denom_secmod_public_key;
+        signkey_secmod_public_key;
+      }
+    in
+    let future_denoms t = t.future_denoms in
+    let future_signkeys t = t.future_signkeys in
+    let master_pub t = t.master_pub in
+    let denom_secmod_public_key t = t.denom_secmod_public_key in
+    let signkey_secmod_public_key t = t.signkey_secmod_public_key in
+    let open Jsont.Object in
+    map ~kind:"FutureKeysResponse" make
+    |> mem "future_denoms" (Jsont.list FutureDenom.jsont) ~enc:future_denoms
+    |> mem "future_signkeys"
+         (Jsont.list FutureSignKey.jsont)
+         ~enc:future_signkeys
+    |> mem "master_pub" EddsaPublicKey.jsont ~enc:master_pub
+    |> mem "denom_secmod_public_key" EddsaPublicKey.jsont
+         ~enc:denom_secmod_public_key
+    |> mem "signkey_secmod_public_key" EddsaPublicKey.jsont
+         ~enc:signkey_secmod_public_key
+    |> finish
+end
+
+module SignKeySignature = struct
+  type t = {
+    key: EddsaPublicKey.t;
+    master_sig: EddsaSignature.t;
+  }
+
+  let jsont =
+    let make key master_sig = { key; master_sig } in
+    let key v = v.key in
+    let master_sig v = v.master_sig in
+    let open Jsont.Object in
+    map ~kind:"SignKeySignature" make
+    |> mem "key" EddsaPublicKey.jsont ~enc:key
+    |> mem "master_sig" EddsaSignature.jsont ~enc:master_sig
+    |> finish
+end
+
+module DenomSignature = struct
+  type t = {
+    h_denom_pub: HashCode.t;
+    master_sig: EddsaSignature.t;
+  }
+
+  let jsont =
+    let make h_denom_pub master_sig = { h_denom_pub; master_sig } in
+    let h_denom_pub v = v.h_denom_pub in
+    let master_sig v = v.master_sig in
+    let open Jsont.Object in
+    map ~kind:"DenomSignature" make
+    |> mem "h_denom_pub" HashCode.jsont ~enc:h_denom_pub
+    |> mem "master_sig" EddsaSignature.jsont ~enc:master_sig
+    |> finish
+end
+
+module MasterSignatures = struct
+  type t = {
+    denom_sigs: DenomSignature.t list;
+    signkey_sigs: SignKeySignature.t list;
+  }
+
+  let jsont =
+    let make denom_sigs signkey_sigs = { denom_sigs; signkey_sigs } in
+    let denom_sigs v = v.denom_sigs in
+    let signkey_sigs v = v.signkey_sigs in
+    let open Jsont.Object in
+    map ~kind:"MasterSignatures" make
+    |> mem "denom_sigs" (Jsont.list DenomSignature.jsont) ~enc:denom_sigs
+    |> mem "signkey_sigs" (Jsont.list SignKeySignature.jsont) ~enc:signkey_sigs
+    |> finish
+end
diff --git a/src/assets.ml b/src/assets.ml
new file mode 100644
index 00000000..9d6c8088
--- /dev/null
+++ b/src/assets.ml
@@ -0,0 +1,150 @@
+(* TODO clean up *)
+
+(* docs: https://docs.taler.net/manpages/taler-exchange.conf.5.html
+   https://docs.taler.net/design-documents/003-tos-rendering.html *)
+
+(* hardcoded config just for static assets *)
+let default_lang = "en"
+let default_encoding : [< `Identity | `DEFLATE | `Gzip ] = `Identity
+
+(* todo: Taler documentation markdown mimetype should be the prefered one, and be
+   supported, according to DD we take text/plain as default instead for now *)
+let default_mimetype = ("text", "plain")
+let default_extension = ".txt"
+let terms_legal_version = "1"
+let privacy_legal_version = "1"
+
+module Mimetype = struct
+  let mimetype_extension_assoc =
+    [
+      (("text", "plain"), ".txt");
+      (("text", "markdown"), ".md");
+      (("text", "html"), ".html");
+      (("text", "html"), ".htm");
+      (("application", "pdf"), ".pdf");
+      (("image", "jpeg"), ".jpg");
+      (("image", "jpeg"), ".jpeg");
+      (("image", "png"), ".png");
+      (("image", "gif"), ".gif");
+    ]
+
+  let mimetype_l, _ = List.split mimetype_extension_assoc
+
+  let of_cohttp_media = function
+    | Cohttp.Accept.MediaType (m, m_sub) ->
+        List.find_opt (( = ) (m, m_sub)) mimetype_l
+    | AnyMediaSubtype m ->
+        List.find_opt (fun (m', _) -> String.equal m m') mimetype_l
+    | AnyMedia -> Some default_mimetype
+
+  let to_extension (m, m_sub) =
+    assert (m <> "*");
+    assert (m_sub <> "*");
+    List.assoc_opt (m, m_sub) mimetype_extension_assoc
+
+  let of_extension ext =
+    List.find_map
+      (fun (mime, ext') ->
+        match String.equal ext ext' with false -> None | true -> Some mime)
+      mimetype_extension_assoc
+
+  let pp_mime fmt mime = Fmt.pf fmt "%s/%s" (fst mime) (snd mime)
+end
+
+(* TODO config *)
+type t =
+  | Terms
+  | Privacy
+
+let etag k =
+  Result.get_ok
+  @@ Headers_lib.Etag.of_crockford32
+  @@ match k with Terms -> "0" | Privacy -> "0"
+
+let legal_version = function
+  | Terms -> terms_legal_version
+  | Privacy -> privacy_legal_version
+
+let base_dir = function
+  | Terms -> Fpath.v "terms"
+  | Privacy -> Fpath.v "privacy"
+
+(* does some checks on assets/ folder content and infer the set of supported languages and mimetype *)
+let supported_lang_arr, supported_ext_arr =
+  let open Syntax in
+  let path_l =
+    Assets_crunch.file_list |> list_map Fpath.of_string |> function
+    | Error (`Msg e) -> Fmt.failwith "%s" e
+    | Ok x -> x
+  in
+  let aux t =
+    let prefix = base_dir t in
+    let path_l = path_l |> List.filter_map (Fpath.rem_prefix prefix) in
+    let ext_l =
+      path_l |> List.map Fpath.get_ext |> List.sort_uniq String.compare
+    in
+    let lang_l =
+      path_l
+      |> List.map (fun path ->
+          match Fpath.segs path with
+          | [] -> assert false
+          | [ dir; _file ] -> dir
+          | _l ->
+              Fmt.failwith "invalid folder structure, file `%s` is misplaced"
+                (Fpath.to_string path))
+      |> List.sort_uniq String.compare
+    in
+    let () =
+      if List.is_empty lang_l then Fmt.failwith "no language supported";
+      if List.is_empty ext_l then Fmt.failwith "no mimetype supported";
+      if not @@ List.mem default_lang lang_l then
+        Fmt.failwith "default language `%s` files not found" default_lang;
+      if not @@ List.mem ".txt" ext_l then
+        Fmt.failwith "plain text file not found";
+      if not @@ List.mem ".md" ext_l then Fmt.failwith "markdown file not found";
+      List.iter
+        (fun dir ->
+          if String.length dir <> 2 then
+            Fmt.failwith "language directory with invalid name: `%s`" dir)
+        lang_l;
+      if List.length path_l <> List.length ext_l * List.length lang_l then
+        Fmt.failwith
+          "invalid folder structure, all supported language must provide the \
+           same set of file mimetype"
+    in
+    (lang_l, ext_l)
+  in
+  let lang_l, ext_l = aux Terms in
+  let lang_l', ext_l' = aux Privacy in
+  let () =
+    if
+      not
+      @@ (List.equal String.equal lang_l lang_l'
+         && List.equal String.equal ext_l ext_l')
+    then
+      Fmt.failwith
+        "invalid folder structure, /terms and /privacy must support the same \
+         set of languages and mimetypes";
+    ()
+  in
+  (Array.of_list lang_l, Array.of_list ext_l)
+
+let supported_mimetype_arr =
+  Array.map Mimetype.of_extension supported_ext_arr |> Array.map Option.get
+
+let is_supported_lang lang = Array.mem lang supported_lang_arr
+let is_supported_ext ext = Array.mem ext supported_ext_arr
+let is_supported_mimetype mime = Array.mem mime supported_mimetype_arr
+
+(* ! lang and mime must be supported *)
+let get_content ~lang ~mime t =
+  let etag = Headers_lib.Etag.to_raw_string (etag t) in
+  let ext =
+    match Mimetype.to_extension mime with
+    | None -> Fmt.failwith "mimetype `%s/%s` unknown" (fst mime) (snd mime)
+    | Some ext -> ext
+  in
+  let path = Fpath.to_string Fpath.((base_dir t / lang / etag) + ext) in
+  match Assets_crunch.read path with
+  | None -> Fmt.failwith "static file not found: `%s`" path
+  | Some data -> data
diff --git a/src/b32.ml b/src/b32.ml
new file mode 100644
index 00000000..29e73239
--- /dev/null
+++ b/src/b32.ml
@@ -0,0 +1,28 @@
+(* TODO test *)
+(* Crockford's variant of Base32
+   http://www.crockford.com/wrmg/base32.html
+   except that:
+     - 'U' is not excluded but also decodes to 'V'
+     - '-' is not allowed
+     - checksum is not allowed *)
+
+(* 'I' 'L' 'O' 'U' excluded *)
+type t = string
+
+let alphabet = Base32.make_alphabet "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+let encode s = Base32.encode_string ~alphabet s
+
+let decode s =
+  let s =
+    String.map
+      (fun c ->
+        match Char.uppercase_ascii c with
+        | 'O' -> '0'
+        | 'I' | 'L' -> '1'
+        | 'U' -> 'V'
+        | c -> c)
+      s
+  in
+  match Base32.decode ~alphabet ~off:0 ~len:(String.length s) s with
+  | Error (`Msg e) -> Error e
+  | Ok v -> Ok v
diff --git a/src/bin_signature.ml b/src/bin_signature.ml
new file mode 100644
index 00000000..f7d30051
--- /dev/null
+++ b/src/bin_signature.ml
@@ -0,0 +1,801 @@
+(* Packed Signature *)
+
+open Bin_type
+open Bin_type.Aliases
+
+(* EccSignaturePurpose *)
+module Purpose = struct
+  type t = {
+    size: int32;
+    purpose: int32;
+  }
+
+  let bin =
+    let open Bin in
+    record (fun size purpose -> { size; purpose })
+    |+ field beint32 (fun t -> t.size)
+    |+ field beint32 (fun t -> t.purpose)
+    |> sealr
+
+  let make ~size purpose = { size= Int32.of_int size; purpose }
+  let dummy = make ~size:0 0_l
+
+  (* helper function to make ['signature Bin.t]
+     to compute [t.size], we first build a bin with a dummy purpose *)
+  let make_bin =
+    let get_size f =
+      let open Bin in
+      match Size.of_value (Size.size_of (f dummy)) with
+      | Dynamic _ | Unknown ->
+          Fmt.failwith "size_of failure: size is not Static"
+      | Static n -> n
+    in
+    fun code f -> make ~size:(get_size f) code |> f
+
+  let field purpose = Bin.field bin (fun _t -> purpose)
+end
+
+module WithdrawRequestPS = struct
+  (* Purpose is #TALER_SIGNATURE_WALLET_RESERVE_WITHDRAW *)
+  type t = {
+    amount: Amount.t;
+    fee: Amount.t;
+    h_planchets: HashPlanchetsP.t;
+    blinding_seed: BlindingMasterSecret.t;
+    max_age_group: int32;
+    mask: AgeMask.t;
+  }
+
+  let bin =
+    let open Bin in
+    Purpose.make_bin Taler_signatures.wallet_reserve_withdraw @@ fun purpose ->
+    record
+      (fun _purpose amount fee h_planchets blinding_seed max_age_group mask ->
+        { amount; fee; h_planchets; blinding_seed; max_age_group; mask })
+    |+ Purpose.field purpose
+    |+ field Amount.bin (fun t -> t.amount)
+    |+ field Amount.bin (fun t -> t.fee)
+    |+ field HashPlanchetsP.bin (fun t -> t.h_planchets)
+    |+ field BlindingMasterSecret.bin (fun t -> t.blinding_seed)
+    |+ field beint32 (fun t -> t.max_age_group)
+    |+ field AgeMask.bin (fun t -> t.mask)
+    |> sealr
+end
+
+module WithdrawConfirmationPS = struct
+  (* Purpose is #TALER_SIGNATURE_EXCHANGE_CONFIRM_WITHDRAW.
+     Signed by a `struct TALER_ExchangePrivateKeyP` using EdDSA. *)
+  type t = {
+    (* TODO TALER doc
+       missing TALER_HashBlindedPlanchetsP*)
+    h_planchets: HashPlanchetsP.t;
+    noreveal_index: int32;
+  }
+
+  let bin =
+    let open Bin in
+    Purpose.make_bin Taler_signatures.exchange_confirm_withdraw
+    @@ fun purpose ->
+    record (fun _purpose h_planchets noreveal_index ->
+        { h_planchets; noreveal_index })
+    |+ Purpose.field purpose
+    |+ field HashPlanchetsP.bin (fun t -> t.h_planchets)
+    |+ field beint32 (fun t -> t.noreveal_index)
+    |> sealr
+end
+
+module DenominationKeyAnnouncementPS = struct
+  (* TODO taler_signatures purpose
+     we use TALER_SIGNATURE_SM_RSA_DENOMINATION_KEY instead here *)
+  (* purpose.purpose = TALER_SIGNATURE_SM_DENOMINATION_KEY *)
+  type r = {
+    h_denom_pub: DenominationHash.t;
+    h_section_name: Hash_64_cstr.t;
+    anchor_time: TimeAbsoluteNBO.t;
+    duration_withdraw: TimeRelativeNBO.t;
+  }
+
+  let bin =
+    let open Bin in
+    Purpose.make_bin Taler_signatures.sm_rsa_denomination_key @@ fun purpose ->
+    record
+      (fun _purpose h_denom_pub h_section_name anchor_time duration_withdraw ->
+        { h_denom_pub; h_section_name; anchor_time; duration_withdraw })
+    |+ Purpose.field purpose
+    |+ field DenominationHash.bin (fun t -> t.h_denom_pub)
+    |+ field Hash_64_cstr.bin (fun t -> t.h_section_name)
+    |+ field TimeAbsoluteNBO.bin (fun t -> t.anchor_time)
+    |+ field TimeRelativeNBO.bin (fun t -> t.duration_withdraw)
+    |> sealr
+
+  module type SIG = sig
+    type t
+
+    val sign : (string -> string) -> r -> t
+    val verify : (string -> msg:string -> bool) -> t -> r -> bool
+    val jsont : t Jsont.t
+  end
+
+  module Sig : SIG = struct
+    type t = string
+
+    let sign f r = f @@ Bin.to_string bin r
+    let verify f s r = f s ~msg:(Bin.to_string bin r)
+
+    (* TODO B32.jsont, for others types too *)
+    let jsont = Jsont.string
+  end
+end
+
+module SigningKeyAnnouncementPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_SM_SIGNING_KEY *)
+  type t = {
+    exchange_pub: ExchangePublicKeyP.t;
+    anchor_time: TimeAbsoluteNBO.t;
+    duration: TimeRelativeNBO.t;
+  }
+
+  let bin =
+    let open Bin in
+    Purpose.make_bin Taler_signatures.sm_signing_key @@ fun purpose ->
+    record (fun _purpose exchange_pub anchor_time duration ->
+        { exchange_pub; anchor_time; duration })
+    |+ Purpose.field purpose
+    |+ field ExchangePublicKeyP.bin (fun t -> t.exchange_pub)
+    |+ field TimeAbsoluteNBO.bin (fun t -> t.anchor_time)
+    |+ field TimeRelativeNBO.bin (fun t -> t.duration)
+    |> sealr
+end
+
+module DenominationKeyValidityPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_DENOMINATION_KEY_VALIDITY *)
+  type t = {
+    master: MasterPublicKeyP.t;
+    start: TimeAbsoluteNBO.t;
+    expire_withdraw: TimeAbsoluteNBO.t;
+    expire_spend: TimeAbsoluteNBO.t;
+    expire_legal: TimeAbsoluteNBO.t;
+    value: AmountNBO.t;
+    fee_withdraw: AmountNBO.t;
+    fee_deposit: AmountNBO.t;
+    fee_refresh: AmountNBO.t;
+    denom_hash: DenominationHash.t;
+  }
+
+  let bin =
+    let open Bin in
+    Purpose.make_bin Taler_signatures.master_denomination_key_validity
+    @@ fun purpose ->
+    record
+      (fun
+        _purpose
+        master
+        start
+        expire_withdraw
+        expire_spend
+        expire_legal
+        value
+        fee_withdraw
+        fee_deposit
+        fee_refresh
+        denom_hash
+      ->
+        {
+          master;
+          start;
+          expire_withdraw;
+          expire_spend;
+          expire_legal;
+          value;
+          fee_withdraw;
+          fee_deposit;
+          fee_refresh;
+          denom_hash;
+        })
+    |+ Purpose.field purpose
+    |+ field MasterPublicKeyP.bin (fun t -> t.master)
+    |+ field TimeAbsoluteNBO.bin (fun t -> t.start)
+    |+ field TimeAbsoluteNBO.bin (fun t -> t.expire_withdraw)
+    |+ field TimeAbsoluteNBO.bin (fun t -> t.expire_spend)
+    |+ field TimeAbsoluteNBO.bin (fun t -> t.expire_legal)
+    |+ field AmountNBO.bin (fun t -> t.value)
+    |+ field AmountNBO.bin (fun t -> t.fee_withdraw)
+    |+ field AmountNBO.bin (fun t -> t.fee_deposit)
+    |+ field AmountNBO.bin (fun t -> t.fee_refresh)
+    |+ field DenominationHash.bin (fun t -> t.denom_hash)
+    |> sealr
+end
+
+module ExchangeSigningKeyValidityPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_SIGNING_KEY_VALIDITY *)
+  type t = {
+    start: TimeAbsoluteNBO.t;
+    expire: TimeAbsoluteNBO.t;
+    end_: TimeAbsoluteNBO.t; (* "end" renamed to end_ *)
+    signkey_pub: ExchangePublicKeyP.t;
+  }
+
+  let bin =
+    let open Bin in
+    Purpose.make_bin Taler_signatures.master_signing_key_validity
+    @@ fun purpose ->
+    record (fun _purpose start expire end_ signkey_pub ->
+        { start; expire; end_; signkey_pub })
+    |+ Purpose.field purpose
+    |+ field TimeAbsoluteNBO.bin (fun t -> t.start)
+    |+ field TimeAbsoluteNBO.bin (fun t -> t.expire)
+    |+ field TimeAbsoluteNBO.bin (fun t -> t.end_)
+    |+ field ExchangePublicKeyP.bin (fun t -> t.signkey_pub)
+    |> sealr
+end
+
+(* ### BIN IMPL END ### *)
+
+module SingleWithdrawRequestPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_RESERVE_WITHDRAW *)
+  type t = {
+    amount_with_fee: AmountNBO.t;
+    h_denomination_pub: DenominationHash.t;
+    h_coin_envelope: BlindedCoinHash.t;
+  }
+end
+
+module DepositRequestPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_COIN_DEPOSIT *)
+  type t = {
+    h_contract_terms: PrivateContractHash.t;
+    h_age_commitment: AgeCommitmentHash.t;
+    h_policy: ExtensionsPolicyHash.t;
+    h_wire: MerchantWireHash.t;
+    h_denom_pub: DenominationHash.t;
+    timestamp: TimeAbsoluteNBO.t;
+    refund_deadline: TimeAbsoluteNBO.t;
+    amount_with_fee: AmountNBO.t;
+    deposit_fee: AmountNBO.t;
+    merchant: MerchantPublicKeyP.t;
+    wallet_data_hash: Hash_64_cstr.t;
+  }
+end
+
+module DepositConfirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_CONFIRM_DEPOSIT *)
+  type t = {
+    h_contract_terms: PrivateContractHash.t;
+    h_wire: MerchantWireHash.t;
+    h_policy: ExtensionsPolicyHash.t;
+    timestamp: TimeAbsoluteNBO.t;
+    refund_deadline: TimeAbsoluteNBO.t;
+    amount_without_fee: AmountNBO.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+    merchant: MerchantPublicKeyP.t;
+  }
+end
+
+module RefreshMeltCoinAffirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_COIN_MELT *)
+  type t = {
+    session_hash: RefreshCommitmentP.t;
+    h_denom_pub: DenominationHash.t;
+    h_age_commitment: AgeCommitmentHash.t;
+    amount_with_fee: AmountNBO.t;
+    melt_fee: AmountNBO.t;
+  }
+end
+
+module RefreshMeltConfirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_CONFIRM_MELT *)
+  type t = {
+    session_hash: RefreshCommitmentP.t;
+    noreveal_index: int; (* uint16_t mapped to OCaml int *)
+  }
+end
+
+module ExchangeKeySetPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_KEY_SET *)
+  type t = {
+    list_issue_date: TimeAbsoluteNBO.t;
+    hc: Hash_64_cstr.t;
+  }
+end
+
+module MasterWireDetailsPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_WIRE_DETAILS *)
+  type t = {
+    h_wire_details: FullPaytoHash.t;
+    h_conversion_url: Hash_64_cstr.t;
+    h_credit_restrictions: Hash_64_cstr.t;
+    h_debit_restrictions: Hash_64_cstr.t;
+  }
+end
+
+module MasterWireFeePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_WIRE_FEES *)
+  type t = {
+    h_wire_method: Hash_64_cstr.t;
+    start_date: TimeAbsoluteNBO.t;
+    end_date: TimeAbsoluteNBO.t;
+    wire_fee: AmountNBO.t;
+    closing_fee: AmountNBO.t;
+  }
+end
+
+module GlobalFeesPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_GLOBAL_FEES *)
+  type t = {
+    start_date: TimeAbsoluteNBO.t;
+    end_date: TimeAbsoluteNBO.t;
+    purse_timeout: TimeRelativeNBO.t;
+    kyc_timeout: TimeRelativeNBO.t;
+    history_expiration: TimeRelativeNBO.t;
+    history_fee: AmountNBO.t;
+    kyc_fee: AmountNBO.t;
+    account_fee: AmountNBO.t;
+    purse_fee: AmountNBO.t;
+    purse_account_limit: int; (* uint32_t → int *)
+  }
+end
+
+module MasterDrainProfitPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_DRAIN_PROFITS *)
+  type t = {
+    wtid: WireTransferIdentifierRawP.t;
+    date: TimeAbsoluteNBO.t;
+    amount: AmountNBO.t;
+    h_section: Hash_64_cstr.t;
+    h_payto: FullPaytoHash.t;
+  }
+end
+
+module DepositTrackPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MERCHANT_TRACK_TRANSACTION *)
+  type t = {
+    h_contract_terms: PrivateContractHash.t;
+    h_wire: MerchantWireHash.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+  }
+end
+
+module WireDepositDetailP = struct
+  type t = {
+    h_contract_terms: PrivateContractHash.t;
+    execution_time: TimeAbsoluteNBO.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+    deposit_value: AmountNBO.t;
+    deposit_fee: AmountNBO.t;
+  }
+end
+
+module WireDepositDataPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_CONFIRM_WIRE_DEPOSIT *)
+  type t = {
+    total: AmountNBO.t;
+    wire_fee: AmountNBO.t;
+    merchant_pub: MerchantPublicKeyP.t;
+    h_wire: MerchantWireHash.t;
+    h_details: Hash_64_cstr.t;
+  }
+end
+
+module ExchangeKeyValidityPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_AUDITOR_EXCHANGE_KEYS *)
+  type t = {
+    auditor_url_hash: Hash_64_cstr.t;
+    master: MasterPublicKeyP.t;
+    start: TimeAbsoluteNBO.t;
+    expire_withdraw: TimeAbsoluteNBO.t;
+    expire_spend: TimeAbsoluteNBO.t;
+    expire_legal: TimeAbsoluteNBO.t;
+    value: AmountNBO.t;
+    fee_withdraw: AmountNBO.t;
+    fee_deposit: AmountNBO.t;
+    fee_refresh: AmountNBO.t;
+    denom_hash: DenominationHash.t;
+  }
+end
+
+module PaymentResponsePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MERCHANT_PAYMENT_OK *)
+  type t = { h_contract_terms: PrivateContractHash.t }
+end
+
+module ContractPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MERCHANT_CONTRACT *)
+  type t = { h_contract_terms: PrivateContractHash.t }
+end
+
+module ConfirmWirePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_CONFIRM_WIRE *)
+  type t = {
+    h_wire: MerchantWireHash.t;
+    h_contract_terms: PrivateContractHash.t;
+    wtid: WireTransferIdentifierRawP.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+    execution_time: TimeAbsoluteNBO.t;
+    coin_contribution: AmountNBO.t;
+  }
+end
+
+module RefundConfirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_CONFIRM_REFUND *)
+  type t = {
+    h_contract_terms: PrivateContractHash.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+    merchant: MerchantPublicKeyP.t;
+    rtransaction_id: int64;
+    refund_amount: AmountNBO.t;
+  }
+end
+
+module DepositTrackPS2 = struct
+  (* purpose.purpose = TALER_SIGNATURE_MERCHANT_TRACK_TRANSACTION *)
+  type t = {
+    h_contract_terms: PrivateContractHash.t;
+    h_wire: MerchantWireHash.t;
+    merchant: MerchantPublicKeyP.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+  }
+end
+
+module RefundRequestPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MERCHANT_REFUND *)
+  type t = {
+    h_contract_terms: PrivateContractHash.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+    rtransaction_id: int64;
+    refund_amount: AmountNBO.t;
+    refund_fee: AmountNBO.t;
+  }
+end
+
+module MerchantRefundConfirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MERCHANT_REFUND_OK *)
+  (* Hash of the order ID (a string), hashed without the 0-termination. *)
+  type t = { h_order_id: Hash_64_cstr.t }
+end
+
+module RecoupRequestPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_COIN_RECOUP or TALER_SIGNATURE_WALLET_COIN_RECOUP_REFRESH *)
+  type t = {
+    h_denom_pub: DenominationHash.t;
+    coin_blind: DenominationBlindingKeyP.t;
+  }
+end
+
+module RecoupRefreshConfirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_CONFIRM_RECOUP_REFRESH *)
+  type t = {
+    timestamp: TimeAbsoluteNBO.t;
+    recoup_amount: AmountNBO.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+    old_coin_pub: CoinSpendPublicKeyP.t;
+  }
+end
+
+module RecoupConfirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_CONFIRM_RECOUP *)
+  type t = {
+    timestamp: TimeAbsoluteNBO.t;
+    recoup_amount: AmountNBO.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+    reserve_pub: ReservePublicKeyP.t;
+  }
+end
+
+module DenominationUnknownAffirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_AFFIRM_DENOM_UNKNOWN *)
+  type t = {
+    timestamp: TimeAbsoluteNBO.t;
+    h_denom_pub: DenominationHash.t;
+  }
+end
+
+module DenominationExpiredAffirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_GENERIC_DENOMINATIN_EXPIRED *)
+  type t = {
+    timestamp: TimeAbsoluteNBO.t;
+    operation: string; (* char[8] → string *)
+    h_denom_pub: DenominationHash.t;
+  }
+end
+
+module ReserveCloseConfirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_RESERVE_CLOSED *)
+  type t = {
+    timestamp: TimeAbsoluteNBO.t;
+    closing_amount: AmountNBO.t;
+    reserve_pub: ReservePublicKeyP.t;
+    h_wire: FullPaytoHash.t;
+  }
+end
+
+module CoinLinkSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_COIN_LINK *)
+  type t = {
+    h_denom_pub: DenominationHash.t;
+    old_coin_pub: CoinSpendPublicKeyP.t;
+    transfer_pub: TransferPublicKeyP.t;
+    coin_envelope_hash: BlindedCoinHash.t;
+  }
+end
+
+module RefreshNonceSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_COIN_LINK *)
+  type t = { nonce: PublicRefreshCoinNonceP.t }
+end
+
+module ReserveStatusRequestSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_RESERVE_STATUS_REQUEST *)
+  type t = { request_timestamp: TimeAbsoluteNBO.t }
+end
+
+module ReserveHistoryRequestSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_RESERVE_HISTORY_REQUEST *)
+  type t = {
+    history_fee: AmountNBO.t;
+    request_timestamp: TimeAbsoluteNBO.t;
+  }
+end
+
+module PurseStatusRequestSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_PURSE_STATUS_REQUEST *)
+  type t = unit
+end
+
+module PurseStatusResponseSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_PURSE_STATUS_RESPONSE *)
+  type t = {
+    total_purse_amount: AmountNBO.t;
+    total_deposit_amount: AmountNBO.t;
+    max_deposit_fees: AmountNBO.t;
+    purse_expiration: TimeAbsoluteNBO.t;
+    status_timestamp: TimeAbsoluteNBO.t;
+    h_contract_terms: PrivateContractHash.t;
+  }
+end
+
+module ReserveCloseRequestSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_RESERVE_CLOSE *)
+  type t = unit
+end
+
+module PurseRequestSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_PURSE_CREATE *)
+  type t = {
+    purse_expiration: TimeAbsoluteNBO.t;
+    merge_value_after_fees: AmountNBO.t;
+    h_contract_terms: PrivateContractHash.t;
+    min_age: int;
+  }
+end
+
+module PurseDepositSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_PURSE_DEPOSIT *)
+  type t = {
+    coin_contribution: AmountNBO.t;
+    h_denom_pub: DenominationHash.t;
+    h_age_commitment: AgeCommitmentHash.t;
+    purse_pub: PursePublicKey.t;
+    h_exchange_base_url: Hash_64_cstr.t;
+  }
+end
+
+module PurseDepositSignaturePS2 = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_RESERVE_OPEN_DEPOSIT *)
+  type t = {
+    reserve_sig: ReserveSignatureP.t;
+    coin_contribution: AmountNBO.t;
+  }
+end
+
+module PurseDepositConfirmedSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_PURSE_DEPOSIT_CONFIRMED *)
+  type t = {
+    total_purse_amount: AmountNBO.t;
+    total_deposit_fees: AmountNBO.t;
+    purse_pub: PursePublicKey.t;
+    purse_expiration: TimeAbsoluteNBO.t;
+    h_contract_terms: PrivateContractHash.t;
+  }
+end
+
+module PurseMergeSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_PURSE_MERGE *)
+  type t = {
+    merge_timestamp: TimeAbsoluteNBO.t;
+    h_wire: NormalizedPaytoHash.t;
+  }
+end
+
+module AccountMergeSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_ACCOUNT_MERGE *)
+  type t = {
+    reserve_pub: ReservePublicKeyP.t;
+    purse_pub: PursePublicKey.t;
+    merge_amount_after_fees: AmountNBO.t;
+    merge_timestamp: TimeAbsoluteNBO.t;
+    purse_expiration: TimeAbsoluteNBO.t;
+    h_contract_terms: PrivateContractHash.t;
+    min_age: int;
+  }
+end
+
+module AccountSetupRequestSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_ACCOUNT_SETUP *)
+  type t = { threshold: AmountNBO.t }
+end
+
+module PurseMergeSuccessSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_PURSE_MERGE_SUCCESS *)
+  type t = {
+    reserve_pub: ReservePublicKeyP.t;
+    purse_pub: PursePublicKey.t;
+    merge_amount_after_fees: AmountNBO.t;
+    contract_time: TimeAbsoluteNBO.t;
+    h_contract_terms: PrivateContractHash.t;
+    h_wire: NormalizedPaytoHash.t;
+    min_age: int;
+  }
+end
+
+module WadDataSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WAD_DATA *)
+  type t = {
+    wad_execution_time: TimeAbsoluteNBO.t;
+    total_amount: AmountNBO.t;
+    h_items: Hash_64_cstr.t;
+    wad_id: WadId.t;
+  }
+end
+
+module WadPartnerSignaturePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_PARTNER_DETAILS *)
+  type t = {
+    h_partner_base_url: Hash_64_cstr.t;
+    master_public_key: MasterPublicKeyP.t;
+    start_date: TimeAbsoluteNBO.t;
+    end_date: TimeAbsoluteNBO.t;
+    wad_fee: AmountNBO.t;
+    wad_frequency: TimeRelativeNBO.t;
+  }
+end
+
+module P2PFeesPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_P2P_FEES *)
+  type t = {
+    start_date: TimeAbsoluteNBO.t;
+    end_date: TimeAbsoluteNBO.t;
+    kyc_fee: AmountNBO.t;
+    purse_fee: AmountNBO.t;
+    account_history_fee: AmountNBO.t;
+    account_annual_fee: AmountNBO.t;
+    account_kyc_timeout: TimeRelativeNBO.t;
+    purse_timeout: TimeRelativeNBO.t;
+    purse_account_limit: int;
+  }
+end
+
+module CoinPurseRefundConfirmationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_CONFIRM_PURSE_REFUND *)
+  type t = {
+    purse_pub: PursePublicKey.t;
+    coin_pub: CoinSpendPublicKeyP.t;
+    refunded_amount: AmountNBO.t;
+    refund_fee: AmountNBO.t;
+  }
+end
+
+module MasterDenominationKeyRevocationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_DENOMINATION_KEY_REVOKED *)
+  type t = { h_denom_pub: DenominationHash.t }
+end
+
+module MasterSigningKeyRevocationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_SIGNING_KEY_REVOKED *)
+  type t = { exchange_pub: ExchangePublicKeyP.t }
+end
+
+module MasterAddAuditorPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_ADD_AUDITOR *)
+  type t = {
+    start_date: TimeAbsoluteNBO.t;
+    auditor_pub: AuditorPublicKeyP.t;
+    h_auditor_url: Hash_64_cstr.t;
+  }
+end
+
+module MasterDelAuditorPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_DEL_AUDITOR *)
+  type t = {
+    end_date: TimeAbsoluteNBO.t;
+    auditor_pub: AuditorPublicKeyP.t;
+  }
+end
+
+module MasterAddWirePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_ADD_WIRE *)
+  type t = {
+    start_date: TimeAbsoluteNBO.t;
+    h_wire: FullPaytoHash.t;
+    h_conversion_url: Hash_64_cstr.t;
+    h_credit_restrictions: Hash_64_cstr.t;
+    h_debit_restrictions: Hash_64_cstr.t;
+  }
+end
+
+module MasterDelWirePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_DEL_WIRE *)
+  type t = {
+    end_date: TimeAbsoluteNBO.t;
+    h_wire: FullPaytoHash.t;
+  }
+end
+
+module MasterAmlOfficerStatusPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_AML_KEY *)
+  type t = {
+    change_date: TimestampNBO.t;
+    officer_pub: AmlOfficerPublicKeyP.t;
+    h_officer_name: Hash_64_cstr.t;
+    is_active: int;
+  }
+end
+
+module AmlDecisionPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_AML_DECISION *)
+  type t = {
+    h_justification: Hash_64_cstr.t;
+    decision_time: TimestampNBO.t;
+    new_threshold: AmountNBO.t;
+    h_payto: NormalizedPaytoHash.t;
+    h_kyc_requirements: Hash_64_cstr.t;
+    new_state: int;
+  }
+end
+
+module PartnerConfigurationPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_MASTER_PARNTER_DETAILS *)
+  type t = {
+    partner_pub: MasterPublicKeyP.t;
+    start_date: TimestampNBO.t;
+    end_date: TimestampNBO.t;
+    wad_frequency: TimeRelativeNBO.t;
+    wad_fee: AmountNBO.t;
+    h_url: Hash_64_cstr.t;
+  }
+end
+
+module ReserveOpenPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_RESERVE_OPEN *)
+  type t = {
+    reserve_payment: AmountNBO.t;
+    request_timestamp: TimestampNBO.t;
+    reserve_expiration: TimestampNBO.t;
+    purse_limit: int;
+  }
+end
+
+module ReserveClosePS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_RESERVE_CLOSE *)
+  type t = {
+    request_timestamp: TimestampNBO.t;
+    target_account_h_payto: FullPaytoHash.t;
+  }
+end
+
+module ReserveAttestRequestPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_WALLET_ATTEST_REQUEST *)
+  type t = {
+    request_timestamp: TimestampNBO.t;
+    h_details: Hash_64_cstr.t;
+  }
+end
+
+module ExchangeAttestPS = struct
+  (* purpose.purpose = TALER_SIGNATURE_EXCHANGE_RESERVE_ATTEST_DETAILS *)
+  type t = {
+    attest_timestamp: TimestampNBO.t;
+    expiration_time: TimestampNBO.t;
+    reserve_pub: ReservePublicKeyP.t;
+    h_attributes: Hash_64_cstr.t;
+  }
+end
diff --git a/src/bin_type.ml b/src/bin_type.ml
new file mode 100644
index 00000000..38d047b5
--- /dev/null
+++ b/src/bin_type.ml
@@ -0,0 +1,269 @@
+(* https://docs.taler.net/core/api-common.html#binary-formats
+
+   numeric values are in network byte order (big endian) *)
+
+(* structs that are 'packed' and do not contain pointers and are
+   thus suitable for hashing or similar operations are distinguished
+   by adding a 'P' at the end of the name.
+   (NEW) Note that this convention does not hold for the GNUnet-structs (yet).
+
+   structs that are used with a purpose for signatures,
+   additionally get an 'S' at the end of the name.
+
+   (from https://docs.taler.net/taler-developer-manual.html) *)
+
+(* TODO
+   - correctly handle endianness
+   - check that our struct are well packed
+     - it looks like Bin only define packed structs
+     - we don't need to worry about struct having "P" suffix
+       remove them
+   - test them
+   - union: not sure what to do of them
+     not needed or relevant i think
+   - some purpose (`TALER_SIGNATURE_XXX`) are missing
+     - exchange and gana master branch are not in sync
+       and we should use a specific git tag instead
+     - outdated doc(?)
+   - some missing struct documentation
+
+   - better way to have module aliases?
+   *)
+
+(* TODO hash and C(ancer)-terminated strings
+
+   - "A JSON object is canonicalized by converting it to an ASCII byte array
+      with the algorithm specified in RFC 8785. The resulting bytes are
+      terminated with a single 0-byte and then hashed with SHA512."
+   - from the code it looks like its the same for all stringy-strings
+     ! not strings that are raw-bytes-data-like
+     ? only for "HashCode" and "ShortHashCode"
+ *)
+
+module Taler_signatures = Include.Taler_signatures
+open Crypto
+
+let int32_size = 4
+let int64_size = 8
+
+module Bytes_32 = struct
+  type t = string
+
+  let bin = Bin.bytes 32
+end
+
+module Bytes_64 = struct
+  type t = string
+
+  let bin = Bin.bytes 64
+end
+
+(* -- Time -- *)
+module type Time_S = sig
+  type t = Timestamp.t
+
+  val bin : t Bin.t
+end
+
+module TIME : Time_S = struct
+  type t = Timestamp.t
+
+  let bin = Timestamp.bin
+end
+
+module TIME_NBO : Time_S = struct
+  type t = Timestamp.t
+
+  let bin = Timestamp.bin_nbo
+end
+
+module TimeAbsolute : Time_S = TIME
+module TimeAbsoluteNBO : Time_S = TIME_NBO
+module TimeRelative : Time_S = TIME
+module TimeRelativeNBO : Time_S = TIME_NBO
+
+(* -- Cryptographic primitives -- *)
+
+(* Hashes *)
+
+module Hash_32 = struct
+  type t = Digestif.SHA256.t
+
+  let hash s = Digestif.SHA256.(digest_string s)
+
+  let of_octets s =
+    match String.length s = 32 with
+    | false -> Fmt.failwith "Hash.of_octets failure: data is not 32 bytes"
+    | true -> Digestif.SHA256.of_raw_string s
+
+  let to_octets = Digestif.SHA256.to_raw_string
+
+  let bin =
+    let open Bin in
+    map (bytes 32) of_octets to_octets
+
+  let caqti : t Caqti_type.t =
+    let open Caqti_type in
+    custom
+      ~encode:(fun v -> Ok (to_octets v))
+      ~decode:(fun v -> Ok (of_octets v))
+      octets
+end
+
+module Hash_64 = struct
+  type t = Digestif.SHA512.t
+
+  let hash s = Digestif.SHA512.(digest_string s)
+
+  let of_octets s =
+    match String.length s = 64 with
+    | false -> Fmt.failwith "Hash.of_octets failure: data is not 64 bytes"
+    | true -> Digestif.SHA512.of_raw_string s
+
+  let to_octets v =
+    let s = Digestif.SHA512.to_raw_string v in
+    match String.length s = 64 with
+    | false -> Fmt.failwith "Hash.to_octets failure: data is not 64 bytes"
+    | true -> s
+
+  let bin =
+    let open Bin in
+    map (bytes 64) of_octets to_octets
+
+  let caqti : t Caqti_type.t =
+    let open Caqti_type in
+    custom
+      ~encode:(fun v -> Ok (to_octets v))
+      ~decode:(fun v -> Ok (of_octets v))
+      octets
+end
+
+(* Hash over string + '\0' *)
+module Hash_32_cstr = struct
+  include Hash_32
+
+  let hash s =
+    let s = s ^ "\x00" in
+    Digestif.SHA256.(digest_string s)
+end
+
+module Hash_64_cstr = struct
+  include Hash_64
+
+  let hash s =
+    let s = s ^ "\x00" in
+    Digestif.SHA512.(digest_string s)
+end
+
+module type Hash_S = sig
+  type t
+
+  val bin : t Bin.t
+  val caqti : t Caqti_type.t
+  val hash : string -> t
+  val of_octets : string -> t
+  val to_octets : t -> string
+end
+
+module FullPaytoHash : Hash_S = Hash_32
+module NormalizedPaytoHash : Hash_S = Hash_32
+module DenominationHash : Hash_S = Hash_64
+module PrivateContractHash : Hash_S = Hash_64
+module ExtensionsPolicyHash : Hash_S = Hash_64
+module MerchantWireHash : Hash_S = Hash_64
+module AgeCommitmentHash : Hash_S = Hash_64
+module BlindedCoinHash : Hash_S = Hash_64
+module CoinPubHash : Hash_S = Hash_64
+module OutputCommitmentHash : Hash_S = Hash_64
+module HashPlanchetsP : Hash_S = Hash_64
+
+(* --- Various --- *)
+
+module TransferSecretP = Bytes_64
+module LinkSecretP = Bytes_64
+module EncryptedLinkSecretP = Bytes_64
+module BlindingMasterSeed = Bytes_32
+module BlindingMasterSecret = Bytes_32
+module WireTransferIdentifierRawP = Bytes_32
+module PublicRefreshCoinNonceP = Bytes_64
+
+(* TODO ? need to use/save a specific nonce for cryptographic blinding *)
+(* Secret for blinding/unblinding.
+   An RSA blinding secret, which is basically
+   a 256-bit nonce, converted to Crockford `Base32`.
+
+   type DenominationBlindingKeyP = string; *)
+module DenominationBlindingKeyP = Bytes_32
+module RefreshCommitmentP = Bytes_64
+
+(* -- TODO better: -- *)
+module UUID = struct
+  (* uint32t value[4]; *)
+  type t = { value: string }
+
+  let size = 4 * int32_size
+
+  let bin =
+    let open Bin in
+    record (fun value -> { value })
+    |+ field (bytes size) (fun t -> t.value)
+    |> sealr
+end
+
+module WadId = struct
+  (* uint32t value[6]; *)
+  type t = { raw: string }
+
+  let size = 6 * int32_size
+
+  let bin =
+    let open Bin in
+    record (fun raw -> { raw }) |+ field (bytes size) (fun t -> t.raw) |> sealr
+end
+
+module AgeMask = struct
+  type t = { mask: int32 }
+
+  let bin =
+    let open Bin in
+    record (fun mask -> { mask }) |+ field beint32 (fun t -> t.mask) |> sealr
+end
+
+(* TODO keep this?
+   some of those are actuall ecdhe, or union of eddsa|ecdhe *)
+module Aliases = struct
+  module TimestampNBO : Time_S = struct
+    type t = Timestamp.t
+
+    let bin = Timestamp.bin_nbo
+  end
+
+  module AmountNBO = struct
+    type t = Amount.t
+
+    let bin = Amount.bin_nbo
+  end
+
+  (* - Keys - *)
+  module PursePublicKey = EddsaPublicKey
+  module AuditorPublicKeyP = EddsaPublicKey
+  module ReservePublicKeyP = EddsaPublicKey
+  module MerchantPublicKeyP = EddsaPublicKey
+  module TransferPublicKeyP = EddsaPublicKey
+  module AmlOfficerPublicKeyP = EddsaPublicKey
+  module ExchangePublicKeyP = EddsaPublicKey
+  module MasterPublicKeyP = EddsaPublicKey
+  module CoinSpendPublicKeyP = EddsaPublicKey
+  module TokenPublicKeyP = EddsaPublicKey
+  module ReservePrivateKeyP = EddsaPrivateKey
+  module MerchantPrivateKeyP = EddsaPrivateKey
+  module TransferPrivateKeyP = EddsaPrivateKey
+  module AmlOfficerPrivateKeyP = EddsaPrivateKey
+  module ExchangePrivateKeyP = EddsaPrivateKey
+  module MasterPrivateKeyP = EddsaPrivateKey
+  module CoinSpendPrivateKeyP = EddsaPrivateKey
+  module MasterSignatureP = EddsaSignature
+  module ReserveSignatureP = EddsaSignature
+  module ExchangeSignatureP = EddsaSignature
+  module CoinSpendSignatureP = EddsaSignature
+end
diff --git a/src/config.ml b/src/config.ml
new file mode 100644
index 00000000..e3c112ee
--- /dev/null
+++ b/src/config.ml
@@ -0,0 +1,196 @@
+open Parse_config
+
+let config_data =
+  let path = Fpath.to_string (Fpath.v "default.config") in
+  match Assets_crunch.read path with
+  | None -> fail "static file not found: `%s`" path
+  | Some data ->
+      let v = Parse_data.parse data in
+      v
+
+module Exchange = struct
+  let get_opt field = get_opt config_data ~section:"exchange" ~field
+  let get field = get config_data ~section:"exchange" ~field
+
+  (* - *)
+  let currency = (* todo: constraint on currency string *) get "currency"
+  let currency_round_unit = get "currency_round_unit" |> amount
+  let db = get "db" |> const_value "postgres"
+  let attribute_encryption_key = get "attribute_encryption_key"
+  let port = get "port" |> int
+  let bind_to = get "bind_to"
+  let master_public_key = get "master_public_key" |> ed25519
+  let stefan_abs = get "stefan_abs" |> amount
+  let stefan_log = get "stefan_log" |> amount
+  let stefan_lin = get_opt "stefan_lin" |> Option.map float
+
+  let aggregator_idle_sleep_interval =
+    get "aggregator_idle_sleep_interval" |> duration
+
+  let closer_idle_sleep_interval = get "closer_idle_sleep_interval" |> duration
+
+  let transfer_idle_sleep_interval =
+    get "transfer_idle_sleep_interval" |> duration
+
+  let wirewatch_idle_sleep_interval =
+    get "wirewatch_idle_sleep_interval" |> duration
+
+  let signkey_legal_duration = get "signkey_legal_duration" |> duration
+  let max_keys_caching = get "max_keys_caching" |> duration
+  let enable_kyc = get "enable_kyc" |> yes_no
+  let terms_etag = get "terms_etag"
+  let privacy_etag = get "privacy_etag"
+
+  (* optional:
+       tiny_amount
+       shopping_url
+       open_banking_gateway_url
+       aml_spa_dialect
+       bank_compliance_language
+       toplevel_redirect_url *)
+  (* not implemented or not relevant to MTE:
+       let max_requests = get "max_requests" |> int
+       base_url
+       aggregator_shard_size
+       serve
+       unixpath
+       unixpath_mode
+       terms_dir
+       privacy_dir *)
+end
+
+module Exchangedb = struct
+  let get field = get config_data ~section:"exchangedb" ~field
+
+  (* - *)
+  let idle_reserve_expiration_time =
+    get "idle_reserve_expiration_time" |> duration
+
+  let legal_reserve_expiration_time =
+    get "legal_reserve_expiration_time" |> duration
+
+  let aggregator_shift = get "aggregator_shift" |> duration
+  let max_aml_program_runtime = get "max_aml_program_runtime" |> duration
+  let default_purse_limit = get "default_purse_limit" |> int
+end
+
+module Exchangedb_postgres = struct
+  let config =
+    get config_data ~section:"exchangedb-postgres" ~field:"config" |> uri
+end
+
+module Currency = struct
+  type t = {
+    enabled: [ `YES | `NO ];
+    code: string;
+    name: string;
+    fractional_input_digits: int;
+    fractional_normal_digits: int;
+    fractional_trailing_zero_digits: int;
+    alt_unit_names: (int * string) list;
+  }
+
+  let currency_sections =
+    List.filter
+      (fun v -> String.starts_with ~prefix:"currency-" v.header)
+      config_data
+
+  let parse_currency section =
+    let get field = get config_data ~section:section.header ~field in
+    {
+      enabled= get "enabled" |> yes_no;
+      code= get "code";
+      name= get "name";
+      fractional_input_digits= get "fractional_input_digits" |> int;
+      fractional_normal_digits= get "fractional_normal_digits" |> int;
+      fractional_trailing_zero_digits=
+        get "fractional_trailing_zero_digits" |> int;
+      alt_unit_names= get "alt_unit_names" |> Parse_alt_unit_names.parse;
+    }
+
+  let all_currencies = List.map parse_currency currency_sections
+
+  (* I think the exchange only handle one currency *)
+  let v =
+    match
+      List.find_opt (fun v -> v.code = Exchange.currency) all_currencies
+    with
+    | None ->
+        fail "section `[currency-%s]` not found, currency `%s` is not defined"
+          Exchange.currency Exchange.currency
+    | Some v -> (
+        match v.enabled = `YES with
+        | false -> fail "currency `%s` is not enabled" Exchange.currency
+        | true -> v)
+end
+
+module Coin = struct
+  type t = {
+    section_name: string;
+    value: Amount.t;
+    duration_withdraw: Ptime.Span.t;
+    duration_spend: Ptime.Span.t;
+    duration_legal: Ptime.Span.t;
+    fee_withdraw: Amount.t;
+    fee_deposit: Amount.t;
+    fee_refresh: Amount.t;
+    fee_refund: Amount.t;
+    cipher: [ (* `CS |*) `RSA ];
+    rsa_keysize: int; (* : int option (only if `RSA) *)
+    age_restricted: [ (*`YES|*) `NO ];
+  }
+
+  let coin_sections =
+    List.filter
+      (fun v ->
+        (* note: here its a '_' not '-' *)
+        String.starts_with ~prefix:"coin_" v.header)
+      config_data
+
+  let parse_coin section =
+    let get field = get config_data ~section:section.header ~field in
+    let section_name =
+      String.sub section.header 5 (String.length section.header - 5)
+    in
+    {
+      section_name;
+      value= get "value" |> amount;
+      duration_withdraw= get "duration_withdraw" |> duration;
+      duration_spend= get "duration_spend" |> duration;
+      duration_legal= get "duration_legal" |> duration;
+      fee_withdraw= get "fee_withdraw" |> amount;
+      fee_deposit= get "fee_deposit" |> amount;
+      fee_refresh= get "fee_refresh" |> amount;
+      fee_refund= get "fee_refund" |> amount;
+      cipher= (get "cipher" |> const_value "RSA" |> fun _s -> `RSA);
+      rsa_keysize= get "rsa_keysize" |> int;
+      age_restricted=
+        ( get "age_restricted" |> yes_no |> function
+          | `NO -> `NO
+          | `YES -> fail "`age_restricted = YES` is not supported" );
+    }
+
+  let all_coins = List.map parse_coin coin_sections
+end
+
+module Exchange_secmod_rsa = struct
+  let get field =
+    let section = "taler-exchange-secmod-" ^ "rsa" in
+    get config_data ~section ~field
+
+  let lookahead_sign = get "lookahead_sign" |> duration
+  let overlap_duration = get "overlap_duration" |> duration
+  (* not relevant: sm_priv_key key_dir unixpath *)
+end
+
+module Exchange_secmod_eddsa = struct
+  let get field =
+    let section = "taler-exchange-secmod-" ^ "eddsa" in
+    get config_data ~section ~field
+
+  let lookahead_sign = get "lookahead_sign" |> duration
+  let overlap_duration = get "overlap_duration" |> duration
+end
+
+(* -- *)
+include Exchange
diff --git a/src/crypto.ml b/src/crypto.ml
new file mode 100644
index 00000000..8fda65f3
--- /dev/null
+++ b/src/crypto.ml
@@ -0,0 +1,159 @@
+(* TODO key format
+   - check what is the exact format in GNUNET
+   - endianess issue? *)
+module EddsaPublicKey = struct
+  (* EdDSA and ECDHE public keys always point on Curve25519
+     and represented  using the standard 256 bits Ed25519 compact format,
+     converted to Crockford Base32. *)
+  open Mirage_crypto_ec.Ed25519
+
+  type t = pub
+
+  let to_octets t = pub_to_octets t
+  let of_octets t = pub_of_octets t |> Result.get_ok
+  let bin = Bin.map (Bin.bytes 32) of_octets to_octets
+
+  let of_b32 s =
+    let open Syntax in
+    let* octets = B32.decode s in
+    match pub_of_octets octets with
+    | Error e -> Fmt.error "%a" Mirage_crypto_ec.pp_error e
+    | Ok pub -> Ok pub
+
+  let to_b32 t = B32.encode (to_octets t)
+  let jsont = Jsont.of_of_string ~kind:"EddsaPublicKey" of_b32 ~enc:to_b32
+end
+
+module EddsaPrivateKey = struct
+  (* EdDSA and ECDHE public keys always point on Curve25519
+     and represented  using the standard 256 bits Ed25519 compact format,
+     converted to Crockford Base32. *)
+  open Mirage_crypto_ec.Ed25519
+
+  type t = priv
+
+  let pub_of_priv = pub_of_priv
+  let to_octets t = priv_to_octets t
+  let of_octets t = priv_of_octets t |> Result.get_ok
+  let bin = Bin.map (Bin.bytes 32) of_octets to_octets
+
+  let of_b32 s =
+    let open Syntax in
+    let* octets = B32.decode s in
+    match priv_of_octets octets with
+    | Error e -> Fmt.error "%a" Mirage_crypto_ec.pp_error e
+    | Ok priv -> Ok priv
+
+  let to_b32 t = B32.encode (to_octets t)
+  let jsont = Jsont.of_of_string ~kind:"EddsaPrivateKey" of_b32 ~enc:to_b32
+end
+
+module EddsaSignature : sig
+  type t
+
+  val sign : key:Mirage_crypto_ec.Ed25519.priv -> string -> t
+  val sign_as_string : key:Mirage_crypto_ec.Ed25519.priv -> string -> string
+  val of_b32 : string -> (t, string) result
+  val to_b32 : t -> string
+  val to_octets : t -> string
+  val of_octets : string -> t
+  val jsont : t Jsont.t
+  val bin : t Bin.t
+end = struct
+  (* TODO key format
+     endianess issue? *)
+  (* EdDSA signatures are transmitted as 64-bytes base32
+     binary-encoded objects with just the R and S values (base32_ binary-only).
+
+     They are signature over a c-struct like `TALER_xxxPS` + with a purpose *)
+  type t = string
+
+  let to_octets t = t
+
+  let of_octets v =
+    match String.length v = 64 with
+    | false ->
+        Fmt.failwith "EddsaSignature.of_octets failure: data is not 64 bytes."
+    | true -> v
+
+  let bin = Bin.map (Bin.bytes 64) of_octets to_octets
+
+  let sign ~key s =
+    (* mirage_crypto: "The result is the concatenation of r and s, as specified in RFC 8032." *)
+    Mirage_crypto_ec.Ed25519.sign ~key s
+
+  let sign_as_string ~key s = sign ~key s
+
+  let check_size t =
+    match String.length t = 64 with
+    | false -> Error "EddsaSignature: invalid string length"
+    | true -> Ok ()
+
+  let of_b32 s =
+    let open Syntax in
+    let* t = B32.decode s in
+    let+ () = check_size t in
+    t
+
+  let to_b32 = B32.encode
+  let jsont = Jsont.of_of_string ~kind:"EddsaSignature" of_b32 ~enc:to_b32
+end
+
+module RsaPublicKey = struct
+  open Mirage_crypto_pk
+
+  type t = Rsa.pub
+
+  let of_octets = Util.Bin_rsa.pub_of_octets
+  let to_octets = Util.Bin_rsa.pub_to_octets
+
+  let of_b32 s =
+    let open Syntax in
+    let* s = B32.decode s in
+    let v = Util.Bin_rsa.pub_of_octets s in
+    let+ v = Rsa.pub ~n:v.n ~e:v.e |> unwrap_err_msg in
+    v
+
+  let to_b32 t = B32.encode (to_octets t)
+  let jsont = Jsont.of_of_string ~kind:"RsaPublicKey" of_b32 ~enc:to_b32
+end
+
+module RsaPrivateKey = struct
+  open Mirage_crypto_pk.Rsa
+
+  type t = priv
+
+  let pub_of_priv = pub_of_priv
+  let of_octets = Util.Bin_rsa.priv_of_octets
+  let to_octets = Util.Bin_rsa.priv_to_octets
+
+  let of_b32 s =
+    let open Syntax in
+    let* s = B32.decode s in
+    Ok (of_octets s)
+
+  let to_b32 t = B32.encode (to_octets t)
+  let jsont = Jsont.of_of_string ~kind:"RsaPrivateKey" of_b32 ~enc:to_b32
+end
+
+module RsaSignature : sig
+  type t
+
+  val to_octets : t -> string
+  val sign : key:Mirage_crypto_pk.Rsa.priv -> string -> t
+  val of_b32 : string -> (t, string) result
+  val to_b32 : t -> string
+  val jsont : t Jsont.t
+end = struct
+  type t = string
+
+  let to_octets t = t
+
+  (* TODO rsa sign *)
+  let sign ~key s =
+    Mirage_crypto_pk.Rsa.decrypt ~crt_hardening:true ~mask:`Yes ~key s
+
+  let of_b32 s = B32.decode s
+  let to_b32 t = B32.encode t
+  let jsont = Jsont.of_of_string ~kind:"RsaSignature" of_b32 ~enc:to_b32
+end
diff --git a/src/data_file.ml b/src/data_file.ml
new file mode 100644
index 00000000..125f6f9a
--- /dev/null
+++ b/src/data_file.ml
@@ -0,0 +1,93 @@
+open Bos.OS
+open Syntax
+open Crypto
+
+let read fname =
+  let* b = File.exists fname in
+  match b with
+  | false -> Ok None
+  | true ->
+      let+ content = File.read fname in
+      Some content
+
+let read_eddsa fname =
+  let+ content_opt = read fname in
+  Option.map EddsaPrivateKey.of_octets content_opt
+
+let read_rsa fname =
+  let+ content_opt = read fname in
+  Option.map RsaPrivateKey.of_octets content_opt
+
+let write_eddsa fname priv = EddsaPrivateKey.to_octets priv |> File.write fname
+let write_rsa fname priv = RsaPrivateKey.to_octets priv |> File.write fname
+
+let load_signkey conn fname =
+  let* opt = read_eddsa fname in
+  match opt with
+  | None -> Ok None
+  | Some priv -> (
+      let pub = EddsaPrivateKey.pub_of_priv priv in
+      let* opt = Pg.lookup_signing_key conn pub in
+      match opt with
+      | None ->
+          Fmt.error_msg
+            "load_signkey error no associated metadata found in database for \
+             signkey `%s`."
+            (Fpath.to_string fname)
+      | Some (stamp_start, stamp_expire, stamp_end) ->
+          (* TODO master_sig *)
+          let master_sig = None in
+          let v =
+            Signkey.
+              { pub; priv; stamp_start; stamp_expire; stamp_end; master_sig }
+          in
+          Ok (Some v))
+
+let load_denom conn ~section_name fname =
+  let* opt = read_rsa fname in
+  match opt with
+  | None -> Ok None
+  | Some priv -> (
+      let pub = RsaPrivateKey.pub_of_priv priv in
+      let h_pub = Bin_type.DenominationHash.hash (RsaPublicKey.to_octets pub) in
+      let* opt = Pg.lookup_denomination_key conn h_pub in
+      match opt with
+      | None ->
+          Fmt.error_msg
+            "load_denom error no associated metadata found in database for \
+             denom `%s`."
+            (Fpath.to_string fname)
+      | Some
+          ( stamp_start,
+            stamp_expire_withdraw,
+            stamp_expire_deposit,
+            stamp_expire_legal,
+            value,
+            fee_withdraw,
+            fee_deposit,
+            fee_refresh,
+            fee_refund,
+            age_mask ) ->
+          (* TODO master_sig *)
+          let master_sig = None in
+          let v =
+            Denomination.
+              {
+                pub;
+                priv;
+                section_name;
+                value;
+                stamp_start;
+                stamp_expire_withdraw;
+                stamp_expire_deposit;
+                stamp_expire_legal;
+                fee_withdraw;
+                fee_deposit;
+                fee_refresh;
+                fee_refund;
+                age_mask;
+                h_pub;
+                master_sig;
+              }
+          in
+          Ok (Some v))
diff --git a/src/database.ml b/src/database.ml
new file mode 100644
index 00000000..07f5661e
--- /dev/null
+++ b/src/database.ml
@@ -0,0 +1,33 @@
+(* TODO
+   - GNU Taler db-events?
+     it seems caqti/pgx does not support it *)
+
+let on_ok req () =
+  let open Vif.Response.Syntax in
+  let* () =
+    Vif.Response.add ~field:"content-type" "text/plain; charset= utf-8"
+  in
+  let* () =
+    Vif.Response.with_string req (Fmt.str "activate_signing_key done~~@.")
+  in
+  Vif.Response.respond `OK
+
+let on_error req err =
+  (* TODO be sure to not leak private data in error messages *)
+  let open Vif.Response.Syntax in
+  let str = Fmt.str "Database error: %a." Caqti_error.pp err in
+  Logs.err (fun m -> m "%s" str);
+  let* () = Vif.Response.with_string req str in
+  Vif.Response.respond `Internal_server_error
+
+(* TODO master_sig *)
+let dummy_master_sig =
+  Option.some @@ Crypto.EddsaSignature.of_octets (String.make 64 '\x00')
+
+let test_activate req server _ =
+  let db_conn = Vif.Server.device Devices.db_connection server in
+  let secmod_signkey = Vif.Server.device Devices.secmod_signkey server in
+  let sm_key = secmod_signkey.sm_key in
+  let sm_key = { sm_key with master_sig= dummy_master_sig } in
+  let res = Pg.activate_signing_key db_conn sm_key in
+  Result.fold ~ok:(on_ok req) ~error:(on_error req) res
diff --git a/src/denomination.ml b/src/denomination.ml
new file mode 100644
index 00000000..32eb469d
--- /dev/null
+++ b/src/denomination.ml
@@ -0,0 +1,71 @@
+open Crypto
+
+type t = {
+  pub: RsaPublicKey.t;
+  priv: RsaPrivateKey.t;
+  section_name: string;
+  value: Amount.t;
+  stamp_start: Timestamp.t;
+  stamp_expire_withdraw: Timestamp.t;
+  stamp_expire_deposit: Timestamp.t;
+  stamp_expire_legal: Timestamp.t;
+  fee_withdraw: Amount.t;
+  fee_deposit: Amount.t;
+  fee_refresh: Amount.t;
+  fee_refund: Amount.t;
+  age_mask: int;
+  h_pub: Bin_type.DenominationHash.t;
+  master_sig: EddsaSignature.t option;
+}
+
+let make
+    ({
+       section_name;
+       value;
+       duration_withdraw;
+       duration_spend;
+       duration_legal;
+       fee_withdraw;
+       fee_deposit;
+       fee_refresh;
+       fee_refund;
+       cipher;
+       rsa_keysize;
+       age_restricted= _;
+     } :
+      Config.Coin.t) =
+  assert (cipher = `RSA);
+
+  let stamp_start = Ptime_clock.now () |> Option.some in
+  let stamp_expire_withdraw =
+    Timestamp.add_span_exn stamp_start (Some duration_withdraw)
+  in
+  let stamp_expire_deposit =
+    Timestamp.add_span_exn stamp_start (Some duration_spend)
+  in
+  let stamp_expire_legal =
+    Timestamp.add_span_exn stamp_start (Some duration_legal)
+  in
+
+  let open Mirage_crypto_pk.Rsa in
+  let priv = generate ~bits:rsa_keysize () in
+  let pub = pub_of_priv priv in
+  let h_pub = Bin_type.DenominationHash.hash (RsaPublicKey.to_octets pub) in
+  let master_sig = None in
+  {
+    pub;
+    priv;
+    section_name;
+    value;
+    stamp_start;
+    stamp_expire_withdraw;
+    stamp_expire_deposit;
+    stamp_expire_legal;
+    fee_withdraw;
+    fee_deposit;
+    fee_refresh;
+    fee_refund;
+    age_mask= 0;
+    h_pub;
+    master_sig;
+  }
diff --git a/src/devices.ml b/src/devices.ml
new file mode 100644
index 00000000..34538354
--- /dev/null
+++ b/src/devices.ml
@@ -0,0 +1,148 @@
+open Syntax
+
+type env = {
+  caqti_switch: Caqti_miou.Switch.t;
+  db_uri: Uri.t;
+}
+
+let db_connection : (env, Caqti_miou.connection) Vif.Device.device =
+  let finally (module Conn : Caqti_miou.CONNECTION) = Conn.disconnect () in
+  Vif.Device.v ~name:"db_connection" ~finally []
+  @@ fun { caqti_switch; db_uri } ->
+  match Caqti_miou_unix.connect ~sw:caqti_switch db_uri with
+  | Error err ->
+      Fmt.failwith "Database connection failure: %a." Caqti_error.pp err
+  | Ok conn -> (
+      match Pg.preflight conn with
+      | Error err ->
+          Fmt.failwith "Database preflight failure: %a." Caqti_error.pp err
+      | Ok () ->
+          Logs.info (fun m -> m "database connection initialized");
+          conn)
+
+module Secmod_signkey = struct
+  (* TODO
+     - key rotation
+     - how many signkey to use?
+       we just use 1 for now *)
+  type t = {
+    sm_key: Signkey.t;
+    keys: Signkey.t list;
+  }
+
+  let dir = Fpath.(v "data" / "secmod_signkey")
+
+  let store_secmod_data t =
+    let* () = Data_file.write_eddsa Fpath.(dir / "sm_key") t.sm_key.priv in
+    t.keys
+    |> List.mapi (fun i key ->
+        let fname = Fpath.(dir / string_of_int i) in
+        (fname, key.Signkey.priv))
+    |> list_iter (fun (fname, key) -> Data_file.write_eddsa fname key)
+
+  let load conn =
+    let error_invalid_state =
+      Fmt.error_msg "secmod_signkey load error: invalid store state."
+    in
+    let* sm_key = Data_file.load_signkey conn Fpath.(dir / "sm_key") in
+    let* keys =
+      let l = List.init 1 (fun i -> Fpath.(dir / string_of_int i)) in
+      let* l =
+        Syntax.list_map (fun fname -> Data_file.load_signkey conn fname) l
+      in
+      match Syntax.opt_list l with
+      | Error () -> error_invalid_state
+      | Ok opt -> Ok opt
+    in
+    match (sm_key, keys) with
+    | None, None -> Ok None
+    | Some sm_key, Some keys -> Ok (Some { sm_key; keys })
+    | _, _ -> error_invalid_state
+
+  let generate_fresh_secmod_data () =
+    let sm_key = Signkey.generate () in
+    let keys = [ Signkey.generate () ] in
+    { sm_key; keys }
+
+  let v =
+    let finally _key = () in
+    Vif.Device.v ~name:"secmod_signkey" ~finally
+      [ Vif.Device.value db_connection ]
+    @@ fun conn (_env : env) ->
+    match load conn with
+    | Ok None ->
+        let t = generate_fresh_secmod_data () in
+        Logs.info (fun m -> m "secmod_signkey initialized with fresh keys");
+        t
+    | Ok (Some v) ->
+        Logs.info (fun m -> m "secmod_signkey initialized from storage");
+        v
+    | Error _ ->
+        (* TODO error: pretty print *)
+        Fmt.failwith "secmod_signkey init failure."
+end
+
+module Secmod_denom = struct
+  type t = {
+    sm_key: Signkey.t;
+    keys: Denomination.t list;
+  }
+
+  let dir = Fpath.(v "data" / "secmod_signkey")
+
+  let store_secmod_data t =
+    let* () = Data_file.write_eddsa Fpath.(dir / "sm_key") t.sm_key.priv in
+    t.keys
+    |> List.mapi (fun i key ->
+        let fname = Fpath.(dir / string_of_int i) in
+        (fname, key.Denomination.priv))
+    |> list_iter (fun (fname, key) -> Data_file.write_rsa fname key)
+
+  let load conn =
+    let error_invalid_state =
+      Fmt.error_msg "secmod_denom load error: invalid store state."
+    in
+    let* sm_key = Data_file.load_signkey conn Fpath.(dir / "sm_key") in
+    let* keys =
+      let* l =
+        let open Config.Coin in
+        Syntax.list_map
+          (fun coin ->
+            let section_name = coin.section_name in
+            let fname = Fpath.(dir / section_name) in
+            (* todo: could check that coin config match db values *)
+            Data_file.load_denom conn ~section_name fname)
+          all_coins
+      in
+      match Syntax.opt_list l with
+      | Error () -> error_invalid_state
+      | Ok opt -> Ok opt
+    in
+    match (sm_key, keys) with
+    | None, None -> Ok None
+    | Some sm_key, Some keys -> Ok (Some { sm_key; keys })
+    | _, _ -> error_invalid_state
+
+  let generate_fresh_secmod_data () =
+    let sm_key = Signkey.generate () in
+    let keys = List.map Denomination.make Config.Coin.all_coins in
+    { sm_key; keys }
+
+  let v =
+    let finally _key = () in
+    Vif.Device.v ~name:"secmod_denom" ~finally
+      [ Vif.Device.value db_connection ]
+    @@ fun conn (_env : env) ->
+    match load conn with
+    | Ok None ->
+        let t = generate_fresh_secmod_data () in
+        Logs.info (fun m -> m "secmod_denom initialized with fresh keys");
+        t
+    | Ok (Some v) ->
+        Logs.info (fun m -> m "secmod_denom initialized from storage");
+        v
+    | Error _ -> Fmt.failwith "secmod_denom init failure."
+end
+
+let secmod_signkey = Secmod_signkey.v
+let secmod_denom = Secmod_denom.v
diff --git a/src/dune b/src/dune
new file mode 100644
index 00000000..2a1a266a
--- /dev/null
+++ b/src/dune
@@ -0,0 +1,45 @@
+(executable
+ (public_name mte)
+ (name mte)
+ (modules mte)
+ (libraries mte))
+
+(library
+ (name mte)
+ (wrapped false)
+ (modules :standard \ mte b32)
+ (libraries
+  b32
+  include
+  ;
+  caqti
+  caqti-miou
+  caqti-miou.unix
+  caqti-driver-pgx
+  bin
+  mirage-crypto
+  digestif
+  duration
+  vif
+  fmt
+  jsont
+  cohttp
+  ptime
+  logs
+  logs.fmt
+  logs.threaded
+  fmt.tty))
+
+(library ; crockford base32
+ (name b32)
+ (modules b32)
+ (libraries base32))
+
+(rule
+ (target assets_crunch.ml)
+ (deps
+  (source_tree ../data/assets/))
+ (action
+  (with-stdout-to
+   %{null}
+   (run ocaml-crunch -m plain ../data/assets -o %{target}))))
diff --git a/src/headers.ml b/src/headers.ml
new file mode 100644
index 00000000..ae740b4f
--- /dev/null
+++ b/src/headers.ml
@@ -0,0 +1,52 @@
+let pp_array pp_item item = Fmt.array ~sep:(Fmt.any ", ") pp_item item
+
+let accept_header_value =
+  let s =
+    Fmt.str "%a"
+      (pp_array Assets.Mimetype.pp_mime)
+      Assets.supported_mimetype_arr
+  in
+  s
+
+let avail_languages_header_value =
+  let s = Fmt.str "%a" (pp_array Fmt.string) Assets.supported_lang_arr in
+  s
+
+let select_mimetype headers =
+  let accept = Vif.Headers.get headers "accept" in
+  Cohttp.Accept.media_ranges accept
+  |> Cohttp.Accept.qsort
+  |> List.filter_map (fun (_q, (m, _p)) -> Assets.Mimetype.of_cohttp_media m)
+  |> List.find_opt Assets.is_supported_mimetype
+
+let select_language headers =
+  let accept_language = Vif.Headers.get headers "accept-language" in
+  Cohttp.Accept.languages accept_language
+  |> Cohttp.Accept.qsort
+  |> List.map (fun (_q, lang) -> lang)
+  |> List.map (function
+    | Cohttp.Accept.AnyLanguage -> Assets.default_lang
+    | Language language_range -> (
+        (* ignore language subtags (e.g. "en-US" -> "en") *)
+        match language_range with
+        | [] -> assert false
+        | primary_tag :: _ -> primary_tag))
+  |> List.find_opt Assets.is_supported_lang
+  |> Option.value ~default:Assets.default_lang
+
+let select_encoding headers =
+  Vif.Headers.get headers "accept-encoding"
+  |> Cohttp.Accept.encodings
+  |> Cohttp.Accept.qsort
+  |> List.map snd
+  |> List.filter_map (function
+    | Cohttp.Accept.Identity -> Some `Identity
+    | Deflate -> Some `DEFLATE
+    | Gzip -> Some `Gzip
+    | AnyEncoding -> Some Assets.default_encoding
+    | Encoding _ | Compress -> (* unsupported *) None)
+  |> function
+  | [] -> assert false
+  | `Identity :: _ -> None
+  | `DEFLATE :: _ -> Some `DEFLATE
+  | `Gzip :: _ -> Some `Gzip
diff --git a/src/headers_lib.ml b/src/headers_lib.ml
new file mode 100644
index 00000000..b26f5da1
--- /dev/null
+++ b/src/headers_lib.ml
@@ -0,0 +1,86 @@
+(* independent library for headers fields value *)
+
+(* TODO - test - can still bypass this module and directly set Etag header, but
+   its fine *)
+module Etag : sig
+  (* module to parse etags header fields used by If-Match and If-None-Match
+     headers
+
+     https://httpwg.org/specs/rfc9110.html#field.etag *)
+  type t
+  type header_value
+
+  val parse : string -> (header_value, string) result
+  val of_crockford32 : string -> (t, string) result
+  val to_raw_string : t -> string
+  val to_field_value : t -> string
+  val evaluate : t -> header_value -> bool
+end = struct
+  (* raw etag *)
+  type t = string
+
+  (* type for the value of header field *)
+  type header_etag_item = {
+    weak: bool;
+    value: string;
+  }
+
+  type header_value =
+    | Any_etag
+    | Etag_list of header_etag_item list
+
+  let pp_header_etag_item ppf { weak; value } =
+    if weak then Fmt.pf ppf {|W/"%s"|} value else Fmt.pf ppf {|"%s"|} value
+
+  let to_raw_string t = t
+
+  let to_field_value t =
+    (* always weak comparison for If-None-Match header *)
+    let v = { weak= true; value= t } in
+    Fmt.str "%a" pp_header_etag_item v
+
+  let is_valid_char c =
+    let n = Char.code c in
+    (n >= 0x21 && n <= 0x7E && n <> 0x22) || (n >= 0x80 && n <= 0xFF)
+
+  let has_valid_charset s = String.for_all is_valid_char s
+
+  let of_crockford32 s =
+    match has_valid_charset s with
+    | false -> Error "invalid etag"
+    | true -> Ok s
+
+  let parse =
+    let open Angstrom in
+    let ws = skip_while (function ' ' -> true | _ -> false) in
+    let quoted_string =
+      char '"' *> take_till (fun c -> c = '"') <* char '"' >>= fun s ->
+      if String.for_all is_valid_char s then return s
+      else fail "found illegal char"
+    in
+    let item =
+      ws
+      *> lift2
+           (fun weak value -> { weak; value })
+           (option false (string "W/" *> return true))
+           quoted_string
+      <* ws
+    in
+    let comma = ws *> char ',' *> ws in
+    let list_of_items = sep_by1 comma item in
+    let parse_header_value =
+      char '*' *> return Any_etag
+      <|> (list_of_items >>| fun items -> Etag_list items)
+      <* end_of_input
+    in
+    fun s ->
+      match parse_string ~consume:Consume.All parse_header_value s with
+      | Error e -> Fmt.error "invalid etag: %s" e
+      | Ok v -> Ok v
+
+  let evaluate t header_value =
+    match header_value with
+    | Any_etag -> false
+    | Etag_list l ->
+        not @@ List.exists (fun { weak= _; value } -> String.equal t value) l
+end
diff --git a/src/management.ml b/src/management.ml
new file mode 100644
index 00000000..1aff93fe
--- /dev/null
+++ b/src/management.ml
@@ -0,0 +1,112 @@
+open Api
+open Devices
+
+let mk_future_denom denom_key_signf
+    ({
+       pub;
+       priv= _;
+       section_name;
+       value;
+       stamp_start;
+       stamp_expire_withdraw;
+       stamp_expire_deposit;
+       stamp_expire_legal;
+       fee_withdraw;
+       fee_deposit;
+       fee_refresh;
+       fee_refund;
+       age_mask;
+       h_pub;
+       master_sig= _;
+     } :
+      Denomination.t) =
+  let denom_pub =
+    DenominationKey.of_rsa RsaDenominationKey.{ age_mask; rsa_pub= pub }
+  in
+  let denom_secmod_sig =
+    let open Bin_signature.DenominationKeyAnnouncementPS in
+    let h_denom_pub = h_pub in
+    let h_section_name = Bin_type.Hash_64_cstr.hash section_name in
+    let anchor_time = stamp_start in
+    let duration_withdraw =
+      Timestamp.diff stamp_start stamp_expire_withdraw |> Timestamp.of_span_exn
+    in
+    Sig.sign denom_key_signf
+      { h_denom_pub; h_section_name; anchor_time; duration_withdraw }
+  in
+  FutureDenom.
+    {
+      section_name;
+      value;
+      stamp_start;
+      stamp_expire_withdraw;
+      stamp_expire_deposit;
+      stamp_expire_legal;
+      denom_pub;
+      fee_withdraw;
+      fee_deposit;
+      fee_refresh;
+      fee_refund;
+      denom_secmod_sig;
+    }
+
+let mk_future_signkey signkey_signf
+    ({ pub; priv= _; stamp_start; stamp_expire; stamp_end; master_sig= _ } :
+      Signkey.t) =
+  let signkey_secmod_sig =
+    let open Bin_signature.SigningKeyAnnouncementPS in
+    let exchange_pub = pub in
+    let anchor_time = stamp_start in
+    let duration =
+      Timestamp.diff stamp_start stamp_expire |> Timestamp.of_span_exn
+    in
+    { exchange_pub; anchor_time; duration }
+    |> Bin.to_string bin
+    |> signkey_signf
+  in
+  FutureSignKey.
+    { key= pub; stamp_start; stamp_expire; stamp_end; signkey_secmod_sig }
+
+let mk_future_keys_response (secmod_signkey : Secmod_signkey.t)
+    (secmod_denom : Secmod_denom.t) =
+  let future_denoms =
+    secmod_denom.keys
+    |> List.filter (fun k -> Option.is_none k.Denomination.master_sig)
+    |> List.map (fun denom ->
+        let signf s =
+          Crypto.EddsaSignature.sign_as_string
+            ~key:secmod_denom.sm_key.Signkey.priv s
+        in
+        mk_future_denom signf denom)
+  in
+  let future_signkeys =
+    secmod_signkey.keys
+    |> List.filter (fun k -> Option.is_none k.Signkey.master_sig)
+    |> List.map (fun signkey ->
+        let signf s =
+          Crypto.EddsaSignature.sign ~key:secmod_denom.sm_key.Signkey.priv s
+        in
+        mk_future_signkey signf signkey)
+  in
+  let master_pub = Config.Exchange.master_public_key in
+  let denom_secmod_public_key = secmod_denom.sm_key.pub in
+  let signkey_secmod_public_key = secmod_signkey.sm_key.pub in
+  FutureKeysResponse.
+    {
+      future_denoms;
+      future_signkeys;
+      master_pub;
+      denom_secmod_public_key;
+      signkey_secmod_public_key;
+    }
+
+let keys_get req server _env =
+  let open Vif.Response in
+  let open Syntax in
+  let secmod_signkey = Vif.Server.device Devices.secmod_signkey server in
+  let secmod_denom = Vif.Server.device Devices.secmod_denom server in
+  let v = mk_future_keys_response secmod_signkey secmod_denom in
+  let s = Api.encode_exn Api.FutureKeysResponse.jsont v in
+  let* () = with_string req s in
+  let* () = add ~field:"content-type" "application/json" in
+  respond `OK
diff --git a/src/mte.ml b/src/mte.ml
new file mode 100644
index 00000000..4f660718
--- /dev/null
+++ b/src/mte.ml
@@ -0,0 +1,53 @@
+(*  MTE - the MirageOS Taler Exchange
+    Copyright (C) 2025 Olivier Pierre <swrup@protonmail.com>
+
+    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, version 3.
+
+    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/>. *)
+
+let hello req _server _env =
+  let open Vif.Response in
+  let open Syntax in
+  let* () = with_string req "Hello~~\n" in
+  let* () = add ~field:"content-type" "text/plain" in
+  respond `OK
+
+let routes =
+  let open Vif.Uri in
+  let open Vif.Route in
+  (*let open Vif.Type in*)
+  [
+    get (rel /?? nil) --> hello;
+    get (rel / "terms" /?? nil) --> Static.terms;
+    get (rel / "privacy" /?? nil) --> Static.privacy;
+    get (rel / "management" / "keys" /?? nil) --> Management.keys_get;
+  ]
+
+let () =
+  Util.Log_reporter.setup ();
+  let cfg =
+    let port = Config.Exchange.port in
+    let sockaddr = Unix.(ADDR_INET (inet_addr_loopback, port)) in
+    Vif.config ~reporter:Util.Log_reporter.reporter sockaddr
+  in
+  Miou_unix.run @@ fun () ->
+  Caqti_miou.Switch.run @@ fun caqti_switch ->
+  let env : Devices.env =
+    { caqti_switch; db_uri= Config.Exchangedb_postgres.config }
+  in
+  let devices =
+    Vif.Devices.
+      [ Devices.db_connection; Devices.secmod_signkey; Devices.secmod_denom ]
+  in
+  let middlewares = Vif.Middlewares.[] in
+  Logs.info (fun m ->
+      m ~tags:(Util.Log_reporter.detail "...") "Starting MTE server");
+  Vif.run ~cfg ~devices ~middlewares routes env
diff --git a/src/parse_config.ml b/src/parse_config.ml
new file mode 100644
index 00000000..0fd672a3
--- /dev/null
+++ b/src/parse_config.ml
@@ -0,0 +1,270 @@
+(* parse config file
+   https://docs.taler.net/manpages/taler-exchange.conf.5.html
+
+   do not support "$"-path expansion*)
+
+open Angstrom
+
+type item = {
+  key: string;
+  value: string;
+}
+
+type section = {
+  header: string;
+  items: item list;
+}
+
+let fail fmt =
+  let k _ppf = exit 1 in
+  Fmt.kpf k Fmt.stderr ("Configuration failure: " ^^ fmt ^^ ".@.")
+
+let is_eol = function '\n' | '\r' -> true | _ -> false
+let is_whitespace = function ' ' | '\t' -> true | _ -> false
+let whitespace = skip_while is_whitespace
+
+module Parse_data = struct
+  type line =
+    | Blank
+    | Comment of string
+    | Header of string
+    | Item of item
+
+  let id =
+    let ident_char = function
+      | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' | '-' -> true
+      | _ -> false
+    in
+    take_while1 ident_char >>| String.lowercase_ascii
+
+  let take_till_end_of_line =
+    take_till is_eol >>= fun s -> return s <* end_of_line
+
+  let blank = whitespace <* end_of_line >>| fun () -> Blank
+
+  let comment =
+    whitespace *> (char '#' <|> char '%') *> take_till_end_of_line >>| fun s ->
+    Comment s
+
+  let header = char '[' *> id <* char ']' <* end_of_line >>| fun s -> Header s
+
+  let item_value =
+    let unquoted_value =
+      take_while1 (fun c -> not (is_whitespace c || is_eol c))
+    in
+    let quoted_value =
+      char '"' *> take_till is_eol >>= fun s ->
+      match String.ends_with ~suffix:"\"" s with
+      | false -> fail "invalid quoted value"
+      | true ->
+          let value = String.sub s 0 (String.length s - 1) in
+          return value
+    in
+    quoted_value <|> unquoted_value
+
+  let item =
+    lift2
+      (fun key value -> Item { key; value })
+      id
+      (whitespace *> char '=' *> whitespace *> item_value)
+    <* end_of_line
+
+  let config = many (choice [ blank; comment; header; item ]) <* end_of_input
+
+  let fold_sections l =
+    let rec loop section_l item_l l =
+      match l with
+      | [] ->
+          if List.is_empty item_l then section_l
+          else fail "invalid configuration structure"
+      | Blank :: tl | Comment _ :: tl -> loop section_l item_l tl
+      | Item item :: tl -> loop section_l (item :: item_l) tl
+      | Header header :: tl ->
+          let section = { header; items= item_l } in
+          loop (section :: section_l) [] tl
+    in
+    loop [] [] (List.rev l)
+
+  let parse s =
+    match parse_string ~consume:All config s with
+    | Error msg -> fail "parse error `%s`" msg
+    | Ok v -> fold_sections v
+end
+
+module Pp_debug = struct
+  let pp_item ppf { key; value } =
+    let open Fmt in
+    match String.contains value '"' || String.contains value ' ' with
+    | false -> pf ppf "%s = %s" key value
+    | true -> pf ppf "%s = \"%s\"" key value
+
+  let pp_line ppf line =
+    let open Fmt in
+    let open Parse_data in
+    match line with
+    | Blank -> Fmt.nop ppf ()
+    | Comment s -> pf ppf "#%s" s
+    | Header s -> pf ppf "[%s]" s
+    | Item item -> pf ppf "%a" pp_item item
+
+  let _pp_lines ppf raw_line_l =
+    let open Fmt in
+    pf ppf "%a" (list ~sep:(any "\n") pp_line) raw_line_l
+
+  let pp_section ppf { header; items } =
+    let open Fmt in
+    pf ppf "[%s]@\n%a" header (list ~sep:(any "\n") pp_item) items
+
+  let pp_config ppf l =
+    let open Fmt in
+    pf ppf "%a" (list ~sep:(any "\n") pp_section) l
+end
+[@@ocaml.warning "-32"]
+
+module Parse_duration = struct
+  type duration_element = {
+    number: int;
+    dunit: [ `Year | `Week | `Day | `Hour | `Minute | `Second ];
+  }
+
+  let integer =
+    take_while1 (function '0' .. '9' -> true | _ -> false) >>= fun s ->
+    match int_of_string_opt s with
+    | None -> fail "expected integer, got `%s`" s
+    | Some i -> return i
+
+  let duration_element =
+    let number = whitespace *> integer in
+    let dunit =
+      whitespace *> take_while1 (fun c -> not (is_whitespace c || is_eol c))
+      >>= function
+      | "year" | "years" -> return `Year
+      | "week" | "weeks" -> return `Week
+      | "day" | "days" -> return `Day
+      | "hour" | "hours" -> return `Hour
+      | "minute" | "minutes" -> return `Minute
+      | "second" | "seconds" | "s" -> return `Second
+      | s -> fail "expected a duration unit, got `%s`" s
+    in
+    lift2 (fun number dunit -> { number; dunit }) number dunit
+
+  let duration = many1 duration_element <* end_of_input
+
+  let dunit_to_seconds u =
+    let rec f = function
+      | `Year -> 365 * f `Day
+      | `Week -> 7 * f `Day
+      | `Day -> 24 * f `Hour
+      | `Hour -> 60 * f `Minute
+      | `Minute -> 60 * f `Second
+      | `Second -> 1
+    in
+    f u
+
+  let ptime_span_of_int64 i =
+    match Ptime.Span.of_float_s (Int64.to_float i) with
+    | None ->
+        fail "ptime_span_of_int64 error: `%Ld` is not a valid ptime span" i
+    | Some ts -> ts
+
+  let to_ptime_span t =
+    let acc =
+      List.fold_left
+        (fun acc { number; dunit } -> acc + (number * dunit_to_seconds dunit))
+        0 t
+    in
+    let acc = Int64.of_int acc in
+    let ptime = ptime_span_of_int64 acc in
+    ptime
+
+  let parse s : duration_element list =
+    match parse_string ~consume:All duration s with
+    | Error msg -> fail "duration parse error `%s`" msg
+    | Ok v -> v
+end
+
+let unwrap_res = function Error e -> fail "`%s`." e | Ok v -> v
+
+let get_opt t ~section ~field =
+  match List.find_opt (fun v -> v.header = section) t with
+  | None -> None
+  | Some v -> (
+      match List.find_opt (fun item -> item.key = field) v.items with
+      | None -> None
+      | Some item -> Some item.value)
+
+let get t ~section ~field =
+  match get_opt t ~section ~field with
+  | None -> fail "option `[%s].%s` not found" section field
+  | Some v -> v
+
+let int s =
+  match int_of_string_opt s with
+  | None -> fail "expected int value, got `%s`" s
+  | Some v -> v
+
+let float s =
+  match float_of_string_opt s with
+  | None -> fail "expected float value, got `%s`" s
+  | Some v -> v
+
+let const_value a b =
+  match a = b with false -> fail "unexpected value `%s`" b | true -> a
+
+let yes_no = function
+  | "NO" -> `NO
+  | "YES" -> `YES
+  | s -> fail "expected `YES`/`NO` value, got `%s`" s
+
+let uri s = Uri.of_string s
+let amount s = s |> Amount.of_string |> unwrap_res
+let duration s = Parse_duration.(s |> parse |> to_ptime_span)
+
+let ed25519 s =
+  s
+  |> B32.decode
+  |> unwrap_res
+  |> Mirage_crypto_ec.Ed25519.pub_of_octets
+  |> Result.map_error (fun e -> Fmt.str "%a" Mirage_crypto_ec.pp_error e)
+  |> unwrap_res
+
+module Parse_alt_unit_names = struct
+  let rm_brackets s =
+    let s = String.trim s in
+    match
+      String.starts_with ~prefix:"{" s && String.ends_with ~suffix:"}" s
+    with
+    | false -> fail "expected json, got `%s`" s
+    | true ->
+        let s = String.sub s 1 (String.length s - 2) in
+        s
+
+  let rm_quotes s =
+    let s = String.trim s in
+    match
+      String.starts_with ~prefix:"\"" s && String.ends_with ~suffix:"\"" s
+    with
+    | false -> fail "expected quoted string, got `%s`" s
+    | true ->
+        let s = String.sub s 1 (String.length s - 2) in
+        s
+
+  let parse s =
+    let s = rm_brackets s in
+    String.split_on_char ',' s
+    |> List.map (String.split_on_char ':')
+    |> List.map (function
+      | [ k; v ] -> (k, v)
+      | _ -> fail "invalid json key-value map")
+    |> List.map (fun (k, v) ->
+        let k = rm_quotes k in
+        let v = rm_quotes v in
+        let k =
+          match int_of_string_opt k with
+          | None ->
+              fail "invalid json key-value map, expected integer key, got `%s`"
+                k
+          | Some k -> k
+        in
+        (k, v))
+end
diff --git a/src/pg.ml b/src/pg.ml
new file mode 100644
index 00000000..b6f6264e
--- /dev/null
+++ b/src/pg.ml
@@ -0,0 +1,164 @@
+open Crypto
+
+module Caqti_type = struct
+  include Caqti_type
+
+  (* TODO add a dune stanza like for prelude:
+     "(flags (:standard -open Prelude))" *)
+  (* we want to use int64 timestamps,
+     not postgresql built-in timestamp type *)
+  let ptime : Ptime.t option t = Timestamp.caqti
+  let time = Timestamp.caqti
+
+  let amount : Amount.t t =
+    let open Amount in
+    custom
+      ~encode:(fun amount -> Ok (amount.value, amount.fraction))
+      ~decode:(fun (value, fraction) ->
+        Amount.make ~sign:None ~currency:Config.currency ~value ~fraction)
+      (t2 int64 int32)
+
+  let age_mask : int t = Caqti_type.int
+
+  let rsa_public : RsaPublicKey.t t =
+    let open RsaPublicKey in
+    custom
+      ~encode:(fun v -> Ok (to_octets v))
+      ~decode:(fun v -> Ok (of_octets v))
+      octets
+
+  let eddsa_public : EddsaPublicKey.t t =
+    let open EddsaPublicKey in
+    custom
+      ~encode:(fun v -> Ok (to_octets v))
+      ~decode:(fun v -> Ok (of_octets v))
+      octets
+
+  let eddsa_signature : EddsaSignature.t t =
+    let open EddsaSignature in
+    custom
+      ~encode:(fun v -> Ok (to_octets v))
+      ~decode:(fun s -> Ok (of_octets s))
+      octets
+
+  include struct
+    (* alias for hash *)
+    open Bin_type
+
+    let fullpayto_hash = FullPaytoHash.caqti
+    let nomalizaedpayto_hash = NormalizedPaytoHash.caqti
+    let denomination_hash = DenominationHash.caqti
+    let privatecontract_hash = PrivateContractHash.caqti
+    let extensionspolicy_hash = ExtensionsPolicyHash.caqti
+    let merchantwire_hash = MerchantWireHash.caqti
+    let agecommitment_hash = AgeCommitmentHash.caqti
+    let blindedcoin_hash = BlindedCoinHash.caqti
+    let coinpub_hash = CoinPubHash.caqti
+    let outputcommitment_hash = OutputCommitmentHash.caqti
+    let planchets_hash = HashPlanchetsP.caqti
+  end
+
+  include Caqti_request.Infix
+end
+
+module type CONN = Caqti_miou.CONNECTION
+
+open Bin_type
+
+let preflight =
+  let l =
+    List.map
+      Caqti_type.(unit ->. unit)
+      [
+        "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL \
+         SERIALIZABLE;";
+        "SET enable_sort=OFF;";
+        "SET enable_seqscan=OFF;";
+        "SET enable_mergejoin=OFF;";
+        "SET search_path TO exchange;";
+      ]
+  in
+  fun (module Conn : Caqti_miou.CONNECTION) ->
+    Syntax.list_iter (fun p -> Conn.exec p ()) l
+
+let lookup_signing_key =
+  let lookup_signing_key =
+    Caqti_type.(eddsa_public ->? t3 time time time)
+      "SELECT valid_from, expire_sign, expire_legal FROM exchange_sign_keys \
+       WHERE exchange_pub=$1"
+  in
+  fun (module Conn : CONN) (exchange_pub : EddsaPublicKey.t) ->
+    Conn.find_opt lookup_signing_key exchange_pub
+
+let activate_signing_key =
+  let insert_signkey =
+    Caqti_type.(t5 eddsa_public time time time eddsa_signature ->. unit)
+      "INSERT INTO exchange_sign_keys (exchange_pub, valid_from, expire_sign, \
+       expire_legal, master_sig) VALUES ($1, $2, $3, $4, $5)"
+  in
+  fun (module Conn : CONN)
+    Signkey.{ pub; priv= _; stamp_start; stamp_expire; stamp_end; master_sig }
+  ->
+    (* TODO master_sig *)
+    let master_sig = master_sig |> Option.get in
+    Conn.exec insert_signkey
+      (pub, stamp_start, stamp_expire, stamp_end, master_sig)
+
+let lookup_denomination_key =
+  let lookup_denomination_key =
+    Caqti_type.(
+      denomination_hash
+      ->? t10 time time time time amount amount amount amount amount age_mask)
+      "SELECT valid_from, expire_withdraw, expire_deposit, expire_legal, coin, \
+       fee_withdraw, fee_deposit, fee_refresh, fee_refund, age_mask FROM \
+       denominations WHERE denom_pub_hash=$1"
+  in
+  fun (module Conn : CONN) (h_denom_pub : DenominationHash.t) ->
+    Conn.find_opt lookup_denomination_key h_denom_pub
+
+let add_denomination_key =
+  let denomination_insert =
+    Caqti_type.(
+      t12 denomination_hash rsa_public eddsa_signature time time time time
+        amount amount amount amount (t2 amount age_mask)
+      ->. unit)
+      "INSERT INTO denominations (denom_pub_hash, denom_pub, master_sig, \
+       valid_from, expire_withdraw, expire_deposit, expire_legal, coin, \
+       fee_withdraw, fee_deposit, fee_refresh, fee_refund, age_mask) VALUES \
+       ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)"
+  in
+  fun (module Conn : CONN)
+    Denomination.
+      {
+        pub;
+        priv= _;
+        section_name= _;
+        value;
+        stamp_start;
+        stamp_expire_withdraw;
+        stamp_expire_deposit;
+        stamp_expire_legal;
+        fee_withdraw;
+        fee_deposit;
+        fee_refresh;
+        fee_refund;
+        age_mask;
+        h_pub;
+        master_sig;
+      }
+  ->
+    (* TODO master_sig *)
+    let master_sig = master_sig |> Option.get in
+    Conn.exec denomination_insert
+      ( h_pub,
+        pub,
+        master_sig,
+        stamp_start,
+        stamp_expire_withdraw,
+        stamp_expire_deposit,
+        stamp_expire_legal,
+        value,
+        fee_withdraw,
+        fee_deposit,
+        fee_refresh,
+        (fee_refund, age_mask) )
diff --git a/src/signkey.ml b/src/signkey.ml
new file mode 100644
index 00000000..2b29662b
--- /dev/null
+++ b/src/signkey.ml
@@ -0,0 +1,29 @@
+open Crypto
+
+(* TODO master_sig
+   not sur how to handle master_sig initialization *)
+type t = {
+  pub: EddsaPublicKey.t;
+  priv: EddsaPrivateKey.t;
+  stamp_start: Timestamp.t;
+  stamp_expire: Timestamp.t;
+  stamp_end: Timestamp.t;
+  (* signature of this key by offline master key *)
+  master_sig: EddsaSignature.t option;
+}
+
+let generate () =
+  (* TODO
+       - look if it exists
+       - if not, create it (TOFU initialization scheme)
+       - write it *)
+  let stamp_start = Ptime_clock.now () |> Option.some in
+  let stamp_expire =
+    Timestamp.add_span_exn stamp_start
+      (Some Config.Exchange.signkey_legal_duration)
+  in
+  let stamp_end = stamp_expire in
+
+  let priv, pub = Mirage_crypto_ec.Ed25519.generate () in
+  let master_sig = None in
+  { pub; priv; stamp_start; stamp_expire; stamp_end; master_sig }
diff --git a/src/static.ml b/src/static.ml
new file mode 100644
index 00000000..a69d2dc0
--- /dev/null
+++ b/src/static.ml
@@ -0,0 +1,83 @@
+(* TODO check for mathcing ETAG with a middleware instead? *)
+(* /terms + /privacy
+   - try to find a response with an acceptable mime-type
+   - pick the version in the most preferred language of the user
+   - apply compression if that is allowed by the client
+   - set ETAG header
+   - If it did not change, a "304 Not Modified" response will be returned
+   - A "Taler-Terms-Version" header is generated to indicate the legal version of the terms
+   - When returning a full response (not a "304 Not Modified"),
+     include a "Avail-Languages" header: a comma-separated list of the languages available *)
+
+module Respond_with = struct
+  open Vif.Response
+  open Syntax
+
+  open struct
+    let error_detail ?hint _status =
+      let open Api in
+      let code = -1 in
+      let s = encode_exn ErrorDetail.jsont { code; hint } in
+      s
+  end
+
+  let bad_request ?hint req =
+    let body = error_detail ?hint `Bad_request in
+    let* () = with_string ?compression:None req body in
+    respond `Bad_request
+
+  let not_modified () =
+    let* () = empty in
+    respond `Not_modified
+
+  let unsupported_media_type req =
+    let body =
+      error_detail ~hint:"no acceptable mimetype" `Unsupported_media_type
+    in
+    let* () = with_string ?compression:None req body in
+    let* () = add ~field:"accept" Headers.accept_header_value in
+    respond `Unsupported_media_type
+end
+
+let aux kind req _server _env =
+  let etag = Assets.etag kind in
+  let headers = Vif.Request.headers req in
+  let has_matching_etag =
+    match Vif.Headers.get headers "if-none-match" with
+    | None -> Ok false
+    | Some s ->
+        Headers_lib.Etag.parse s |> Result.map (Headers_lib.Etag.evaluate etag)
+  in
+  match has_matching_etag with
+  | Error e -> Respond_with.bad_request ~hint:e req
+  | Ok true -> Respond_with.not_modified ()
+  | Ok false -> (
+      match Headers.select_mimetype headers with
+      | None -> Respond_with.unsupported_media_type req
+      | Some mime ->
+          let lang = Headers.select_language headers in
+          let compression = Headers.select_encoding headers in
+          let data = Assets.get_content ~mime ~lang kind in
+          (* -- *)
+          let open Vif.Response in
+          let open Syntax in
+          let* () = with_string ?compression req data in
+          let* () =
+            let etag_field_value = Headers_lib.Etag.to_field_value etag in
+            add ~field:"etag" etag_field_value
+          in
+          let* () =
+            (* todo: is it "taler-privacy-version" for /policy ? *)
+            add ~field:"taler-terms-version" Assets.terms_legal_version
+          in
+          let* () =
+            add ~field:"avail-languages" Headers.avail_languages_header_value
+          in
+          let* () =
+            let content_type = Fmt.str "%a" Assets.Mimetype.pp_mime mime in
+            add ~field:"content-type" content_type
+          in
+          respond `OK)
+
+let terms req _server _env = aux Assets.Terms req _server _env
+let privacy req _server _env = aux Assets.Privacy req _server _env
diff --git a/src/syntax.ml b/src/syntax.ml
new file mode 100644
index 00000000..f354ca6c
--- /dev/null
+++ b/src/syntax.ml
@@ -0,0 +1,48 @@
+let ( let* ) o f = match o with Ok v -> f v | Error _ as e -> e
+let ( let+ ) o f = match o with Ok v -> Ok (f v) | Error _ as e -> e
+
+(* TODO use polymorphic variant for errors *)
+let unwrap_err_msg o = match o with Error (`Msg e) -> Error e | Ok v -> Ok v
+
+let list_iter f l =
+  let err = ref None in
+  try
+    List.iter
+      (fun v ->
+        match f v with
+        | Error _e as e ->
+            err := Some e;
+            raise Exit
+        | Ok () -> ())
+      l;
+    Ok ()
+  with Exit -> ( match !err with None -> assert false | Some v -> v)
+
+let list_map f l =
+  let err = ref None in
+  try
+    Ok
+      (List.map
+         (fun v ->
+           match f v with
+           | Error _e as e ->
+               err := Some e;
+               raise Exit
+           | Ok v -> v)
+         l)
+  with Exit -> ( match !err with None -> assert false | Some v -> v)
+
+let list_fold_left f acc l =
+  List.fold_left
+    (fun acc v ->
+      let* acc = acc in
+      f acc v)
+    (Ok acc) l
+
+let opt_list l =
+  match (List.for_all Option.is_none l, List.for_all Option.is_some l) with
+  | _, true ->
+      let l = List.map Option.get l in
+      Ok (Some l)
+  | true, _ -> Ok None
+  | _, _ -> Error ()
diff --git a/src/timestamp.ml b/src/timestamp.ml
new file mode 100644
index 00000000..710ac992
--- /dev/null
+++ b/src/timestamp.ml
@@ -0,0 +1,69 @@
+type t = Ptime.t option
+type span = Ptime.Span.t option
+
+let diff a b =
+  match (a, b) with
+  | None, _ | _, None -> None
+  | Some a, Some b -> Some (Ptime.diff a b)
+
+let add_span_exn t span =
+  match (t, span) with
+  | None, _ | _, None -> None
+  | Some t, Some span -> (
+      match Ptime.add_span t span with
+      | None -> Fmt.failwith "add_span_exn: not in the range [min;max]"
+      | Some v -> Some v)
+
+let of_span_exn = function
+  | None -> None
+  | Some span -> (
+      match Ptime.of_span span with
+      | None -> Fmt.failwith "of_span_exn: not in the range [min;max]"
+      | Some p -> Some p)
+
+(* -- *)
+
+(* microseconds since the UNIX Epoch, or "never" if None *)
+let jsont =
+  let number_or_never_jsont =
+    let never =
+      let dec s =
+        match s with
+        | "never" -> None
+        | _ -> Jsont.Error.msg Jsont.Meta.none "unexpected string value"
+      in
+      let enc = function None -> "never" | _ -> assert false in
+      Jsont.map ~dec ~enc Jsont.string
+    in
+    let number =
+      let dec n = Ptime.of_float_s n in
+      let enc = function Some n -> Ptime.to_float_s n | _ -> assert false in
+      Jsont.map ~dec ~enc Jsont.number
+    in
+    let enc = function None -> never | Some _ -> number in
+    Jsont.any ~dec_string:never ~dec_number:number ~enc ()
+  in
+  let make t = t in
+  Jsont.Object.map ~kind:"Timestamp" make
+  |> Jsont.Object.mem "t_s" number_or_never_jsont ~enc:Fun.id
+  |> Jsont.Object.finish
+
+(* TODO exn *)
+let ptime_to_int64 ptime = ptime |> Ptime.to_float_s |> Int64.of_float
+
+let ptime_of_int64 i =
+  match Ptime.of_float_s (Int64.to_float i) with
+  | None -> Fmt.failwith "ptime_of_int64 error: `%Ld` is not a valid ptime" i
+  | Some ts -> ts
+
+let encode_int64 = function None -> Int64.max_int | Some p -> ptime_to_int64 p
+let decode_int64 i = if i = Int64.max_int then None else Some (ptime_of_int64 i)
+
+(* UINT64_MAX represents "never". *)
+let bin = Bin.map Bin.neint64 decode_int64 encode_int64
+let bin_nbo = Bin.map Bin.beint64 decode_int64 encode_int64
+
+let caqti : Ptime.t option Caqti_type.t =
+  let encode v = Ok (encode_int64 v) in
+  let decode v = Ok (decode_int64 v) in
+  Caqti_type.custom ~encode ~decode Caqti_type.int64
diff --git a/src/timestamp.mli b/src/timestamp.mli
new file mode 100644
index 00000000..c1ac00ab
--- /dev/null
+++ b/src/timestamp.mli
@@ -0,0 +1,15 @@
+(* TODO time
+   not sure about this *)
+
+type t = Ptime.t option
+type span = Ptime.Span.t option
+
+val diff : t -> t -> span
+val add_span_exn : t -> span -> t
+val of_span_exn : span -> t
+
+(* - *)
+val jsont : t Jsont.t
+val bin : t Bin.t
+val bin_nbo : t Bin.t
+val caqti : Ptime.t option Caqti_type.t
diff --git a/src/util.ml b/src/util.ml
new file mode 100644
index 00000000..52691564
--- /dev/null
+++ b/src/util.ml
@@ -0,0 +1,177 @@
+(* TODO bin
+   - no [Bin.of_string] ? *)
+let bin_of_string bin s =
+  let v = Bin.decode bin s (ref 0) in
+  Ok v
+
+module Bin_rsa = struct
+  (* TODO
+     - need to strip leading zeros?
+     - endianess ok?
+     - tests *)
+  (* RSA public key binary format
+       https://www.gnupg.org/documentation/manuals/gcrypt/MPI-formats.html
+       := { uint16_be: n size; uint16_be: e size; n; e}
+
+    integer in big-endian format (MSB first)
+    leading zeroes are stripped unless they are required to keep a value positive
+    no 0-termination *)
+  (* RSA private key custom format is inspired by the public rsa key format
+     used by secmod to save private key to file *)
+  open Syntax
+
+  module Internal = struct
+    let rev_string len s = String.init len (fun i -> s.[len - 1 - i])
+
+    (* we need reverse bytes because Z.of_bits reads bytes in little endian *)
+    let z_of_bits_be src pos len =
+      String.sub src pos len |> rev_string len |> Z.of_bits
+
+    let z_to_bits_be z =
+      let bits = Z.to_bits z in
+      rev_string (String.length bits) bits
+
+    let check = function false -> Error (`Msg "invalid data") | true -> Ok ()
+
+    let z_array_to_octets (arr : Z.t array) =
+      let nb = Array.length arr in
+      let bits_arr = Array.map z_to_bits_be arr in
+      let len_arr = Array.map String.length bits_arr in
+      let len = (2 * nb) + Array.fold_left ( + ) 0 len_arr in
+      let b = Bytes.make len '\x00' in
+      let pos = ref 0 in
+      Array.iter
+        (fun len ->
+          Bytes.set_uint16_be b !pos len;
+          pos := !pos + 2)
+        len_arr;
+      Array.iteri
+        (fun i bits ->
+          let len = len_arr.(i) in
+          Bytes.blit_string bits 0 b !pos len;
+          pos := !pos + len)
+        bits_arr;
+      Bytes.unsafe_to_string b
+
+    let z_array_of_octets ~nb s =
+      let s_len = String.length s in
+      let* () = check (s_len > 2 * nb) in
+      let pos = ref 0 in
+      let len_arr =
+        Array.init nb (fun _i ->
+            let len = String.get_uint16_be s !pos in
+            pos := !pos + 2;
+            len)
+      in
+      let* () =
+        let len = (2 * nb) + Array.fold_left ( + ) 0 len_arr in
+        check (s_len = len)
+      in
+      let z_arr =
+        Array.init nb (fun i ->
+            let len = len_arr.(i) in
+            let z = z_of_bits_be s !pos len in
+            pos := !pos + len;
+            z)
+      in
+      Ok z_arr
+  end
+
+  open Internal
+
+  let pub_to_octets ({ n; e } : Mirage_crypto_pk.Rsa.pub) =
+    z_array_to_octets [| n; e |]
+
+  let pub_of_octets s =
+    let pub_of_octets s =
+      let* arr = z_array_of_octets ~nb:2 s in
+      match arr with
+      | [| n; e |] ->
+          let* pub = Mirage_crypto_pk.Rsa.pub ~n ~e in
+          Ok pub
+      | _ -> assert false
+    in
+    match pub_of_octets s with
+    | Error (`Msg e) -> Fmt.failwith "rsa pub_of_octets failure: %s@." e
+    | Ok v -> v
+
+  let priv_to_octets ({ e; d; n; p; q; dp; dq; q' } : Mirage_crypto_pk.Rsa.priv)
+      =
+    z_array_to_octets [| e; d; n; p; q; dp; dq; q' |]
+
+  let priv_of_octets s =
+    let priv_of_octets s =
+      let* arr = z_array_of_octets ~nb:8 s in
+      match arr with
+      | [| e; d; n; p; q; dp; dq; q' |] ->
+          let* priv = Mirage_crypto_pk.Rsa.priv ~e ~d ~n ~p ~q ~dp ~dq ~q' in
+          Ok priv
+      | _ -> assert false
+    in
+    match priv_of_octets s with
+    | Error (`Msg e) -> Fmt.failwith "rsa priv_of_octets failure: %s@." e
+    | Ok v -> v
+end
+
+module Log_reporter = struct
+  let detail_tag : string Logs.Tag.def =
+    Logs.Tag.def "Detail tag" ~doc:"" Fmt.string
+
+  let detail s = Logs.Tag.(empty |> add detail_tag s)
+  let time_anchor = Ptime_clock.now () |> Ptime.to_span
+
+  let color_of_log_level = function
+    | Logs.App -> `White
+    | Error -> `Red
+    | Warning -> `Yellow
+    | Info -> `Blue
+    | Debug -> `Magenta
+
+  let reporter : Logs.reporter =
+    let open Fmt in
+    let pp_timestamp = styled `Faint (styled (`Fg `White) (fmt "%04.02f")) in
+    let pp_header ppf v =
+      let color = color_of_log_level (fst v) in
+      let pp = styled (`Fg color) Logs.pp_header in
+      pf ppf "%a" pp v
+    in
+    let pp_src_name =
+      let pp = using Logs.Src.name (styled `Cyan (fmt "%s: ")) in
+      fun ppf v -> if not @@ Logs.Src.equal Logs.default v then pp ppf v
+    in
+    let pp_detail = option (styled `Green (fmt " (%s)")) in
+    let report src lvl ~over k msgf =
+      let ppf =
+        match lvl with
+        | Logs.App -> stdout
+        | Error | Warning | Info | Debug -> stderr
+      in
+      let k _ppf = over (); k () in
+      let with_detail h tags k user_fmt =
+        let detail = Option.bind tags (Logs.Tag.find detail_tag) in
+        let timestamp =
+          Ptime.sub_span (Ptime_clock.now ()) time_anchor
+          |> Option.map Ptime.to_float_s
+          |> Option.value ~default:0.
+        in
+        let k ppf = kpf k ppf "%a@." pp_detail detail in
+        let k ppf = kpf k ppf user_fmt in
+        kpf k ppf "%a %a %a" pp_timestamp timestamp pp_header (lvl, h)
+          pp_src_name src
+      in
+      msgf @@ fun ?header ?tags fmt -> with_detail header tags k fmt
+    in
+    { report }
+
+  (* TODO logs
+     - vif shouldn't use/set the default reporter
+     - Log.err all `Internal_server_error response *)
+  let setup () =
+    let level = Some Logs.Info in
+    Logs.set_level ~all:false level;
+    Fmt_tty.setup_std_outputs ~style_renderer:`Ansi_tty ~utf_8:true ();
+    Logs.Src.set_level Logs.default level;
+    Logs_threaded.enable ();
+    Logs.set_reporter reporter;
+    ()
+end
diff --git a/test/dune b/test/dune
new file mode 100644
index 00000000..1eefa8ef
--- /dev/null
+++ b/test/dune
@@ -0,0 +1,11 @@
+(test
+ (name test)
+ (modules test)
+ (libraries mte fmt))
+
+; TODO
+; cram test?
+; gcc -o a.out ./test/signatures.c && ./a.out > a.output
+; rm ./a.out
+; dune exec ./test/test.exe > b.output
+; cmp -l a.output b.output
diff --git a/test/signatures.c b/test/signatures.c
new file mode 100644
index 00000000..bcebe993
--- /dev/null
+++ b/test/signatures.c
@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdint.h>
+
+struct H64 {
+  uint8_t hash[64];
+};
+struct Hhh {
+  struct H64 hash;
+};
+struct Purpose {
+  uint32_t size;
+  uint32_t purpose;
+};
+
+struct PS {
+  struct Purpose purpose;
+  struct Hhh h;
+  uint32_t noreveal_index;
+};
+
+int main(void) {
+    struct Purpose purpose;
+    struct PS ps;
+
+    purpose.size = 3 * 4 + 64;
+    purpose.purpose = 1050;
+
+    struct Hhh h = {
+        .hash = {
+            .hash = {
+                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, 26, 27, 28, 29, 30, 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,
+                57, 58, 59, 60, 61, 62, 63, 64
+            }
+        }
+    };
+
+    uint32_t noreveal_index = 0;
+
+    ps.purpose = purpose;
+    ps.h = h;
+    ps.noreveal_index = noreveal_index;
+
+
+    fwrite(&ps, sizeof(ps), 1, stdout);
+
+    // printf("\n");
+
+    return 0;
+}
diff --git a/test/test.ml b/test/test.ml
new file mode 100644
index 00000000..4377e198
--- /dev/null
+++ b/test/test.ml
@@ -0,0 +1,111 @@
+let () = Mirage_crypto_rng_unix.use_default ()
+
+let () =
+  let priv = Mirage_crypto_pk.Rsa.generate ~bits:2048 () in
+  let pub = Mirage_crypto_pk.Rsa.pub_of_priv priv in
+  let () =
+    let open Crypto.RsaPrivateKey in
+    let priv' = priv |> to_octets |> of_octets in
+    assert (to_octets priv = to_octets priv')
+  in
+  let () =
+    let open Crypto.RsaPublicKey in
+    let pub' = pub |> to_octets |> of_octets in
+    assert (to_octets pub = to_octets pub')
+  in
+  ()
+
+let get_ok = function Error e -> failwith e | Ok v -> v
+
+let () =
+  let open Api in
+  let check jsont s =
+    let encode v = encode jsont v |> get_ok in
+    let decode v = decode jsont v |> get_ok in
+    let ts = decode s in
+    let s' = encode ts in
+    let ts' = decode s' in
+    let s'' = encode ts' in
+    assert (String.equal s' s'')
+  in
+  let check_bad jsont s =
+    let decode = decode jsont in
+    assert (Result.is_error (decode s))
+  in
+  check Timestamp.jsont {|{"t_s": 123456780}|};
+  check Timestamp.jsont {|{"t_s": "never"}|};
+  check_bad Timestamp.jsont {|{"t_s": "123456780"}|};
+  check_bad Timestamp.jsont {|{"t_s": "agagou"}|};
+
+  (* CS not implemented *)
+  check_bad DenominationKey.jsont
+    {|{"cipher": "CS", "age_mask": 18, "cs_pub": "ouhagag"}|};
+
+  (* TODO test with a valid rsa_pub value *)
+  (* TODO handle "rsa pub_of_octets failure" correctly *)
+  (* check_bad DenominationKey.jsont
+    {|{"cipher": "RSA", "age_mask": 18, "rsa_pub": "agagouh"}|}; *)
+  ()
+
+let () =
+  let open Amount in
+  let v =
+    make ~sign:(Some Sign_plus) ~currency:"EUR" ~value:(Int64.of_int 25)
+      ~fraction:(Int32.of_int 678)
+    |> Result.get_ok
+  in
+  let s = to_string v in
+  let v' = of_string s |> Result.get_ok in
+  assert (v = v');
+  let r = of_string {|~EUR:4.9|} in
+  assert (Result.is_error r);
+  let r = of_string {|+EUR:4.99999999999999999999999|} in
+  assert (Result.is_error r);
+  ()
+
+let () =
+  let open Headers_lib.Etag in
+  let check input = assert (Result.is_ok (parse input)) in
+  let check_bad input = assert (Result.is_error (parse input)) in
+
+  check "*";
+  check "\"foo\"";
+  check "W/\"foo\"";
+  check "\"foo\", \"bar\"";
+  check " W/\"x\" , W/\"y\" , \"z\" ";
+  check "  \"one\" ,  \"two\"  ,  \"three\"  ";
+  check "W/\"a\"";
+  check "  W/\"a\" , \"b\"";
+
+  check_bad "";
+  check_bad "foo";
+  check_bad "W/foo";
+  check_bad "W/\"unterminated";
+  check_bad "\"foo\", W/";
+  check_bad "* , \"bar\"";
+  check_bad "\"a\" \"b\"";
+  check_bad "W/\"a\" W/\"b\"";
+  check_bad "\"fo\x7Fo\"";
+
+  (* TODO trailing comma are valid actually, I think *)
+  check_bad "\"foo\" ,";
+  check_bad ", \"foo\"";
+  ()
+
+(*
+
+let () =
+  let open Binary_formats.WithdrawConfirmationPS in
+  let str64 = String.init 64 (fun i -> Char.unsafe_chr (i + 1)) in
+  let dummy_t = { h_planchets= { hash= str64 }; noreveal_index= 0_l } in
+  let size = Bin.size_of_value bin dummy_t |> Option.get in
+  assert (size = 76);
+
+  (* for cmp test with signatures.c output *)
+  (*
+  let raw_str = Bin.to_string bin dummy_t in
+  Printf.printf "%s" raw_str;
+  *)
+  ()
+
+  *)
diff --git a/tools/dune b/tools/dune
new file mode 100644
index 00000000..dc7b5c6a
--- /dev/null
+++ b/tools/dune
@@ -0,0 +1,7 @@
+(executable
+ (public_name offline)
+ (name offline)
+ (modules offline offline_impl offline_bin)
+ (libraries cmdliner bos fmt mirage-crypto ptime mte vif))
+
+; todo depends on curl
diff --git a/tools/offline.ml b/tools/offline.ml
new file mode 100644
index 00000000..ba191e35
--- /dev/null
+++ b/tools/offline.ml
@@ -0,0 +1,78 @@
+open Cmdliner
+open Cmdliner.Term.Syntax
+open Offline_impl
+
+let default_master_offline_key_file = "data/master_offline_private_key"
+let default_response_file = "response.json"
+let default_request_file = "request.json"
+
+(*let to_term_ret = function Error e -> `Error (false, e) | Ok () -> `Ok ()*)
+let to_term_ret = Fun.id
+
+let setup_cmd =
+  let doc = "Generate offline master keys" in
+  let output =
+    Arg.(
+      value
+      & opt filepath default_master_offline_key_file
+      & info [ "o"; "output" ] ~doc)
+  in
+  Cmd.make (Cmd.info "setup" ~doc)
+  @@
+  let+ output = output in
+  setup ~output |> to_term_ret
+
+let download_cmd =
+  let doc = "GET /management/keys/" in
+  let man =
+    [ `S Manpage.s_description; `P "$(cmd) download /management/keys." ]
+  in
+  let output =
+    Arg.(
+      value & opt filepath default_response_file & info [ "o"; "output" ] ~doc)
+  in
+  Cmd.make (Cmd.info "download" ~doc ~man)
+  @@
+  let+ output = output in
+  download ~output |> to_term_ret
+
+let upload_cmd =
+  let doc = "POST /management/keys/" in
+  let man =
+    [ `S Manpage.s_description; `P "$(cmd) upload /management/keys." ]
+  in
+  let input =
+    Arg.(value & opt file default_request_file & info [ "i"; "input" ] ~doc)
+  in
+  Cmd.make (Cmd.info "upload" ~doc ~man)
+  @@
+  let+ input = input in
+  upload ~input |> to_term_ret
+
+let sign_cmd =
+  let doc = "Sign FutureKeysResponse." in
+  let master_key =
+    let doc = "Master offline Eddsa private key file." in
+    Arg.(value & opt file default_master_offline_key_file & info [ "key" ] ~doc)
+  in
+  let input =
+    Arg.(value & opt file default_response_file & info [ "i"; "input" ] ~doc)
+  in
+  let output =
+    Arg.(
+      value & opt filepath default_request_file & info [ "o"; "output" ] ~doc)
+  in
+  Cmd.make (Cmd.info "sign" ~doc)
+  @@
+  let+ input = input and+ output = output and+ master_key = master_key in
+  sign ~input ~output ~master_key |> to_term_ret
+
+let cli =
+  let info =
+    let doc = "MTE Offline CLI tool" in
+    Cmd.info "mte-offline" ~doc
+  in
+  Cmd.group info [ setup_cmd; download_cmd; sign_cmd; upload_cmd ]
+
+let main () = Cmd.eval_result cli
+let () = if !Sys.interactive then () else exit (main ())
diff --git a/tools/offline_bin.ml b/tools/offline_bin.ml
new file mode 100644
index 00000000..1919706d
--- /dev/null
+++ b/tools/offline_bin.ml
@@ -0,0 +1,84 @@
+open Crypto
+open Bin_type
+open Api
+
+let denom_signature ~master_key
+    FutureDenom.
+      {
+        section_name= _;
+        value;
+        stamp_start;
+        stamp_expire_withdraw;
+        stamp_expire_deposit;
+        stamp_expire_legal;
+        denom_pub;
+        fee_withdraw;
+        fee_deposit;
+        fee_refresh;
+        fee_refund= _;
+        (* TODO check sigs *)
+        denom_secmod_sig= _;
+      } =
+  let octets = DenominationKey.to_octets denom_pub in
+  let h_denom_pub = HashCode.hash octets in
+  let master_sig =
+    let open Bin_signature.DenominationKeyValidityPS in
+    let master = EddsaPrivateKey.(pub_of_priv master_key) in
+    let denom_hash = DenominationHash.hash octets in
+    {
+      master;
+      start= stamp_start;
+      expire_withdraw= stamp_expire_withdraw;
+      expire_spend= stamp_expire_deposit;
+      expire_legal= stamp_expire_legal;
+      value;
+      fee_withdraw;
+      fee_deposit;
+      fee_refresh;
+      denom_hash;
+    }
+    |> Bin.to_string bin
+    |> EddsaSignature.sign ~key:master_key
+  in
+  DenomSignature.{ h_denom_pub; master_sig }
+
+let signkey_signature ~master_key
+    FutureSignKey.
+      {
+        key;
+        stamp_start;
+        stamp_expire;
+        stamp_end;
+        (* TODO check sigs *)
+        signkey_secmod_sig= _;
+      } =
+  let master_sig =
+    let open Bin_signature.ExchangeSigningKeyValidityPS in
+    {
+      start= stamp_start;
+      expire= stamp_expire;
+      end_= stamp_end;
+      signkey_pub= key;
+    }
+    |> Bin.to_string bin
+    |> EddsaSignature.sign ~key:master_key
+  in
+  SignKeySignature.{ key; master_sig }
+
+let make_master_signatures ~master_key
+    FutureKeysResponse.
+      {
+        future_denoms;
+        future_signkeys;
+        (* TODO check sigs *)
+        master_pub= _;
+        denom_secmod_public_key= _;
+        signkey_secmod_public_key= _;
+      } =
+  let denom_sigs = List.map (denom_signature ~master_key) future_denoms in
+  let signkey_sigs = List.map (signkey_signature ~master_key) future_signkeys in
+  MasterSignatures.{ denom_sigs; signkey_sigs }
+
+let verify_future_key_response _future_key_response =
+  (* TODO *)
+  Ok ()
diff --git a/tools/offline_impl.ml b/tools/offline_impl.ml
new file mode 100644
index 00000000..2a0c09f4
--- /dev/null
+++ b/tools/offline_impl.ml
@@ -0,0 +1,55 @@
+open Syntax
+
+let read_file fname = Bos.OS.File.read (Fpath.v fname) |> unwrap_err_msg
+
+let write_file fname content =
+  Bos.OS.File.write (Fpath.v fname) content |> unwrap_err_msg
+
+let base_url = Uri.of_string "http://localhost:3434/"
+
+let management_keys_url =
+  Uri.with_path base_url "/management/keys/" |> Uri.to_string
+
+let download ~output =
+  let open Bos in
+  let uri = management_keys_url in
+  OS.Cmd.run Cmd.(v "curl" % "-s" % "-o" % output % "-X" % "GET" % uri)
+  |> unwrap_err_msg
+
+let upload ~input =
+  let open Bos in
+  let uri = management_keys_url in
+  OS.Cmd.run
+    Cmd.(
+      v "curl"
+      % "-i"
+      % "-X"
+      % "POST"
+      % "-H"
+      % "Content-Type: application/json"
+      % "--data"
+      % ("@" ^ input)
+      % uri)
+  |> unwrap_err_msg
+
+let setup ~output =
+  let () = Mirage_crypto_rng_unix.use_default () in
+  let priv, pub = Mirage_crypto_ec.Ed25519.generate () in
+  Fmt.pr "generated master public key:@\n%s@."
+    (Mirage_crypto_ec.Ed25519.pub_to_octets pub |> B32.encode);
+  let priv_data = Mirage_crypto_ec.Ed25519.priv_to_octets priv in
+  write_file output priv_data
+
+let sign ~master_key ~input ~output =
+  let open Crypto in
+  let* input = read_file input in
+  let* master_key = read_file master_key in
+  let master_key = EddsaPrivateKey.of_octets master_key in
+  let* future_key_response = Api.decode Api.FutureKeysResponse.jsont input in
+  let* () = Offline_bin.verify_future_key_response future_key_response in
+  let master_signatures =
+    Offline_bin.make_master_signatures ~master_key future_key_response
+  in
+  let* s = Api.encode Api.MasterSignatures.jsont master_signatures in
+  let* () = write_file output s in
+  Ok ()