diff --git a/bridges/.gitignore b/bridges/.gitignore
deleted file mode 100644
index 5d10cfa41a..0000000000
--- a/bridges/.gitignore
+++ /dev/null
@@ -1,26 +0,0 @@
-**/target/
-**/.env
-**/.env2
-**/rust-toolchain
-hfuzz_target
-hfuzz_workspace
-**/Cargo.lock
-
-**/*.rs.bk
-
-*.o
-*.so
-*.rlib
-*.dll
-.gdb_history
-
-*.exe
-
-.DS_Store
-
-.cargo
-.idea
-.vscode
-*.iml
-*.swp
-*.swo
diff --git a/bridges/CODE_OF_CONDUCT.md b/bridges/CODE_OF_CONDUCT.md
deleted file mode 100644
index 23411da2e0..0000000000
--- a/bridges/CODE_OF_CONDUCT.md
+++ /dev/null
@@ -1,80 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers
-pledge to making participation in our project and our community a harassment-free experience for
-everyone, regardless of age, body size, disability, ethnicity, sex characteristics, gender identity
-and expression, level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit
- permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-### Facilitation, Not Strongarming
-
-We recognise that this software is merely a tool for users to create and maintain their blockchain
-of preference. We see that blockchains are naturally community platforms with users being the
-ultimate decision makers. We assert that good software will maximise user agency by facilitate
-user-expression on the network. As such:
-
-* This project will strive to give users as much choice as is both reasonable and possible over what
- protocol they adhere to; but
-* use of the project's technical forums, commenting systems, pull requests and issue trackers as a
- means to express individual protocol preferences is forbidden.
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are
-expected to take appropriate and fair corrective action in response to any instances of unacceptable
-behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits,
-code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or
-to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is
-representing the project or its community. Examples of representing a project or community include
-using an official project e-mail address, posting via an official social media account, or acting as
-an appointed representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting
-the project team at admin@parity.io. All complaints will be reviewed and investigated and will
-result in a response that is deemed necessary and appropriate to the circumstances. The project team
-is obligated to maintain confidentiality with regard to the reporter of an incident. Further
-details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face
-temporary or permanent repercussions as determined by other members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at
-https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq
diff --git a/bridges/LICENSE b/bridges/LICENSE
deleted file mode 100644
index 733c072369..0000000000
--- a/bridges/LICENSE
+++ /dev/null
@@ -1,675 +0,0 @@
- GNU GENERAL PUBLIC LICENSE
- Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc.
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
- Preamble
-
- The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
- The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works. By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users. We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors. You can apply it to
-your programs, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
- To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights. Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
- For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received. You must make sure that they, too, receive
-or can get the source code. And you must show them these terms so they
-know their rights.
-
- Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
- For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software. For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
- Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so. This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software. The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable. Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products. If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
- Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary. To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-
- TERMS AND CONDITIONS
-
- 0. Definitions.
-
- "This License" refers to version 3 of the GNU General Public License.
-
- "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
- "The Program" refers to any copyrightable work licensed under this
-License. Each licensee is addressed as "you". "Licensees" and
-"recipients" may be individuals or organizations.
-
- To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy. The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
- A "covered work" means either the unmodified Program or a work based
-on the Program.
-
- To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy. Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
- To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies. Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
- An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License. If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
- 1. Source Code.
-
- The "source code" for a work means the preferred form of the work
-for making modifications to it. "Object code" means any non-source
-form of a work.
-
- A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
- The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form. A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
- The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities. However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work. For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
- The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
- The Corresponding Source for a work in source code form is that
-same work.
-
- 2. Basic Permissions.
-
- All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met. This License explicitly affirms your unlimited
-permission to run the unmodified Program. The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work. This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
- You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force. You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright. Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
- Conveying under any other circumstances is permitted solely under
-the conditions stated below. Sublicensing is not allowed; section 10
-makes it unnecessary.
-
- 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
- No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
- When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
- 4. Conveying Verbatim Copies.
-
- You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
- You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
- 5. Conveying Modified Source Versions.
-
- You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
- a) The work must carry prominent notices stating that you modified
- it, and giving a relevant date.
-
- b) The work must carry prominent notices stating that it is
- released under this License and any conditions added under section
- 7. This requirement modifies the requirement in section 4 to
- "keep intact all notices".
-
- c) You must license the entire work, as a whole, under this
- License to anyone who comes into possession of a copy. This
- License will therefore apply, along with any applicable section 7
- additional terms, to the whole of the work, and all its parts,
- regardless of how they are packaged. This License gives no
- permission to license the work in any other way, but it does not
- invalidate such permission if you have separately received it.
-
- d) If the work has interactive user interfaces, each must display
- Appropriate Legal Notices; however, if the Program has interactive
- interfaces that do not display Appropriate Legal Notices, your
- work need not make them do so.
-
- A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit. Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
- 6. Conveying Non-Source Forms.
-
- You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
- a) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by the
- Corresponding Source fixed on a durable physical medium
- customarily used for software interchange.
-
- b) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by a
- written offer, valid for at least three years and valid for as
- long as you offer spare parts or customer support for that product
- model, to give anyone who possesses the object code either (1) a
- copy of the Corresponding Source for all the software in the
- product that is covered by this License, on a durable physical
- medium customarily used for software interchange, for a price no
- more than your reasonable cost of physically performing this
- conveying of source, or (2) access to copy the
- Corresponding Source from a network server at no charge.
-
- c) Convey individual copies of the object code with a copy of the
- written offer to provide the Corresponding Source. This
- alternative is allowed only occasionally and noncommercially, and
- only if you received the object code with such an offer, in accord
- with subsection 6b.
-
- d) Convey the object code by offering access from a designated
- place (gratis or for a charge), and offer equivalent access to the
- Corresponding Source in the same way through the same place at no
- further charge. You need not require recipients to copy the
- Corresponding Source along with the object code. If the place to
- copy the object code is a network server, the Corresponding Source
- may be on a different server (operated by you or a third party)
- that supports equivalent copying facilities, provided you maintain
- clear directions next to the object code saying where to find the
- Corresponding Source. Regardless of what server hosts the
- Corresponding Source, you remain obligated to ensure that it is
- available for as long as needed to satisfy these requirements.
-
- e) Convey the object code using peer-to-peer transmission, provided
- you inform other peers where the object code and Corresponding
- Source of the work are being offered to the general public at no
- charge under subsection 6d.
-
- A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
- A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling. In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage. For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product. A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
- "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source. The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
- If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information. But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
- The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed. Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
- Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
- 7. Additional Terms.
-
- "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law. If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
- When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it. (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.) You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
- Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
- a) Disclaiming warranty or limiting liability differently from the
- terms of sections 15 and 16 of this License; or
-
- b) Requiring preservation of specified reasonable legal notices or
- author attributions in that material or in the Appropriate Legal
- Notices displayed by works containing it; or
-
- c) Prohibiting misrepresentation of the origin of that material, or
- requiring that modified versions of such material be marked in
- reasonable ways as different from the original version; or
-
- d) Limiting the use for publicity purposes of names of licensors or
- authors of the material; or
-
- e) Declining to grant rights under trademark law for use of some
- trade names, trademarks, or service marks; or
-
- f) Requiring indemnification of licensors and authors of that
- material by anyone who conveys the material (or modified versions of
- it) with contractual assumptions of liability to the recipient, for
- any liability that these contractual assumptions directly impose on
- those licensors and authors.
-
- All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10. If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term. If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
- If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
- Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
- 8. Termination.
-
- You may not propagate or modify a covered work except as expressly
-provided under this License. Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
- However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
- Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
- Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License. If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
- 9. Acceptance Not Required for Having Copies.
-
- You are not required to accept this License in order to receive or
-run a copy of the Program. Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance. However,
-nothing other than this License grants you permission to propagate or
-modify any covered work. These actions infringe copyright if you do
-not accept this License. Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
- 10. Automatic Licensing of Downstream Recipients.
-
- Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License. You are not responsible
-for enforcing compliance by third parties with this License.
-
- An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations. If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
- You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License. For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
- 11. Patents.
-
- A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based. The
-work thus licensed is called the contributor's "contributor version".
-
- A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version. For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
- Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
- In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement). To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
- If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients. "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
- If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
- A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License. You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
- Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
- 12. No Surrender of Others' Freedom.
-
- If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all. For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
- 13. Use with the GNU Affero General Public License.
-
- Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work. The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
- 14. Revised Versions of this License.
-
- The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time. Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation. If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
- If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
- Later license versions may give you additional or different
-permissions. However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
- 15. Disclaimer of Warranty.
-
- THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. Limitation of Liability.
-
- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
- 17. Interpretation of Sections 15 and 16.
-
- If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
- END OF TERMS AND CONDITIONS
-
- How to Apply These Terms to Your New Programs
-
- If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
- To do so, attach the following notices to the program. It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
- {one line to give the program's name and a brief idea of what it does.}
- Copyright (C) {year} {name of author}
-
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see .
-
-Also add information on how to contact you by electronic and paper mail.
-
- If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
- {project} Copyright (C) {year} {fullname}
- This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
- This is free software, and you are welcome to redistribute it
- under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License. Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
- You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-.
-
- The GNU General Public License does not permit incorporating your program
-into proprietary programs. If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library. If this is what you want to do, use the GNU Lesser General
-Public License instead of this License. But first, please read
-.
-
diff --git a/bridges/README.md b/bridges/README.md
deleted file mode 100644
index 8bfa39841f..0000000000
--- a/bridges/README.md
+++ /dev/null
@@ -1,116 +0,0 @@
-# Parity Bridges Common
-
-This is a collection of components for building bridges.
-
-These components include Substrate pallets for syncing headers, passing arbitrary messages, as well as libraries for
-building relayers to provide cross-chain communication capabilities.
-
-Three bridge nodes are also available. The nodes can be used to run test networks which bridge other Substrate chains.
-
-🚧 The bridges are currently under construction - a hardhat is recommended beyond this point 🚧
-
-## Contents
-
-- [Installation](#installation)
-- [High-Level Architecture](#high-level-architecture)
-- [Project Layout](#project-layout)
-- [Running the Bridge](#running-the-bridge)
-- [How to send a message](#how-to-send-a-message)
-- [Community](#community)
-
-## Installation
-
-To get up and running you need both stable and nightly Rust. Rust nightly is used to build the Web Assembly (WASM)
-runtime for the node. You can configure the WASM support as so:
-
-```bash
-rustup install nightly
-rustup target add wasm32-unknown-unknown --toolchain nightly
-```
-
-Once this is configured you can build and test the repo as follows:
-
-```
-git clone https://github.com/paritytech/parity-bridges-common.git
-cd parity-bridges-common
-cargo build --all
-cargo test --all
-```
-
-Also you can build the repo with [Parity CI Docker
-image](https://github.com/paritytech/scripts/tree/master/dockerfiles/ci-unified):
-
-```bash
-docker pull paritytech/ci-unified:latest
-mkdir ~/cache
-chown 1000:1000 ~/cache #processes in the container runs as "nonroot" user with UID 1000
-docker run --rm -it -w /shellhere/parity-bridges-common \
- -v /home/$(whoami)/cache/:/cache/ \
- -v "$(pwd)":/shellhere/parity-bridges-common \
- -e CARGO_HOME=/cache/cargo/ \
- -e SCCACHE_DIR=/cache/sccache/ \
- -e CARGO_TARGET_DIR=/cache/target/ paritytech/ci-unified:latest cargo build --all
-#artifacts can be found in ~/cache/target
-```
-
-If you want to reproduce other steps of CI process you can use the following
-[guide](https://github.com/paritytech/scripts#reproduce-ci-locally).
-
-If you need more information about setting up your development environment [Substrate's Installation
-page](https://docs.substrate.io/main-docs/install/) is a good resource.
-
-## High-Level Architecture
-
-This repo has support for bridging foreign chains together using a combination of Substrate pallets and external
-processes called relayers. A bridge chain is one that is able to follow the consensus of a foreign chain independently.
-For example, consider the case below where we want to bridge two Substrate based chains.
-
-```
-+---------------+ +---------------+
-| | | |
-| Rococo | | Westend |
-| | | |
-+-------+-------+ +-------+-------+
- ^ ^
- | +---------------+ |
- | | | |
- +-----> | Bridge Relay | <-------+
- | |
- +---------------+
-```
-
-The Rococo chain must be able to accept Westend headers and verify their integrity. It does this by using a runtime
-module designed to track GRANDPA finality. Since two blockchains can't interact directly they need an external service,
-called a relayer, to communicate. The relayer will subscribe to new Rococo headers via RPC and submit them to the Westend
-chain for verification.
-
-Take a look at [Bridge High Level Documentation](./docs/high-level-overview.md) for more in-depth description of the
-bridge interaction.
-
-## Project Layout
-
-Here's an overview of how the project is laid out. The main bits are the `bin`, which is the actual "blockchain", the
-`modules` which are used to build the blockchain's logic (a.k.a the runtime) and the `relays` which are used to pass
-messages between chains.
-
-```
-├── modules // Substrate Runtime Modules (a.k.a Pallets)
-│ ├── beefy // On-Chain BEEFY Light Client (in progress)
-│ ├── grandpa // On-Chain GRANDPA Light Client
-│ ├── messages // Cross Chain Message Passing
-│ ├── parachains // On-Chain Parachains Light Client
-│ ├── relayers // Relayer Rewards Registry
-│ ├── xcm-bridge-hub // Multiple Dynamic Bridges Support
-│ ├── xcm-bridge-hub-router // XCM Router that may be used to Connect to XCM Bridge Hub
-├── primitives // Code shared between modules, runtimes, and relays
-│ └── ...
-├── relays // Application for sending finality proofs and messages between chains
-│ └── ...
-└── scripts // Useful development and maintenance scripts
-```
-
-## Running the Bridge
-
-Apart from live Rococo <> Westend bridge, you may spin up local networks and test see how it works locally. More
-details may be found in
-[this document](https://github.com/paritytech/polkadot-sdk/tree/master//cumulus/parachains/runtimes/bridge-hubs/README.md).
diff --git a/bridges/SECURITY.md b/bridges/SECURITY.md
deleted file mode 100644
index 9f215c8876..0000000000
--- a/bridges/SECURITY.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Security Policy
-
-Thanks for helping make the Parity ecosystem more secure. Security is one of our first priorities.
-
-## Reporting a vulnerability
-
-If you find something that can be treated as a security vulnerability, please do not use the issue tracker or discuss it
-in the public forum as it can cause more damage, rather than giving real help to the ecosystem.
-
-Security vulnerabilities should be reported by the [contact form](https://security-submission.parity.io/).
-
-If you think that your report might be eligible for the Bug Bounty Program, please mark this during the submission.
-Please check up-to-date [Parity Bug Bounty Program rules](https://www.parity.io/bug-bounty) to find out the information
-about our Bug Bounty Program.
-
-**Warning**: This is an unified SECURITY.md file for Paritytech GitHub Organization. The presence of this file does not
-mean that this repository is covered by the Bug Bounty program. Please always check the Bug Bounty Program scope for
-information.
diff --git a/bridges/bin/runtime-common/Cargo.toml b/bridges/bin/runtime-common/Cargo.toml
deleted file mode 100644
index 67b91a16a3..0000000000
--- a/bridges/bin/runtime-common/Cargo.toml
+++ /dev/null
@@ -1,100 +0,0 @@
-[package]
-name = "bridge-runtime-common"
-version = "0.7.0"
-description = "Common types and functions that may be used by substrate-based runtimes of all bridged chains"
-authors.workspace = true
-edition.workspace = true
-repository.workspace = true
-license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
-
-[lints]
-workspace = true
-
-[dependencies]
-codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
-hash-db = { version = "0.16.0", default-features = false }
-log = { workspace = true }
-scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
-static_assertions = { version = "1.1", optional = true }
-
-# Bridge dependencies
-
-bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
-bp-messages = { path = "../../primitives/messages", default-features = false }
-bp-parachains = { path = "../../primitives/parachains", default-features = false }
-bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
-bp-relayers = { path = "../../primitives/relayers", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
-bp-xcm-bridge-hub = { path = "../../primitives/xcm-bridge-hub", default-features = false }
-bp-xcm-bridge-hub-router = { path = "../../primitives/xcm-bridge-hub-router", default-features = false }
-pallet-bridge-grandpa = { path = "../../modules/grandpa", default-features = false }
-pallet-bridge-messages = { path = "../../modules/messages", default-features = false }
-pallet-bridge-parachains = { path = "../../modules/parachains", default-features = false }
-pallet-bridge-relayers = { path = "../../modules/relayers", default-features = false }
-
-# Substrate dependencies
-
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-frame-system = { path = "../../../substrate/frame/system", default-features = false }
-pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment", default-features = false }
-pallet-utility = { path = "../../../substrate/frame/utility", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-core = { path = "../../../substrate/primitives/core", default-features = false }
-sp-io = { path = "../../../substrate/primitives/io", default-features = false }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
-sp-trie = { path = "../../../substrate/primitives/trie", default-features = false }
-
-# Polkadot dependencies
-xcm = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false }
-xcm-builder = { package = "staging-xcm-builder", path = "../../../polkadot/xcm/xcm-builder", default-features = false }
-
-[dev-dependencies]
-bp-test-utils = { path = "../../primitives/test-utils" }
-pallet-balances = { path = "../../../substrate/frame/balances" }
-
-[features]
-default = ["std"]
-std = [
- "bp-header-chain/std",
- "bp-messages/std",
- "bp-parachains/std",
- "bp-polkadot-core/std",
- "bp-relayers/std",
- "bp-runtime/std",
- "bp-xcm-bridge-hub-router/std",
- "bp-xcm-bridge-hub/std",
- "codec/std",
- "frame-support/std",
- "frame-system/std",
- "hash-db/std",
- "log/std",
- "pallet-bridge-grandpa/std",
- "pallet-bridge-messages/std",
- "pallet-bridge-parachains/std",
- "pallet-bridge-relayers/std",
- "pallet-transaction-payment/std",
- "pallet-utility/std",
- "scale-info/std",
- "sp-api/std",
- "sp-core/std",
- "sp-io/std",
- "sp-runtime/std",
- "sp-std/std",
- "sp-trie/std",
- "xcm-builder/std",
- "xcm/std",
-]
-runtime-benchmarks = [
- "frame-support/runtime-benchmarks",
- "frame-system/runtime-benchmarks",
- "pallet-balances/runtime-benchmarks",
- "pallet-bridge-grandpa/runtime-benchmarks",
- "pallet-bridge-messages/runtime-benchmarks",
- "pallet-bridge-parachains/runtime-benchmarks",
- "pallet-bridge-relayers/runtime-benchmarks",
- "pallet-utility/runtime-benchmarks",
- "sp-runtime/runtime-benchmarks",
- "xcm-builder/runtime-benchmarks",
-]
-integrity-test = ["static_assertions"]
diff --git a/bridges/bin/runtime-common/src/integrity.rs b/bridges/bin/runtime-common/src/integrity.rs
deleted file mode 100644
index d3827a14dd..0000000000
--- a/bridges/bin/runtime-common/src/integrity.rs
+++ /dev/null
@@ -1,348 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common. If not, see .
-
-//! Integrity tests for chain constants and pallets configuration.
-//!
-//! Most of the tests in this module assume that the bridge is using standard (see `crate::messages`
-//! module for details) configuration.
-
-use crate::{messages, messages::MessageBridge};
-
-use bp_messages::{InboundLaneData, MessageNonce};
-use bp_runtime::{Chain, ChainId};
-use codec::Encode;
-use frame_support::{storage::generator::StorageValue, traits::Get, weights::Weight};
-use frame_system::limits;
-use pallet_bridge_messages::WeightInfoExt as _;
-
-/// Macro that ensures that the runtime configuration and chain primitives crate are sharing
-/// the same types (nonce, block number, hash, hasher, account id and header).
-#[macro_export]
-macro_rules! assert_chain_types(
- ( runtime: $r:path, this_chain: $this:path ) => {
- {
- // if one of asserts fail, then either bridge isn't configured properly (or alternatively - non-standard
- // configuration is used), or something has broke existing configuration (meaning that all bridged chains
- // and relays will stop functioning)
- use frame_system::{Config as SystemConfig, pallet_prelude::{BlockNumberFor, HeaderFor}};
- use static_assertions::assert_type_eq_all;
-
- assert_type_eq_all!(<$r as SystemConfig>::Nonce, bp_runtime::NonceOf<$this>);
- assert_type_eq_all!(BlockNumberFor<$r>, bp_runtime::BlockNumberOf<$this>);
- assert_type_eq_all!(<$r as SystemConfig>::Hash, bp_runtime::HashOf<$this>);
- assert_type_eq_all!(<$r as SystemConfig>::Hashing, bp_runtime::HasherOf<$this>);
- assert_type_eq_all!(<$r as SystemConfig>::AccountId, bp_runtime::AccountIdOf<$this>);
- assert_type_eq_all!(HeaderFor<$r>, bp_runtime::HeaderOf<$this>);
- }
- }
-);
-
-/// Macro that ensures that the bridge GRANDPA pallet is configured properly to bridge with given
-/// chain.
-#[macro_export]
-macro_rules! assert_bridge_grandpa_pallet_types(
- ( runtime: $r:path, with_bridged_chain_grandpa_instance: $i:path, bridged_chain: $bridged:path ) => {
- {
- // if one of asserts fail, then either bridge isn't configured properly (or alternatively - non-standard
- // configuration is used), or something has broke existing configuration (meaning that all bridged chains
- // and relays will stop functioning)
- use pallet_bridge_grandpa::Config as GrandpaConfig;
- use static_assertions::assert_type_eq_all;
-
- assert_type_eq_all!(<$r as GrandpaConfig<$i>>::BridgedChain, $bridged);
- }
- }
-);
-
-/// Macro that ensures that the bridge messages pallet is configured properly to bridge using given
-/// configuration.
-#[macro_export]
-macro_rules! assert_bridge_messages_pallet_types(
- (
- runtime: $r:path,
- with_bridged_chain_messages_instance: $i:path,
- bridge: $bridge:path
- ) => {
- {
- // if one of asserts fail, then either bridge isn't configured properly (or alternatively - non-standard
- // configuration is used), or something has broke existing configuration (meaning that all bridged chains
- // and relays will stop functioning)
- use $crate::messages::{
- source::{FromThisChainMessagePayload, TargetHeaderChainAdapter},
- target::{FromBridgedChainMessagePayload, SourceHeaderChainAdapter},
- AccountIdOf, BalanceOf, BridgedChain, ThisChain,
- };
- use pallet_bridge_messages::Config as MessagesConfig;
- use static_assertions::assert_type_eq_all;
-
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::OutboundPayload, FromThisChainMessagePayload);
-
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::InboundRelayer, AccountIdOf>);
-
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::TargetHeaderChain, TargetHeaderChainAdapter<$bridge>);
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::SourceHeaderChain, SourceHeaderChainAdapter<$bridge>);
- }
- }
-);
-
-/// Macro that combines four other macro calls - `assert_chain_types`, `assert_bridge_types`,
-/// `assert_bridge_grandpa_pallet_types` and `assert_bridge_messages_pallet_types`. It may be used
-/// at the chain that is implementing complete standard messages bridge (i.e. with bridge GRANDPA
-/// and messages pallets deployed).
-#[macro_export]
-macro_rules! assert_complete_bridge_types(
- (
- runtime: $r:path,
- with_bridged_chain_grandpa_instance: $gi:path,
- with_bridged_chain_messages_instance: $mi:path,
- bridge: $bridge:path,
- this_chain: $this:path,
- bridged_chain: $bridged:path,
- ) => {
- $crate::assert_chain_types!(runtime: $r, this_chain: $this);
- $crate::assert_bridge_grandpa_pallet_types!(
- runtime: $r,
- with_bridged_chain_grandpa_instance: $gi,
- bridged_chain: $bridged
- );
- $crate::assert_bridge_messages_pallet_types!(
- runtime: $r,
- with_bridged_chain_messages_instance: $mi,
- bridge: $bridge
- );
- }
-);
-
-/// Parameters for asserting chain-related constants.
-#[derive(Debug)]
-pub struct AssertChainConstants {
- /// Block length limits of the chain.
- pub block_length: limits::BlockLength,
- /// Block weight limits of the chain.
- pub block_weights: limits::BlockWeights,
-}
-
-/// Test that our hardcoded, chain-related constants, are matching chain runtime configuration.
-///
-/// In particular, this test ensures that:
-///
-/// 1) block weight limits are matching;
-/// 2) block size limits are matching.
-pub fn assert_chain_constants(params: AssertChainConstants)
-where
- R: frame_system::Config,
-{
- // we don't check runtime version here, because in our case we'll be building relay from one
- // repo and runtime will live in another repo, along with outdated relay version. To avoid
- // unneeded commits, let's not raise an error in case of version mismatch.
-
- // if one of following assert fails, it means that we may need to upgrade bridged chain and
- // relay to use updated constants. If constants are now smaller than before, it may lead to
- // undeliverable messages.
-
- // `BlockLength` struct is not implementing `PartialEq`, so we compare encoded values here.
- assert_eq!(
- R::BlockLength::get().encode(),
- params.block_length.encode(),
- "BlockLength from runtime ({:?}) differ from hardcoded: {:?}",
- R::BlockLength::get(),
- params.block_length,
- );
- // `BlockWeights` struct is not implementing `PartialEq`, so we compare encoded values here
- assert_eq!(
- R::BlockWeights::get().encode(),
- params.block_weights.encode(),
- "BlockWeights from runtime ({:?}) differ from hardcoded: {:?}",
- R::BlockWeights::get(),
- params.block_weights,
- );
-}
-
-/// Test that the constants, used in GRANDPA pallet configuration are valid.
-pub fn assert_bridge_grandpa_pallet_constants()
-where
- R: pallet_bridge_grandpa::Config,
- GI: 'static,
-{
- assert!(
- R::HeadersToKeep::get() > 0,
- "HeadersToKeep ({}) must be larger than zero",
- R::HeadersToKeep::get(),
- );
-}
-
-/// Parameters for asserting messages pallet constants.
-#[derive(Debug)]
-pub struct AssertBridgeMessagesPalletConstants {
- /// Maximal number of unrewarded relayer entries in a confirmation transaction at the bridged
- /// chain.
- pub max_unrewarded_relayers_in_bridged_confirmation_tx: MessageNonce,
- /// Maximal number of unconfirmed messages in a confirmation transaction at the bridged chain.
- pub max_unconfirmed_messages_in_bridged_confirmation_tx: MessageNonce,
- /// Identifier of the bridged chain.
- pub bridged_chain_id: ChainId,
-}
-
-/// Test that the constants, used in messages pallet configuration are valid.
-pub fn assert_bridge_messages_pallet_constants(params: AssertBridgeMessagesPalletConstants)
-where
- R: pallet_bridge_messages::Config,
- MI: 'static,
-{
- assert!(
- !R::ActiveOutboundLanes::get().is_empty(),
- "ActiveOutboundLanes ({:?}) must not be empty",
- R::ActiveOutboundLanes::get(),
- );
- assert!(
- R::MaxUnrewardedRelayerEntriesAtInboundLane::get() <= params.max_unrewarded_relayers_in_bridged_confirmation_tx,
- "MaxUnrewardedRelayerEntriesAtInboundLane ({}) must be <= than the hardcoded value for bridged chain: {}",
- R::MaxUnrewardedRelayerEntriesAtInboundLane::get(),
- params.max_unrewarded_relayers_in_bridged_confirmation_tx,
- );
- assert!(
- R::MaxUnconfirmedMessagesAtInboundLane::get() <= params.max_unconfirmed_messages_in_bridged_confirmation_tx,
- "MaxUnrewardedRelayerEntriesAtInboundLane ({}) must be <= than the hardcoded value for bridged chain: {}",
- R::MaxUnconfirmedMessagesAtInboundLane::get(),
- params.max_unconfirmed_messages_in_bridged_confirmation_tx,
- );
- assert_eq!(R::BridgedChainId::get(), params.bridged_chain_id);
-}
-
-/// Parameters for asserting bridge pallet names.
-#[derive(Debug)]
-pub struct AssertBridgePalletNames<'a> {
- /// Name of the messages pallet, deployed at the bridged chain and used to bridge with this
- /// chain.
- pub with_this_chain_messages_pallet_name: &'a str,
- /// Name of the GRANDPA pallet, deployed at this chain and used to bridge with the bridged
- /// chain.
- pub with_bridged_chain_grandpa_pallet_name: &'a str,
- /// Name of the messages pallet, deployed at this chain and used to bridge with the bridged
- /// chain.
- pub with_bridged_chain_messages_pallet_name: &'a str,
-}
-
-/// Tests that bridge pallet names used in `construct_runtime!()` macro call are matching constants
-/// from chain primitives crates.
-pub fn assert_bridge_pallet_names(params: AssertBridgePalletNames)
-where
- B: MessageBridge,
- R: pallet_bridge_grandpa::Config + pallet_bridge_messages::Config,
- GI: 'static,
- MI: 'static,
-{
- assert_eq!(B::BRIDGED_MESSAGES_PALLET_NAME, params.with_this_chain_messages_pallet_name);
- assert_eq!(
- pallet_bridge_grandpa::PalletOwner::::storage_value_final_key().to_vec(),
- bp_runtime::storage_value_key(params.with_bridged_chain_grandpa_pallet_name, "PalletOwner",).0,
- );
- assert_eq!(
- pallet_bridge_messages::PalletOwner::::storage_value_final_key().to_vec(),
- bp_runtime::storage_value_key(
- params.with_bridged_chain_messages_pallet_name,
- "PalletOwner",
- )
- .0,
- );
-}
-
-/// Parameters for asserting complete standard messages bridge.
-#[derive(Debug)]
-pub struct AssertCompleteBridgeConstants<'a> {
- /// Parameters to assert this chain constants.
- pub this_chain_constants: AssertChainConstants,
- /// Parameters to assert messages pallet constants.
- pub messages_pallet_constants: AssertBridgeMessagesPalletConstants,
- /// Parameters to assert pallet names constants.
- pub pallet_names: AssertBridgePalletNames<'a>,
-}
-
-/// All bridge-related constants tests for the complete standard messages bridge (i.e. with bridge
-/// GRANDPA and messages pallets deployed).
-pub fn assert_complete_bridge_constants(params: AssertCompleteBridgeConstants)
-where
- R: frame_system::Config
- + pallet_bridge_grandpa::Config
- + pallet_bridge_messages::Config,
- GI: 'static,
- MI: 'static,
- B: MessageBridge,
-{
- assert_chain_constants::(params.this_chain_constants);
- assert_bridge_grandpa_pallet_constants::();
- assert_bridge_messages_pallet_constants::(params.messages_pallet_constants);
- assert_bridge_pallet_names::(params.pallet_names);
-}
-
-/// Check that the message lane weights are correct.
-pub fn check_message_lane_weights<
- C: Chain,
- T: frame_system::Config + pallet_bridge_messages::Config,
- MessagesPalletInstance: 'static,
->(
- bridged_chain_extra_storage_proof_size: u32,
- this_chain_max_unrewarded_relayers: MessageNonce,
- this_chain_max_unconfirmed_messages: MessageNonce,
- // whether `RefundBridgedParachainMessages` extension is deployed at runtime and is used for
- // refunding this bridge transactions?
- //
- // in other words: pass true for all known production chains
- runtime_includes_refund_extension: bool,
-) {
- type Weights = >::WeightInfo;
-
- // check basic weight assumptions
- pallet_bridge_messages::ensure_weights_are_correct::>();
-
- // check that weights allow us to receive messages
- let max_incoming_message_proof_size = bridged_chain_extra_storage_proof_size
- .saturating_add(messages::target::maximal_incoming_message_size(C::max_extrinsic_size()));
- pallet_bridge_messages::ensure_able_to_receive_message::>(
- C::max_extrinsic_size(),
- C::max_extrinsic_weight(),
- max_incoming_message_proof_size,
- messages::target::maximal_incoming_message_dispatch_weight(C::max_extrinsic_weight()),
- );
-
- // check that weights allow us to receive delivery confirmations
- let max_incoming_inbound_lane_data_proof_size =
- InboundLaneData::<()>::encoded_size_hint_u32(this_chain_max_unrewarded_relayers as _);
- pallet_bridge_messages::ensure_able_to_receive_confirmation::>(
- C::max_extrinsic_size(),
- C::max_extrinsic_weight(),
- max_incoming_inbound_lane_data_proof_size,
- this_chain_max_unrewarded_relayers,
- this_chain_max_unconfirmed_messages,
- );
-
- // check that extra weights of delivery/confirmation transactions include the weight
- // of `RefundBridgedParachainMessages` operations. This signed extension assumes the worst case
- // (i.e. slashing if delivery transaction was invalid) and refunds some weight if
- // assumption was wrong (i.e. if we did refund instead of slashing). This check
- // ensures the extension will not refund weight when it doesn't need to (i.e. if pallet
- // weights do not account weights of refund extension).
- if runtime_includes_refund_extension {
- assert_ne!(
- Weights::::receive_messages_proof_overhead_from_runtime(),
- Weight::zero()
- );
- assert_ne!(
- Weights::::receive_messages_delivery_proof_overhead_from_runtime(),
- Weight::zero()
- );
- }
-}
diff --git a/bridges/bin/runtime-common/src/lib.rs b/bridges/bin/runtime-common/src/lib.rs
deleted file mode 100644
index 2722f6f1c6..0000000000
--- a/bridges/bin/runtime-common/src/lib.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common. If not, see .
-
-//! Common types/functions that may be used by runtimes of all bridged chains.
-
-#![warn(missing_docs)]
-#![cfg_attr(not(feature = "std"), no_std)]
-
-use crate::messages_call_ext::MessagesCallSubType;
-use pallet_bridge_grandpa::CallSubType as GrandpaCallSubType;
-use pallet_bridge_parachains::CallSubType as ParachainsCallSubtype;
-use sp_runtime::transaction_validity::TransactionValidity;
-
-pub mod messages;
-pub mod messages_api;
-pub mod messages_benchmarking;
-pub mod messages_call_ext;
-pub mod messages_generation;
-pub mod messages_xcm_extension;
-pub mod parachains_benchmarking;
-pub mod priority_calculator;
-pub mod refund_relayer_extension;
-
-mod mock;
-
-#[cfg(feature = "integrity-test")]
-pub mod integrity;
-
-const LOG_TARGET_BRIDGE_DISPATCH: &str = "runtime::bridge-dispatch";
-
-/// A duplication of the `FilterCall` trait.
-///
-/// We need this trait in order to be able to implement it for the messages pallet,
-/// since the implementation is done outside of the pallet crate.
-pub trait BridgeRuntimeFilterCall {
- /// Checks if a runtime call is valid.
- fn validate(call: &Call) -> TransactionValidity;
-}
-
-impl BridgeRuntimeFilterCall for pallet_bridge_grandpa::Pallet
-where
- T: pallet_bridge_grandpa::Config,
- T::RuntimeCall: GrandpaCallSubType,
-{
- fn validate(call: &T::RuntimeCall) -> TransactionValidity {
- GrandpaCallSubType::::check_obsolete_submit_finality_proof(call)
- }
-}
-
-impl BridgeRuntimeFilterCall
- for pallet_bridge_parachains::Pallet
-where
- T: pallet_bridge_parachains::Config,
- T::RuntimeCall: ParachainsCallSubtype,
-{
- fn validate(call: &T::RuntimeCall) -> TransactionValidity {
- ParachainsCallSubtype::::check_obsolete_submit_parachain_heads(call)
- }
-}
-
-impl, I: 'static> BridgeRuntimeFilterCall
- for pallet_bridge_messages::Pallet
-where
- T::RuntimeCall: MessagesCallSubType,
-{
- /// Validate messages in order to avoid "mining" messages delivery and delivery confirmation
- /// transactions, that are delivering outdated messages/confirmations. Without this validation,
- /// even honest relayers may lose their funds if there are multiple relays running and
- /// submitting the same messages/confirmations.
- fn validate(call: &T::RuntimeCall) -> TransactionValidity {
- call.check_obsolete_call()
- }
-}
-
-/// Declares a runtime-specific `BridgeRejectObsoleteHeadersAndMessages` signed extension.
-///
-/// ## Example
-///
-/// ```nocompile
-/// generate_bridge_reject_obsolete_headers_and_messages!{
-/// Call, AccountId
-/// BridgeRococoGrandpa, BridgeRococoMessages,
-/// BridgeRococoParachains
-/// }
-/// ```
-///
-/// The goal of this extension is to avoid "mining" transactions that provide outdated bridged
-/// headers and messages. Without that extension, even honest relayers may lose their funds if
-/// there are multiple relays running and submitting the same information.
-#[macro_export]
-macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
- ($call:ty, $account_id:ty, $($filter_call:ty),*) => {
- #[derive(Clone, codec::Decode, Default, codec::Encode, Eq, PartialEq, sp_runtime::RuntimeDebug, scale_info::TypeInfo)]
- pub struct BridgeRejectObsoleteHeadersAndMessages;
- impl sp_runtime::traits::SignedExtension for BridgeRejectObsoleteHeadersAndMessages {
- const IDENTIFIER: &'static str = "BridgeRejectObsoleteHeadersAndMessages";
- type AccountId = $account_id;
- type Call = $call;
- type AdditionalSigned = ();
- type Pre = ();
-
- fn additional_signed(&self) -> sp_std::result::Result<
- (),
- sp_runtime::transaction_validity::TransactionValidityError,
- > {
- Ok(())
- }
-
- fn validate(
- &self,
- _who: &Self::AccountId,
- call: &Self::Call,
- _info: &sp_runtime::traits::DispatchInfoOf,
- _len: usize,
- ) -> sp_runtime::transaction_validity::TransactionValidity {
- let valid = sp_runtime::transaction_validity::ValidTransaction::default();
- $(
- let valid = valid
- .combine_with(<$filter_call as $crate::BridgeRuntimeFilterCall<$call>>::validate(call)?);
- )*
- Ok(valid)
- }
-
- fn pre_dispatch(
- self,
- who: &Self::AccountId,
- call: &Self::Call,
- info: &sp_runtime::traits::DispatchInfoOf,
- len: usize,
- ) -> Result {
- self.validate(who, call, info, len).map(drop)
- }
- }
- };
-}
-
-#[cfg(test)]
-mod tests {
- use crate::BridgeRuntimeFilterCall;
- use frame_support::{assert_err, assert_ok};
- use sp_runtime::{
- traits::SignedExtension,
- transaction_validity::{InvalidTransaction, TransactionValidity, ValidTransaction},
- };
-
- pub struct MockCall {
- data: u32,
- }
-
- impl sp_runtime::traits::Dispatchable for MockCall {
- type RuntimeOrigin = ();
- type Config = ();
- type Info = ();
- type PostInfo = ();
-
- fn dispatch(
- self,
- _origin: Self::RuntimeOrigin,
- ) -> sp_runtime::DispatchResultWithInfo {
- unimplemented!()
- }
- }
-
- struct FirstFilterCall;
- impl BridgeRuntimeFilterCall for FirstFilterCall {
- fn validate(call: &MockCall) -> TransactionValidity {
- if call.data <= 1 {
- return InvalidTransaction::Custom(1).into()
- }
-
- Ok(ValidTransaction { priority: 1, ..Default::default() })
- }
- }
-
- struct SecondFilterCall;
- impl BridgeRuntimeFilterCall for SecondFilterCall {
- fn validate(call: &MockCall) -> TransactionValidity {
- if call.data <= 2 {
- return InvalidTransaction::Custom(2).into()
- }
-
- Ok(ValidTransaction { priority: 2, ..Default::default() })
- }
- }
-
- #[test]
- fn test() {
- generate_bridge_reject_obsolete_headers_and_messages!(
- MockCall,
- (),
- FirstFilterCall,
- SecondFilterCall
- );
-
- assert_err!(
- BridgeRejectObsoleteHeadersAndMessages.validate(&(), &MockCall { data: 1 }, &(), 0),
- InvalidTransaction::Custom(1)
- );
-
- assert_err!(
- BridgeRejectObsoleteHeadersAndMessages.validate(&(), &MockCall { data: 2 }, &(), 0),
- InvalidTransaction::Custom(2)
- );
-
- assert_ok!(
- BridgeRejectObsoleteHeadersAndMessages.validate(&(), &MockCall { data: 3 }, &(), 0),
- ValidTransaction { priority: 3, ..Default::default() }
- )
- }
-}
diff --git a/bridges/bin/runtime-common/src/messages.rs b/bridges/bin/runtime-common/src/messages.rs
deleted file mode 100644
index 4aca53f3b9..0000000000
--- a/bridges/bin/runtime-common/src/messages.rs
+++ /dev/null
@@ -1,701 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common. If not, see .
-
-//! Types that allow runtime to act as a source/target endpoint of message lanes.
-//!
-//! Messages are assumed to be encoded `Call`s of the target chain. Call-dispatch
-//! pallet is used to dispatch incoming messages. Message identified by a tuple
-//! of to elements - message lane id and message nonce.
-
-pub use bp_runtime::{RangeInclusiveExt, UnderlyingChainOf, UnderlyingChainProvider};
-
-use bp_header_chain::HeaderChain;
-use bp_messages::{
- source_chain::TargetHeaderChain,
- target_chain::{ProvedLaneMessages, ProvedMessages, SourceHeaderChain},
- InboundLaneData, LaneId, Message, MessageKey, MessageNonce, MessagePayload, OutboundLaneData,
- VerificationError,
-};
-use bp_runtime::{Chain, RawStorageProof, Size, StorageProofChecker};
-use codec::{Decode, Encode};
-use frame_support::{traits::Get, weights::Weight};
-use hash_db::Hasher;
-use scale_info::TypeInfo;
-use sp_runtime::RuntimeDebug;
-use sp_std::{convert::TryFrom, marker::PhantomData, vec::Vec};
-
-/// Bidirectional message bridge.
-pub trait MessageBridge {
- /// Name of the paired messages pallet instance at the Bridged chain.
- ///
- /// Should be the name that is used in the `construct_runtime!()` macro.
- const BRIDGED_MESSAGES_PALLET_NAME: &'static str;
-
- /// This chain in context of message bridge.
- type ThisChain: ThisChainWithMessages;
- /// Bridged chain in context of message bridge.
- type BridgedChain: BridgedChainWithMessages;
- /// Bridged header chain.
- type BridgedHeaderChain: HeaderChain>;
-}
-
-/// This chain that has `pallet-bridge-messages` module.
-pub trait ThisChainWithMessages: UnderlyingChainProvider {
- /// Call origin on the chain.
- type RuntimeOrigin;
-}
-
-/// Bridged chain that has `pallet-bridge-messages` module.
-pub trait BridgedChainWithMessages: UnderlyingChainProvider {}
-
-/// This chain in context of message bridge.
-pub type ThisChain = ::ThisChain;
-/// Bridged chain in context of message bridge.
-pub type BridgedChain = ::BridgedChain;
-/// Hash used on the chain.
-pub type HashOf = bp_runtime::HashOf<::Chain>;
-/// Hasher used on the chain.
-pub type HasherOf = bp_runtime::HasherOf>;
-/// Account id used on the chain.
-pub type AccountIdOf = bp_runtime::AccountIdOf>;
-/// Type of balances that is used on the chain.
-pub type BalanceOf = bp_runtime::BalanceOf>;
-
-/// Sub-module that is declaring types required for processing This -> Bridged chain messages.
-pub mod source {
- use super::*;
-
- /// Message payload for This -> Bridged chain messages.
- pub type FromThisChainMessagePayload = crate::messages_xcm_extension::XcmAsPlainPayload;
-
- /// Maximal size of outbound message payload.
- pub struct FromThisChainMaximalOutboundPayloadSize(PhantomData);
-
- impl Get for FromThisChainMaximalOutboundPayloadSize {
- fn get() -> u32 {
- maximal_message_size::()
- }
- }
-
- /// Messages delivery proof from bridged chain:
- ///
- /// - hash of finalized header;
- /// - storage proof of inbound lane state;
- /// - lane id.
- #[derive(Clone, Decode, Encode, Eq, PartialEq, RuntimeDebug, TypeInfo)]
- pub struct FromBridgedChainMessagesDeliveryProof {
- /// Hash of the bridge header the proof is for.
- pub bridged_header_hash: BridgedHeaderHash,
- /// Storage trie proof generated for [`Self::bridged_header_hash`].
- pub storage_proof: RawStorageProof,
- /// Lane id of which messages were delivered and the proof is for.
- pub lane: LaneId,
- }
-
- impl Size for FromBridgedChainMessagesDeliveryProof {
- fn size(&self) -> u32 {
- u32::try_from(
- self.storage_proof
- .iter()
- .fold(0usize, |sum, node| sum.saturating_add(node.len())),
- )
- .unwrap_or(u32::MAX)
- }
- }
-
- /// 'Parsed' message delivery proof - inbound lane id and its state.
- pub type ParsedMessagesDeliveryProofFromBridgedChain =
- (LaneId, InboundLaneData>>);
-
- /// Return maximal message size of This -> Bridged chain message.
- pub fn maximal_message_size() -> u32 {
- super::target::maximal_incoming_message_size(
- UnderlyingChainOf::>::max_extrinsic_size(),
- )
- }
-
- /// `TargetHeaderChain` implementation that is using default types and perform default checks.
- pub struct TargetHeaderChainAdapter(PhantomData);
-
- impl TargetHeaderChain>>
- for TargetHeaderChainAdapter
- {
- type MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof>>;
-
- fn verify_message(payload: &FromThisChainMessagePayload) -> Result<(), VerificationError> {
- verify_chain_message::(payload)
- }
-
- fn verify_messages_delivery_proof(
- proof: Self::MessagesDeliveryProof,
- ) -> Result<(LaneId, InboundLaneData>>), VerificationError> {
- verify_messages_delivery_proof::(proof)
- }
- }
-
- /// Do basic Bridged-chain specific verification of This -> Bridged chain message.
- ///
- /// Ok result from this function means that the delivery transaction with this message
- /// may be 'mined' by the target chain.
- pub fn verify_chain_message(
- payload: &FromThisChainMessagePayload,
- ) -> Result<(), VerificationError> {
- // IMPORTANT: any error that is returned here is fatal for the bridge, because
- // this code is executed at the bridge hub and message sender actually lives
- // at some sibling parachain. So we are failing **after** the message has been
- // sent and we can't report it back to sender (unless error report mechanism is
- // embedded into message and its dispatcher).
-
- // apart from maximal message size check (see below), we should also check the message
- // dispatch weight here. But we assume that the bridged chain will just push the message
- // to some queue (XCMP, UMP, DMP), so the weight is constant and fits the block.
-
- // The maximal size of extrinsic at Substrate-based chain depends on the
- // `frame_system::Config::MaximumBlockLength` and
- // `frame_system::Config::AvailableBlockRatio` constants. This check is here to be sure that
- // the lane won't stuck because message is too large to fit into delivery transaction.
- //
- // **IMPORTANT NOTE**: the delivery transaction contains storage proof of the message, not
- // the message itself. The proof is always larger than the message. But unless chain state
- // is enormously large, it should be several dozens/hundreds of bytes. The delivery
- // transaction also contains signatures and signed extensions. Because of this, we reserve
- // 1/3 of the the maximal extrinsic size for this data.
- if payload.len() > maximal_message_size::() as usize {
- return Err(VerificationError::MessageTooLarge)
- }
-
- Ok(())
- }
-
- /// Verify proof of This -> Bridged chain messages delivery.
- ///
- /// This function is used when Bridged chain is directly using GRANDPA finality. For Bridged
- /// parachains, please use the `verify_messages_delivery_proof_from_parachain`.
- pub fn verify_messages_delivery_proof(
- proof: FromBridgedChainMessagesDeliveryProof>>,
- ) -> Result, VerificationError> {
- let FromBridgedChainMessagesDeliveryProof { bridged_header_hash, storage_proof, lane } =
- proof;
- let mut storage =
- B::BridgedHeaderChain::storage_proof_checker(bridged_header_hash, storage_proof)
- .map_err(VerificationError::HeaderChain)?;
- // Messages delivery proof is just proof of single storage key read => any error
- // is fatal.
- let storage_inbound_lane_data_key = bp_messages::storage_keys::inbound_lane_data_key(
- B::BRIDGED_MESSAGES_PALLET_NAME,
- &lane,
- );
- let inbound_lane_data = storage
- .read_and_decode_mandatory_value(storage_inbound_lane_data_key.0.as_ref())
- .map_err(VerificationError::InboundLaneStorage)?;
-
- // check that the storage proof doesn't have any untouched trie nodes
- storage.ensure_no_unused_nodes().map_err(VerificationError::StorageProof)?;
-
- Ok((lane, inbound_lane_data))
- }
-}
-
-/// Sub-module that is declaring types required for processing Bridged -> This chain messages.
-pub mod target {
- use super::*;
-
- /// Decoded Bridged -> This message payload.
- pub type FromBridgedChainMessagePayload = crate::messages_xcm_extension::XcmAsPlainPayload;
-
- /// Messages proof from bridged chain:
- ///
- /// - hash of finalized header;
- /// - storage proof of messages and (optionally) outbound lane state;
- /// - lane id;
- /// - nonces (inclusive range) of messages which are included in this proof.
- #[derive(Clone, Decode, Encode, Eq, PartialEq, RuntimeDebug, TypeInfo)]
- pub struct FromBridgedChainMessagesProof {
- /// Hash of the finalized bridged header the proof is for.
- pub bridged_header_hash: BridgedHeaderHash,
- /// A storage trie proof of messages being delivered.
- pub storage_proof: RawStorageProof,
- /// Messages in this proof are sent over this lane.
- pub lane: LaneId,
- /// Nonce of the first message being delivered.
- pub nonces_start: MessageNonce,
- /// Nonce of the last message being delivered.
- pub nonces_end: MessageNonce,
- }
-
- impl Size for FromBridgedChainMessagesProof {
- fn size(&self) -> u32 {
- u32::try_from(
- self.storage_proof
- .iter()
- .fold(0usize, |sum, node| sum.saturating_add(node.len())),
- )
- .unwrap_or(u32::MAX)
- }
- }
-
- /// Return maximal dispatch weight of the message we're able to receive.
- pub fn maximal_incoming_message_dispatch_weight(maximal_extrinsic_weight: Weight) -> Weight {
- maximal_extrinsic_weight / 2
- }
-
- /// Return maximal message size given maximal extrinsic size.
- pub fn maximal_incoming_message_size(maximal_extrinsic_size: u32) -> u32 {
- maximal_extrinsic_size / 3 * 2
- }
-
- /// `SourceHeaderChain` implementation that is using default types and perform default checks.
- pub struct SourceHeaderChainAdapter(PhantomData);
-
- impl SourceHeaderChain for SourceHeaderChainAdapter {
- type MessagesProof = FromBridgedChainMessagesProof>>;
-
- fn verify_messages_proof(
- proof: Self::MessagesProof,
- messages_count: u32,
- ) -> Result, VerificationError> {
- verify_messages_proof::(proof, messages_count)
- }
- }
-
- /// Verify proof of Bridged -> This chain messages.
- ///
- /// This function is used when Bridged chain is directly using GRANDPA finality. For Bridged
- /// parachains, please use the `verify_messages_proof_from_parachain`.
- ///
- /// The `messages_count` argument verification (sane limits) is supposed to be made
- /// outside of this function. This function only verifies that the proof declares exactly
- /// `messages_count` messages.
- pub fn verify_messages_proof(
- proof: FromBridgedChainMessagesProof>>,
- messages_count: u32,
- ) -> Result, VerificationError> {
- let FromBridgedChainMessagesProof {
- bridged_header_hash,
- storage_proof,
- lane,
- nonces_start,
- nonces_end,
- } = proof;
- let storage =
- B::BridgedHeaderChain::storage_proof_checker(bridged_header_hash, storage_proof)
- .map_err(VerificationError::HeaderChain)?;
- let mut parser = StorageProofCheckerAdapter::<_, B> { storage, _dummy: Default::default() };
- let nonces_range = nonces_start..=nonces_end;
-
- // receiving proofs where end < begin is ok (if proof includes outbound lane state)
- let messages_in_the_proof = nonces_range.checked_len().unwrap_or(0);
- if messages_in_the_proof != MessageNonce::from(messages_count) {
- return Err(VerificationError::MessagesCountMismatch)
- }
-
- // Read messages first. All messages that are claimed to be in the proof must
- // be in the proof. So any error in `read_value`, or even missing value is fatal.
- //
- // Mind that we allow proofs with no messages if outbound lane state is proved.
- let mut messages = Vec::with_capacity(messages_in_the_proof as _);
- for nonce in nonces_range {
- let message_key = MessageKey { lane_id: lane, nonce };
- let message_payload = parser.read_and_decode_message_payload(&message_key)?;
- messages.push(Message { key: message_key, payload: message_payload });
- }
-
- // Now let's check if proof contains outbound lane state proof. It is optional, so
- // we simply ignore `read_value` errors and missing value.
- let proved_lane_messages = ProvedLaneMessages {
- lane_state: parser.read_and_decode_outbound_lane_data(&lane)?,
- messages,
- };
-
- // Now we may actually check if the proof is empty or not.
- if proved_lane_messages.lane_state.is_none() && proved_lane_messages.messages.is_empty() {
- return Err(VerificationError::EmptyMessageProof)
- }
-
- // check that the storage proof doesn't have any untouched trie nodes
- parser
- .storage
- .ensure_no_unused_nodes()
- .map_err(VerificationError::StorageProof)?;
-
- // We only support single lane messages in this generated_schema
- let mut proved_messages = ProvedMessages::new();
- proved_messages.insert(lane, proved_lane_messages);
-
- Ok(proved_messages)
- }
-
- struct StorageProofCheckerAdapter {
- storage: StorageProofChecker,
- _dummy: sp_std::marker::PhantomData,
- }
-
- impl StorageProofCheckerAdapter {
- fn read_and_decode_outbound_lane_data(
- &mut self,
- lane_id: &LaneId,
- ) -> Result, VerificationError> {
- let storage_outbound_lane_data_key = bp_messages::storage_keys::outbound_lane_data_key(
- B::BRIDGED_MESSAGES_PALLET_NAME,
- lane_id,
- );
-
- self.storage
- .read_and_decode_opt_value(storage_outbound_lane_data_key.0.as_ref())
- .map_err(VerificationError::OutboundLaneStorage)
- }
-
- fn read_and_decode_message_payload(
- &mut self,
- message_key: &MessageKey,
- ) -> Result {
- let storage_message_key = bp_messages::storage_keys::message_key(
- B::BRIDGED_MESSAGES_PALLET_NAME,
- &message_key.lane_id,
- message_key.nonce,
- );
- self.storage
- .read_and_decode_mandatory_value(storage_message_key.0.as_ref())
- .map_err(VerificationError::MessageStorage)
- }
- }
-}
-
-/// The `BridgeMessagesCall` used by a chain.
-pub type BridgeMessagesCallOf = bp_messages::BridgeMessagesCall<
- bp_runtime::AccountIdOf,
- target::FromBridgedChainMessagesProof>,
- source::FromBridgedChainMessagesDeliveryProof>,
->;
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::{
- messages_generation::{
- encode_all_messages, encode_lane_data, prepare_messages_storage_proof,
- },
- mock::*,
- };
- use bp_header_chain::{HeaderChainError, StoredHeaderDataBuilder};
- use bp_runtime::{HeaderId, StorageProofError};
- use codec::Encode;
- use sp_core::H256;
- use sp_runtime::traits::Header as _;
-
- #[test]
- fn verify_chain_message_rejects_message_with_too_large_declared_weight() {
- assert!(source::verify_chain_message::(&vec![
- 42;
- BRIDGED_CHAIN_MAX_EXTRINSIC_WEIGHT -
- 1
- ])
- .is_err());
- }
-
- #[test]
- fn verify_chain_message_rejects_message_too_large_message() {
- assert!(source::verify_chain_message::(&vec![
- 0;
- source::maximal_message_size::()
- as usize + 1
- ],)
- .is_err());
- }
-
- #[test]
- fn verify_chain_message_accepts_maximal_message() {
- assert_eq!(
- source::verify_chain_message::(&vec![
- 0;
- source::maximal_message_size::()
- as _
- ],),
- Ok(()),
- );
- }
-
- fn using_messages_proof(
- nonces_end: MessageNonce,
- outbound_lane_data: Option,
- encode_message: impl Fn(MessageNonce, &MessagePayload) -> Option>,
- encode_outbound_lane_data: impl Fn(&OutboundLaneData) -> Vec,
- test: impl Fn(target::FromBridgedChainMessagesProof) -> R,
- ) -> R {
- let (state_root, storage_proof) = prepare_messages_storage_proof::(
- TEST_LANE_ID,
- 1..=nonces_end,
- outbound_lane_data,
- bp_runtime::StorageProofSize::Minimal(0),
- vec![42],
- encode_message,
- encode_outbound_lane_data,
- );
-
- sp_io::TestExternalities::new(Default::default()).execute_with(move || {
- let bridged_header = BridgedChainHeader::new(
- 0,
- Default::default(),
- state_root,
- Default::default(),
- Default::default(),
- );
- let bridged_header_hash = bridged_header.hash();
-
- pallet_bridge_grandpa::BestFinalized::::put(HeaderId(
- 0,
- bridged_header_hash,
- ));
- pallet_bridge_grandpa::ImportedHeaders::::insert(
- bridged_header_hash,
- bridged_header.build(),
- );
- test(target::FromBridgedChainMessagesProof {
- bridged_header_hash,
- storage_proof,
- lane: TEST_LANE_ID,
- nonces_start: 1,
- nonces_end,
- })
- })
- }
-
- #[test]
- fn messages_proof_is_rejected_if_declared_less_than_actual_number_of_messages() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |proof| {
- target::verify_messages_proof::(proof, 5)
- }),
- Err(VerificationError::MessagesCountMismatch),
- );
- }
-
- #[test]
- fn messages_proof_is_rejected_if_declared_more_than_actual_number_of_messages() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |proof| {
- target::verify_messages_proof::(proof, 15)
- }),
- Err(VerificationError::MessagesCountMismatch),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_header_is_missing_from_the_chain() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |proof| {
- let bridged_header_hash =
- pallet_bridge_grandpa::BestFinalized::::get().unwrap().1;
- pallet_bridge_grandpa::ImportedHeaders::::remove(bridged_header_hash);
- target::verify_messages_proof::(proof, 10)
- }),
- Err(VerificationError::HeaderChain(HeaderChainError::UnknownHeader)),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_header_state_root_mismatches() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |proof| {
- let bridged_header_hash =
- pallet_bridge_grandpa::BestFinalized::::get().unwrap().1;
- pallet_bridge_grandpa::ImportedHeaders::::insert(
- bridged_header_hash,
- BridgedChainHeader::new(
- 0,
- Default::default(),
- Default::default(),
- Default::default(),
- Default::default(),
- )
- .build(),
- );
- target::verify_messages_proof::(proof, 10)
- }),
- Err(VerificationError::HeaderChain(HeaderChainError::StorageProof(
- StorageProofError::StorageRootMismatch
- ))),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_it_has_duplicate_trie_nodes() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |mut proof| {
- let node = proof.storage_proof.pop().unwrap();
- proof.storage_proof.push(node.clone());
- proof.storage_proof.push(node);
- target::verify_messages_proof::(proof, 10)
- },),
- Err(VerificationError::HeaderChain(HeaderChainError::StorageProof(
- StorageProofError::DuplicateNodesInProof
- ))),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_it_has_unused_trie_nodes() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |mut proof| {
- proof.storage_proof.push(vec![42]);
- target::verify_messages_proof::(proof, 10)
- },),
- Err(VerificationError::StorageProof(StorageProofError::UnusedNodesInTheProof)),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_required_message_is_missing() {
- matches!(
- using_messages_proof(
- 10,
- None,
- |n, m| if n != 5 { Some(m.encode()) } else { None },
- encode_lane_data,
- |proof| target::verify_messages_proof::(proof, 10)
- ),
- Err(VerificationError::MessageStorage(StorageProofError::StorageValueEmpty)),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_message_decode_fails() {
- matches!(
- using_messages_proof(
- 10,
- None,
- |n, m| {
- let mut m = m.encode();
- if n == 5 {
- m = vec![42]
- }
- Some(m)
- },
- encode_lane_data,
- |proof| target::verify_messages_proof::(proof, 10),
- ),
- Err(VerificationError::MessageStorage(StorageProofError::StorageValueDecodeFailed(_))),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_outbound_lane_state_decode_fails() {
- matches!(
- using_messages_proof(
- 10,
- Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- encode_all_messages,
- |d| {
- let mut d = d.encode();
- d.truncate(1);
- d
- },
- |proof| target::verify_messages_proof::(proof, 10),
- ),
- Err(VerificationError::OutboundLaneStorage(
- StorageProofError::StorageValueDecodeFailed(_)
- )),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_it_is_empty() {
- assert_eq!(
- using_messages_proof(0, None, encode_all_messages, encode_lane_data, |proof| {
- target::verify_messages_proof::(proof, 0)
- },),
- Err(VerificationError::EmptyMessageProof),
- );
- }
-
- #[test]
- fn non_empty_message_proof_without_messages_is_accepted() {
- assert_eq!(
- using_messages_proof(
- 0,
- Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- encode_all_messages,
- encode_lane_data,
- |proof| target::verify_messages_proof::(proof, 0),
- ),
- Ok(vec![(
- TEST_LANE_ID,
- ProvedLaneMessages {
- lane_state: Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- messages: Vec::new(),
- },
- )]
- .into_iter()
- .collect()),
- );
- }
-
- #[test]
- fn non_empty_message_proof_is_accepted() {
- assert_eq!(
- using_messages_proof(
- 1,
- Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- encode_all_messages,
- encode_lane_data,
- |proof| target::verify_messages_proof::(proof, 1),
- ),
- Ok(vec![(
- TEST_LANE_ID,
- ProvedLaneMessages {
- lane_state: Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- messages: vec![Message {
- key: MessageKey { lane_id: TEST_LANE_ID, nonce: 1 },
- payload: vec![42],
- }],
- },
- )]
- .into_iter()
- .collect()),
- );
- }
-
- #[test]
- fn verify_messages_proof_does_not_panic_if_messages_count_mismatches() {
- assert_eq!(
- using_messages_proof(1, None, encode_all_messages, encode_lane_data, |mut proof| {
- proof.nonces_end = u64::MAX;
- target::verify_messages_proof::(proof, u32::MAX)
- },),
- Err(VerificationError::MessagesCountMismatch),
- );
- }
-}
diff --git a/bridges/bin/runtime-common/src/messages_api.rs b/bridges/bin/runtime-common/src/messages_api.rs
deleted file mode 100644
index 7fbdeb3661..0000000000
--- a/bridges/bin/runtime-common/src/messages_api.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common. If not, see .
-
-//! Helpers for implementing various message-related runtime API methods.
-
-use bp_messages::{
- InboundMessageDetails, LaneId, MessageNonce, MessagePayload, OutboundMessageDetails,
-};
-use sp_std::vec::Vec;
-
-/// Implementation of the `To*OutboundLaneApi::message_details`.
-pub fn outbound_message_details(
- lane: LaneId,
- begin: MessageNonce,
- end: MessageNonce,
-) -> Vec
-where
- Runtime: pallet_bridge_messages::Config,
- MessagesPalletInstance: 'static,
-{
- (begin..=end)
- .filter_map(|nonce| {
- let message_data =
- pallet_bridge_messages::Pallet::::outbound_message_data(lane, nonce)?;
- Some(OutboundMessageDetails {
- nonce,
- // dispatch message weight is always zero at the source chain, since we're paying for
- // dispatch at the target chain
- dispatch_weight: frame_support::weights::Weight::zero(),
- size: message_data.len() as _,
- })
- })
- .collect()
-}
-
-/// Implementation of the `To*InboundLaneApi::message_details`.
-pub fn inbound_message_details(
- lane: LaneId,
- messages: Vec<(MessagePayload, OutboundMessageDetails)>,
-) -> Vec
-where
- Runtime: pallet_bridge_messages::Config,
- MessagesPalletInstance: 'static,
-{
- messages
- .into_iter()
- .map(|(payload, details)| {
- pallet_bridge_messages::Pallet::::inbound_message_data(
- lane, payload, details,
- )
- })
- .collect()
-}
diff --git a/bridges/bin/runtime-common/src/messages_benchmarking.rs b/bridges/bin/runtime-common/src/messages_benchmarking.rs
deleted file mode 100644
index 0c7a9ad1a8..0000000000
--- a/bridges/bin/runtime-common/src/messages_benchmarking.rs
+++ /dev/null
@@ -1,314 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common. If not, see .
-
-//! Everything required to run benchmarks of messages module, based on
-//! `bridge_runtime_common::messages` implementation.
-
-#![cfg(feature = "runtime-benchmarks")]
-
-use crate::{
- messages::{
- source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
- AccountIdOf, BridgedChain, HashOf, MessageBridge, ThisChain,
- },
- messages_generation::{
- encode_all_messages, encode_lane_data, prepare_message_delivery_storage_proof,
- prepare_messages_storage_proof,
- },
-};
-
-use bp_messages::MessagePayload;
-use bp_polkadot_core::parachains::ParaHash;
-use bp_runtime::{Chain, Parachain, StorageProofSize, UnderlyingChainOf};
-use codec::Encode;
-use frame_support::weights::Weight;
-use pallet_bridge_messages::benchmarking::{MessageDeliveryProofParams, MessageProofParams};
-use sp_runtime::traits::{Header, Zero};
-use sp_std::prelude::*;
-use xcm::latest::prelude::*;
-
-/// Prepare inbound bridge message according to given message proof parameters.
-fn prepare_inbound_message(
- params: &MessageProofParams,
- successful_dispatch_message_generator: impl Fn(usize) -> MessagePayload,
-) -> MessagePayload {
- // we only care about **this** message size when message proof needs to be `Minimal`
- let expected_size = match params.size {
- StorageProofSize::Minimal(size) => size as usize,
- _ => 0,
- };
-
- // if we don't need a correct message, then we may just return some random blob
- if !params.is_successful_dispatch_expected {
- return vec![0u8; expected_size]
- }
-
- // else let's prepare successful message.
- let msg = successful_dispatch_message_generator(expected_size);
- assert!(
- msg.len() >= expected_size,
- "msg.len(): {} does not match expected_size: {}",
- expected_size,
- msg.len()
- );
- msg
-}
-
-/// Prepare proof of messages for the `receive_messages_proof` call.
-///
-/// In addition to returning valid messages proof, environment is prepared to verify this message
-/// proof.
-///
-/// This method is intended to be used when benchmarking pallet, linked to the chain that
-/// uses GRANDPA finality. For parachains, please use the `prepare_message_proof_from_parachain`
-/// function.
-pub fn prepare_message_proof_from_grandpa_chain(
- params: MessageProofParams,
- message_generator: impl Fn(usize) -> MessagePayload,
-) -> (FromBridgedChainMessagesProof>>, Weight)
-where
- R: pallet_bridge_grandpa::Config>>,
- FI: 'static,
- B: MessageBridge,
-{
- // prepare storage proof
- let (state_root, storage_proof) = prepare_messages_storage_proof::(
- params.lane,
- params.message_nonces.clone(),
- params.outbound_lane_data.clone(),
- params.size,
- prepare_inbound_message(¶ms, message_generator),
- encode_all_messages,
- encode_lane_data,
- );
-
- // update runtime storage
- let (_, bridged_header_hash) = insert_header_to_grandpa_pallet::(state_root);
-
- (
- FromBridgedChainMessagesProof {
- bridged_header_hash,
- storage_proof,
- lane: params.lane,
- nonces_start: *params.message_nonces.start(),
- nonces_end: *params.message_nonces.end(),
- },
- Weight::MAX / 1000,
- )
-}
-
-/// Prepare proof of messages for the `receive_messages_proof` call.
-///
-/// In addition to returning valid messages proof, environment is prepared to verify this message
-/// proof.
-///
-/// This method is intended to be used when benchmarking pallet, linked to the chain that
-/// uses parachain finality. For GRANDPA chains, please use the
-/// `prepare_message_proof_from_grandpa_chain` function.
-pub fn prepare_message_proof_from_parachain(
- params: MessageProofParams,
- message_generator: impl Fn(usize) -> MessagePayload,
-) -> (FromBridgedChainMessagesProof>>, Weight)
-where
- R: pallet_bridge_parachains::Config,
- PI: 'static,
- B: MessageBridge,
- UnderlyingChainOf>: Chain + Parachain,
-{
- // prepare storage proof
- let (state_root, storage_proof) = prepare_messages_storage_proof::(
- params.lane,
- params.message_nonces.clone(),
- params.outbound_lane_data.clone(),
- params.size,
- prepare_inbound_message(¶ms, message_generator),
- encode_all_messages,
- encode_lane_data,
- );
-
- // update runtime storage
- let (_, bridged_header_hash) =
- insert_header_to_parachains_pallet::>>(state_root);
-
- (
- FromBridgedChainMessagesProof {
- bridged_header_hash,
- storage_proof,
- lane: params.lane,
- nonces_start: *params.message_nonces.start(),
- nonces_end: *params.message_nonces.end(),
- },
- Weight::MAX / 1000,
- )
-}
-
-/// Prepare proof of messages delivery for the `receive_messages_delivery_proof` call.
-///
-/// This method is intended to be used when benchmarking pallet, linked to the chain that
-/// uses GRANDPA finality. For parachains, please use the
-/// `prepare_message_delivery_proof_from_parachain` function.
-pub fn prepare_message_delivery_proof_from_grandpa_chain(
- params: MessageDeliveryProofParams>>,
-) -> FromBridgedChainMessagesDeliveryProof>>
-where
- R: pallet_bridge_grandpa::Config>>,
- FI: 'static,
- B: MessageBridge,
-{
- // prepare storage proof
- let lane = params.lane;
- let (state_root, storage_proof) = prepare_message_delivery_storage_proof::(
- params.lane,
- params.inbound_lane_data,
- params.size,
- );
-
- // update runtime storage
- let (_, bridged_header_hash) = insert_header_to_grandpa_pallet::(state_root);
-
- FromBridgedChainMessagesDeliveryProof {
- bridged_header_hash: bridged_header_hash.into(),
- storage_proof,
- lane,
- }
-}
-
-/// Prepare proof of messages delivery for the `receive_messages_delivery_proof` call.
-///
-/// This method is intended to be used when benchmarking pallet, linked to the chain that
-/// uses parachain finality. For GRANDPA chains, please use the
-/// `prepare_message_delivery_proof_from_grandpa_chain` function.
-pub fn prepare_message_delivery_proof_from_parachain(
- params: MessageDeliveryProofParams>>,
-) -> FromBridgedChainMessagesDeliveryProof>>
-where
- R: pallet_bridge_parachains::Config,
- PI: 'static,
- B: MessageBridge,
- UnderlyingChainOf>: Chain + Parachain,
-{
- // prepare storage proof
- let lane = params.lane;
- let (state_root, storage_proof) = prepare_message_delivery_storage_proof::(
- params.lane,
- params.inbound_lane_data,
- params.size,
- );
-
- // update runtime storage
- let (_, bridged_header_hash) =
- insert_header_to_parachains_pallet::>>(state_root);
-
- FromBridgedChainMessagesDeliveryProof {
- bridged_header_hash: bridged_header_hash.into(),
- storage_proof,
- lane,
- }
-}
-
-/// Insert header to the bridge GRANDPA pallet.
-pub(crate) fn insert_header_to_grandpa_pallet(
- state_root: bp_runtime::HashOf,
-) -> (bp_runtime::BlockNumberOf, bp_runtime::HashOf)
-where
- R: pallet_bridge_grandpa::Config,
- GI: 'static,
- R::BridgedChain: bp_runtime::Chain,
-{
- let bridged_block_number = Zero::zero();
- let bridged_header = bp_runtime::HeaderOf::::new(
- bridged_block_number,
- Default::default(),
- state_root,
- Default::default(),
- Default::default(),
- );
- let bridged_header_hash = bridged_header.hash();
- pallet_bridge_grandpa::initialize_for_benchmarks::(bridged_header);
- (bridged_block_number, bridged_header_hash)
-}
-
-/// Insert header to the bridge parachains pallet.
-pub(crate) fn insert_header_to_parachains_pallet(
- state_root: bp_runtime::HashOf,
-) -> (bp_runtime::BlockNumberOf, bp_runtime::HashOf)
-where
- R: pallet_bridge_parachains::Config,
- PI: 'static,
- PC: Chain + Parachain,
-{
- let bridged_block_number = Zero::zero();
- let bridged_header = bp_runtime::HeaderOf::::new(
- bridged_block_number,
- Default::default(),
- state_root,
- Default::default(),
- Default::default(),
- );
- let bridged_header_hash = bridged_header.hash();
- pallet_bridge_parachains::initialize_for_benchmarks::(bridged_header);
- (bridged_block_number, bridged_header_hash)
-}
-
-/// Returns callback which generates `BridgeMessage` from Polkadot XCM builder based on
-/// `expected_message_size` for benchmark.
-pub fn generate_xcm_builder_bridge_message_sample(
- destination: InteriorLocation,
-) -> impl Fn(usize) -> MessagePayload {
- move |expected_message_size| -> MessagePayload {
- // For XCM bridge hubs, it is the message that
- // will be pushed further to some XCM queue (XCMP/UMP)
- let location = xcm::VersionedInteriorLocation::V4(destination.clone());
- let location_encoded_size = location.encoded_size();
-
- // we don't need to be super-precise with `expected_size` here
- let xcm_size = expected_message_size.saturating_sub(location_encoded_size);
- let xcm_data_size = xcm_size.saturating_sub(
- // minus empty instruction size
- Instruction::<()>::ExpectPallet {
- index: 0,
- name: vec![],
- module_name: vec![],
- crate_major: 0,
- min_crate_minor: 0,
- }
- .encoded_size(),
- );
-
- log::trace!(
- target: "runtime::bridge-benchmarks",
- "generate_xcm_builder_bridge_message_sample with expected_message_size: {}, location_encoded_size: {}, xcm_size: {}, xcm_data_size: {}",
- expected_message_size, location_encoded_size, xcm_size, xcm_data_size,
- );
-
- let xcm = xcm::VersionedXcm::<()>::V4(
- vec![Instruction::<()>::ExpectPallet {
- index: 0,
- name: vec![42; xcm_data_size],
- module_name: vec![],
- crate_major: 0,
- min_crate_minor: 0,
- }]
- .into(),
- );
-
- // this is the `BridgeMessage` from polkadot xcm builder, but it has no constructor
- // or public fields, so just tuple
- // (double encoding, because `.encode()` is called on original Xcm BLOB when it is pushed
- // to the storage)
- (location, xcm).encode().encode()
- }
-}
diff --git a/bridges/bin/runtime-common/src/messages_call_ext.rs b/bridges/bin/runtime-common/src/messages_call_ext.rs
deleted file mode 100644
index fb07f7b6dd..0000000000
--- a/bridges/bin/runtime-common/src/messages_call_ext.rs
+++ /dev/null
@@ -1,692 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common. If not, see .
-
-//! Signed extension for the `pallet-bridge-messages` that is able to reject obsolete
-//! (and some other invalid) transactions.
-
-use crate::messages::{
- source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
-};
-use bp_messages::{target_chain::MessageDispatch, InboundLaneData, LaneId, MessageNonce};
-use bp_runtime::OwnedBridgeModule;
-use frame_support::{
- dispatch::CallableCallFor,
- traits::{Get, IsSubType},
-};
-use pallet_bridge_messages::{Config, Pallet};
-use sp_runtime::{transaction_validity::TransactionValidity, RuntimeDebug};
-use sp_std::ops::RangeInclusive;
-
-/// Generic info about a messages delivery/confirmation proof.
-#[derive(PartialEq, RuntimeDebug)]
-pub struct BaseMessagesProofInfo {
- /// Message lane, used by the call.
- pub lane_id: LaneId,
- /// Nonces of messages, included in the call.
- ///
- /// For delivery transaction, it is nonces of bundled messages. For confirmation
- /// transaction, it is nonces that are to be confirmed during the call.
- pub bundled_range: RangeInclusive,
- /// Nonce of the best message, stored by this chain before the call is dispatched.
- ///
- /// For delivery transaction, it is the nonce of best delivered message before the call.
- /// For confirmation transaction, it is the nonce of best confirmed message before the call.
- pub best_stored_nonce: MessageNonce,
-}
-
-impl BaseMessagesProofInfo {
- /// Returns true if `bundled_range` continues the `0..=best_stored_nonce` range.
- fn appends_to_stored_nonce(&self) -> bool {
- Some(*self.bundled_range.start()) == self.best_stored_nonce.checked_add(1)
- }
-}
-
-/// Occupation state of the unrewarded relayers vector.
-#[derive(PartialEq, RuntimeDebug)]
-#[cfg_attr(test, derive(Default))]
-pub struct UnrewardedRelayerOccupation {
- /// The number of remaining unoccupied entries for new relayers.
- pub free_relayer_slots: MessageNonce,
- /// The number of messages that we are ready to accept.
- pub free_message_slots: MessageNonce,
-}
-
-/// Info about a `ReceiveMessagesProof` call which tries to update a single lane.
-#[derive(PartialEq, RuntimeDebug)]
-pub struct ReceiveMessagesProofInfo {
- /// Base messages proof info
- pub base: BaseMessagesProofInfo,
- /// State of unrewarded relayers vector.
- pub unrewarded_relayers: UnrewardedRelayerOccupation,
-}
-
-impl ReceiveMessagesProofInfo {
- /// Returns true if:
- ///
- /// - either inbound lane is ready to accept bundled messages;
- ///
- /// - or there are no bundled messages, but the inbound lane is blocked by too many unconfirmed
- /// messages and/or unrewarded relayers.
- fn is_obsolete(&self, is_dispatcher_active: bool) -> bool {
- // if dispatcher is inactive, we don't accept any delivery transactions
- if !is_dispatcher_active {
- return true
- }
-
- // transactions with zero bundled nonces are not allowed, unless they're message
- // delivery transactions, which brings reward confirmations required to unblock
- // the lane
- if self.base.bundled_range.is_empty() {
- let empty_transactions_allowed =
- // we allow empty transactions when we can't accept delivery from new relayers
- self.unrewarded_relayers.free_relayer_slots == 0 ||
- // or if we can't accept new messages at all
- self.unrewarded_relayers.free_message_slots == 0;
-
- return !empty_transactions_allowed
- }
-
- // otherwise we require bundled messages to continue stored range
- !self.base.appends_to_stored_nonce()
- }
-}
-
-/// Info about a `ReceiveMessagesDeliveryProof` call which tries to update a single lane.
-#[derive(PartialEq, RuntimeDebug)]
-pub struct ReceiveMessagesDeliveryProofInfo(pub BaseMessagesProofInfo);
-
-impl ReceiveMessagesDeliveryProofInfo {
- /// Returns true if outbound lane is ready to accept confirmations of bundled messages.
- fn is_obsolete(&self) -> bool {
- self.0.bundled_range.is_empty() || !self.0.appends_to_stored_nonce()
- }
-}
-
-/// Info about a `ReceiveMessagesProof` or a `ReceiveMessagesDeliveryProof` call
-/// which tries to update a single lane.
-#[derive(PartialEq, RuntimeDebug)]
-pub enum CallInfo {
- /// Messages delivery call info.
- ReceiveMessagesProof(ReceiveMessagesProofInfo),
- /// Messages delivery confirmation call info.
- ReceiveMessagesDeliveryProof(ReceiveMessagesDeliveryProofInfo),
-}
-
-impl CallInfo {
- /// Returns range of messages, bundled with the call.
- pub fn bundled_messages(&self) -> RangeInclusive {
- match *self {
- Self::ReceiveMessagesProof(ref info) => info.base.bundled_range.clone(),
- Self::ReceiveMessagesDeliveryProof(ref info) => info.0.bundled_range.clone(),
- }
- }
-}
-
-/// Helper struct that provides methods for working with a call supported by `CallInfo`.
-pub struct CallHelper, I: 'static> {
- _phantom_data: sp_std::marker::PhantomData<(T, I)>,
-}
-
-impl, I: 'static> CallHelper {
- /// Returns true if:
- ///
- /// - call is `receive_messages_proof` and all messages have been delivered;
- ///
- /// - call is `receive_messages_delivery_proof` and all messages confirmations have been
- /// received.
- pub fn was_successful(info: &CallInfo) -> bool {
- match info {
- CallInfo::ReceiveMessagesProof(info) => {
- let inbound_lane_data =
- pallet_bridge_messages::InboundLanes::::get(info.base.lane_id);
- if info.base.bundled_range.is_empty() {
- let post_occupation =
- unrewarded_relayers_occupation::(&inbound_lane_data);
- // we don't care about `free_relayer_slots` here - it is checked in
- // `is_obsolete` and every relayer has delivered at least one message,
- // so if relayer slots are released, then message slots are also
- // released
- return post_occupation.free_message_slots >
- info.unrewarded_relayers.free_message_slots
- }
-
- inbound_lane_data.last_delivered_nonce() == *info.base.bundled_range.end()
- },
- CallInfo::ReceiveMessagesDeliveryProof(info) => {
- let outbound_lane_data =
- pallet_bridge_messages::OutboundLanes::::get(info.0.lane_id);
- outbound_lane_data.latest_received_nonce == *info.0.bundled_range.end()
- },
- }
- }
-}
-
-/// Trait representing a call that is a sub type of `pallet_bridge_messages::Call`.
-pub trait MessagesCallSubType, I: 'static>:
- IsSubType, T>>
-{
- /// Create a new instance of `ReceiveMessagesProofInfo` from a `ReceiveMessagesProof` call.
- fn receive_messages_proof_info(&self) -> Option;
-
- /// Create a new instance of `ReceiveMessagesDeliveryProofInfo` from
- /// a `ReceiveMessagesDeliveryProof` call.
- fn receive_messages_delivery_proof_info(&self) -> Option;
-
- /// Create a new instance of `CallInfo` from a `ReceiveMessagesProof`
- /// or a `ReceiveMessagesDeliveryProof` call.
- fn call_info(&self) -> Option;
-
- /// Create a new instance of `CallInfo` from a `ReceiveMessagesProof`
- /// or a `ReceiveMessagesDeliveryProof` call, if the call is for the provided lane.
- fn call_info_for(&self, lane_id: LaneId) -> Option;
-
- /// Ensures that a `ReceiveMessagesProof` or a `ReceiveMessagesDeliveryProof` call:
- ///
- /// - does not deliver already delivered messages. We require all messages in the
- /// `ReceiveMessagesProof` call to be undelivered;
- ///
- /// - does not submit empty `ReceiveMessagesProof` call with zero messages, unless the lane
- /// needs to be unblocked by providing relayer rewards proof;
- ///
- /// - brings no new delivery confirmations in a `ReceiveMessagesDeliveryProof` call. We require
- /// at least one new delivery confirmation in the unrewarded relayers set;
- ///
- /// - does not violate some basic (easy verifiable) messages pallet rules obsolete (like
- /// submitting a call when a pallet is halted or delivering messages when a dispatcher is
- /// inactive).
- ///
- /// If one of above rules is violated, the transaction is treated as invalid.
- fn check_obsolete_call(&self) -> TransactionValidity;
-}
-
-impl<
- BridgedHeaderHash,
- SourceHeaderChain: bp_messages::target_chain::SourceHeaderChain<
- MessagesProof = FromBridgedChainMessagesProof,
- >,
- TargetHeaderChain: bp_messages::source_chain::TargetHeaderChain<
- >::OutboundPayload,
- ::AccountId,
- MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof,
- >,
- Call: IsSubType, T>>,
- T: frame_system::Config
- + Config,
- I: 'static,
- > MessagesCallSubType for T::RuntimeCall
-{
- fn receive_messages_proof_info(&self) -> Option {
- if let Some(pallet_bridge_messages::Call::::receive_messages_proof {
- ref proof,
- ..
- }) = self.is_sub_type()
- {
- let inbound_lane_data = pallet_bridge_messages::InboundLanes::::get(proof.lane);
-
- return Some(ReceiveMessagesProofInfo {
- base: BaseMessagesProofInfo {
- lane_id: proof.lane,
- // we want all messages in this range to be new for us. Otherwise transaction
- // will be considered obsolete.
- bundled_range: proof.nonces_start..=proof.nonces_end,
- best_stored_nonce: inbound_lane_data.last_delivered_nonce(),
- },
- unrewarded_relayers: unrewarded_relayers_occupation::(&inbound_lane_data),
- })
- }
-
- None
- }
-
- fn receive_messages_delivery_proof_info(&self) -> Option {
- if let Some(pallet_bridge_messages::Call::::receive_messages_delivery_proof {
- ref proof,
- ref relayers_state,
- ..
- }) = self.is_sub_type()
- {
- let outbound_lane_data = pallet_bridge_messages::OutboundLanes::::get(proof.lane);
-
- return Some(ReceiveMessagesDeliveryProofInfo(BaseMessagesProofInfo {
- lane_id: proof.lane,
- // there's a time frame between message delivery, message confirmation and reward
- // confirmation. Because of that, we can't assume that our state has been confirmed
- // to the bridged chain. So we are accepting any proof that brings new
- // confirmations.
- bundled_range: outbound_lane_data.latest_received_nonce + 1..=
- relayers_state.last_delivered_nonce,
- best_stored_nonce: outbound_lane_data.latest_received_nonce,
- }))
- }
-
- None
- }
-
- fn call_info(&self) -> Option {
- if let Some(info) = self.receive_messages_proof_info() {
- return Some(CallInfo::ReceiveMessagesProof(info))
- }
-
- if let Some(info) = self.receive_messages_delivery_proof_info() {
- return Some(CallInfo::ReceiveMessagesDeliveryProof(info))
- }
-
- None
- }
-
- fn call_info_for(&self, lane_id: LaneId) -> Option {
- self.call_info().filter(|info| {
- let actual_lane_id = match info {
- CallInfo::ReceiveMessagesProof(info) => info.base.lane_id,
- CallInfo::ReceiveMessagesDeliveryProof(info) => info.0.lane_id,
- };
- actual_lane_id == lane_id
- })
- }
-
- fn check_obsolete_call(&self) -> TransactionValidity {
- let is_pallet_halted = Pallet::::ensure_not_halted().is_err();
- match self.call_info() {
- Some(proof_info) if is_pallet_halted => {
- log::trace!(
- target: pallet_bridge_messages::LOG_TARGET,
- "Rejecting messages transaction on halted pallet: {:?}",
- proof_info
- );
-
- return sp_runtime::transaction_validity::InvalidTransaction::Call.into()
- },
- Some(CallInfo::ReceiveMessagesProof(proof_info))
- if proof_info.is_obsolete(T::MessageDispatch::is_active()) =>
- {
- log::trace!(
- target: pallet_bridge_messages::LOG_TARGET,
- "Rejecting obsolete messages delivery transaction: {:?}",
- proof_info
- );
-
- return sp_runtime::transaction_validity::InvalidTransaction::Stale.into()
- },
- Some(CallInfo::ReceiveMessagesDeliveryProof(proof_info))
- if proof_info.is_obsolete() =>
- {
- log::trace!(
- target: pallet_bridge_messages::LOG_TARGET,
- "Rejecting obsolete messages confirmation transaction: {:?}",
- proof_info,
- );
-
- return sp_runtime::transaction_validity::InvalidTransaction::Stale.into()
- },
- _ => {},
- }
-
- Ok(sp_runtime::transaction_validity::ValidTransaction::default())
- }
-}
-
-/// Returns occupation state of unrewarded relayers vector.
-fn unrewarded_relayers_occupation, I: 'static>(
- inbound_lane_data: &InboundLaneData,
-) -> UnrewardedRelayerOccupation {
- UnrewardedRelayerOccupation {
- free_relayer_slots: T::MaxUnrewardedRelayerEntriesAtInboundLane::get()
- .saturating_sub(inbound_lane_data.relayers.len() as MessageNonce),
- free_message_slots: {
- let unconfirmed_messages = inbound_lane_data
- .last_delivered_nonce()
- .saturating_sub(inbound_lane_data.last_confirmed_nonce);
- T::MaxUnconfirmedMessagesAtInboundLane::get().saturating_sub(unconfirmed_messages)
- },
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::{
- messages::{
- source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
- },
- messages_call_ext::MessagesCallSubType,
- mock::{
- DummyMessageDispatch, MaxUnconfirmedMessagesAtInboundLane,
- MaxUnrewardedRelayerEntriesAtInboundLane, TestRuntime, ThisChainRuntimeCall,
- },
- };
- use bp_messages::{DeliveredMessages, UnrewardedRelayer, UnrewardedRelayersState};
- use sp_std::ops::RangeInclusive;
-
- fn fill_unrewarded_relayers() {
- let mut inbound_lane_state =
- pallet_bridge_messages::InboundLanes::::get(LaneId([0, 0, 0, 0]));
- for n in 0..MaxUnrewardedRelayerEntriesAtInboundLane::get() {
- inbound_lane_state.relayers.push_back(UnrewardedRelayer {
- relayer: Default::default(),
- messages: DeliveredMessages { begin: n + 1, end: n + 1 },
- });
- }
- pallet_bridge_messages::InboundLanes::::insert(
- LaneId([0, 0, 0, 0]),
- inbound_lane_state,
- );
- }
-
- fn fill_unrewarded_messages() {
- let mut inbound_lane_state =
- pallet_bridge_messages::InboundLanes::::get(LaneId([0, 0, 0, 0]));
- inbound_lane_state.relayers.push_back(UnrewardedRelayer {
- relayer: Default::default(),
- messages: DeliveredMessages {
- begin: 1,
- end: MaxUnconfirmedMessagesAtInboundLane::get(),
- },
- });
- pallet_bridge_messages::InboundLanes::::insert(
- LaneId([0, 0, 0, 0]),
- inbound_lane_state,
- );
- }
-
- fn deliver_message_10() {
- pallet_bridge_messages::InboundLanes::::insert(
- LaneId([0, 0, 0, 0]),
- bp_messages::InboundLaneData { relayers: Default::default(), last_confirmed_nonce: 10 },
- );
- }
-
- fn validate_message_delivery(
- nonces_start: bp_messages::MessageNonce,
- nonces_end: bp_messages::MessageNonce,
- ) -> bool {
- ThisChainRuntimeCall::BridgeMessages(
- pallet_bridge_messages::Call::::receive_messages_proof {
- relayer_id_at_bridged_chain: 42,
- messages_count: nonces_end.checked_sub(nonces_start).map(|x| x + 1).unwrap_or(0)
- as u32,
- dispatch_weight: frame_support::weights::Weight::zero(),
- proof: FromBridgedChainMessagesProof {
- bridged_header_hash: Default::default(),
- storage_proof: vec![],
- lane: LaneId([0, 0, 0, 0]),
- nonces_start,
- nonces_end,
- },
- },
- )
- .check_obsolete_call()
- .is_ok()
- }
-
- #[test]
- fn extension_rejects_obsolete_messages() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- // when current best delivered is message#10 and we're trying to deliver messages 8..=9
- // => tx is rejected
- deliver_message_10();
- assert!(!validate_message_delivery(8, 9));
- });
- }
-
- #[test]
- fn extension_rejects_same_message() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- // when current best delivered is message#10 and we're trying to import messages 10..=10
- // => tx is rejected
- deliver_message_10();
- assert!(!validate_message_delivery(8, 10));
- });
- }
-
- #[test]
- fn extension_rejects_call_with_some_obsolete_messages() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- // when current best delivered is message#10 and we're trying to deliver messages
- // 10..=15 => tx is rejected
- deliver_message_10();
- assert!(!validate_message_delivery(10, 15));
- });
- }
-
- #[test]
- fn extension_rejects_call_with_future_messages() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- // when current best delivered is message#10 and we're trying to deliver messages
- // 13..=15 => tx is rejected
- deliver_message_10();
- assert!(!validate_message_delivery(13, 15));
- });
- }
-
- #[test]
- fn extension_reject_call_when_dispatcher_is_inactive() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- // when current best delivered is message#10 and we're trying to deliver message 11..=15
- // => tx is accepted, but we have inactive dispatcher, so...
- deliver_message_10();
-
- DummyMessageDispatch::deactivate();
- assert!(!validate_message_delivery(11, 15));
- });
- }
-
- #[test]
- fn extension_rejects_empty_delivery_with_rewards_confirmations_if_there_are_free_relayer_and_message_slots(
- ) {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- deliver_message_10();
- assert!(!validate_message_delivery(10, 9));
- });
- }
-
- #[test]
- fn extension_accepts_empty_delivery_with_rewards_confirmations_if_there_are_no_free_relayer_slots(
- ) {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- deliver_message_10();
- fill_unrewarded_relayers();
- assert!(validate_message_delivery(10, 9));
- });
- }
-
- #[test]
- fn extension_accepts_empty_delivery_with_rewards_confirmations_if_there_are_no_free_message_slots(
- ) {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- fill_unrewarded_messages();
- assert!(validate_message_delivery(
- MaxUnconfirmedMessagesAtInboundLane::get(),
- MaxUnconfirmedMessagesAtInboundLane::get() - 1
- ));
- });
- }
-
- #[test]
- fn extension_accepts_new_messages() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- // when current best delivered is message#10 and we're trying to deliver message 11..=15
- // => tx is accepted
- deliver_message_10();
- assert!(validate_message_delivery(11, 15));
- });
- }
-
- fn confirm_message_10() {
- pallet_bridge_messages::OutboundLanes::::insert(
- LaneId([0, 0, 0, 0]),
- bp_messages::OutboundLaneData {
- oldest_unpruned_nonce: 0,
- latest_received_nonce: 10,
- latest_generated_nonce: 10,
- },
- );
- }
-
- fn validate_message_confirmation(last_delivered_nonce: bp_messages::MessageNonce) -> bool {
- ThisChainRuntimeCall::BridgeMessages(
- pallet_bridge_messages::Call::::receive_messages_delivery_proof {
- proof: FromBridgedChainMessagesDeliveryProof {
- bridged_header_hash: Default::default(),
- storage_proof: Vec::new(),
- lane: LaneId([0, 0, 0, 0]),
- },
- relayers_state: UnrewardedRelayersState {
- last_delivered_nonce,
- ..Default::default()
- },
- },
- )
- .check_obsolete_call()
- .is_ok()
- }
-
- #[test]
- fn extension_rejects_obsolete_confirmations() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- // when current best confirmed is message#10 and we're trying to confirm message#5 => tx
- // is rejected
- confirm_message_10();
- assert!(!validate_message_confirmation(5));
- });
- }
-
- #[test]
- fn extension_rejects_same_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- // when current best confirmed is message#10 and we're trying to confirm message#10 =>
- // tx is rejected
- confirm_message_10();
- assert!(!validate_message_confirmation(10));
- });
- }
-
- #[test]
- fn extension_rejects_empty_confirmation_even_if_there_are_no_free_unrewarded_entries() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- confirm_message_10();
- fill_unrewarded_relayers();
- assert!(!validate_message_confirmation(10));
- });
- }
-
- #[test]
- fn extension_accepts_new_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- // when current best confirmed is message#10 and we're trying to confirm message#15 =>
- // tx is accepted
- confirm_message_10();
- assert!(validate_message_confirmation(15));
- });
- }
-
- fn was_message_delivery_successful(
- bundled_range: RangeInclusive,
- is_empty: bool,
- ) -> bool {
- CallHelper::::was_successful(&CallInfo::ReceiveMessagesProof(
- ReceiveMessagesProofInfo {
- base: BaseMessagesProofInfo {
- lane_id: LaneId([0, 0, 0, 0]),
- bundled_range,
- best_stored_nonce: 0, // doesn't matter for `was_successful`
- },
- unrewarded_relayers: UnrewardedRelayerOccupation {
- free_relayer_slots: 0, // doesn't matter for `was_successful`
- free_message_slots: if is_empty {
- 0
- } else {
- MaxUnconfirmedMessagesAtInboundLane::get()
- },
- },
- },
- ))
- }
-
- #[test]
- #[allow(clippy::reversed_empty_ranges)]
- fn was_successful_returns_false_for_failed_reward_confirmation_transaction() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- fill_unrewarded_messages();
- assert!(!was_message_delivery_successful(10..=9, true));
- });
- }
-
- #[test]
- #[allow(clippy::reversed_empty_ranges)]
- fn was_successful_returns_true_for_successful_reward_confirmation_transaction() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- assert!(was_message_delivery_successful(10..=9, true));
- });
- }
-
- #[test]
- fn was_successful_returns_false_for_failed_delivery() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- deliver_message_10();
- assert!(!was_message_delivery_successful(10..=12, false));
- });
- }
-
- #[test]
- fn was_successful_returns_false_for_partially_successful_delivery() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- deliver_message_10();
- assert!(!was_message_delivery_successful(9..=12, false));
- });
- }
-
- #[test]
- fn was_successful_returns_true_for_successful_delivery() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- deliver_message_10();
- assert!(was_message_delivery_successful(9..=10, false));
- });
- }
-
- fn was_message_confirmation_successful(bundled_range: RangeInclusive) -> bool {
- CallHelper::::was_successful(&CallInfo::ReceiveMessagesDeliveryProof(
- ReceiveMessagesDeliveryProofInfo(BaseMessagesProofInfo {
- lane_id: LaneId([0, 0, 0, 0]),
- bundled_range,
- best_stored_nonce: 0, // doesn't matter for `was_successful`
- }),
- ))
- }
-
- #[test]
- fn was_successful_returns_false_for_failed_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- confirm_message_10();
- assert!(!was_message_confirmation_successful(10..=12));
- });
- }
-
- #[test]
- fn was_successful_returns_false_for_partially_successful_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- confirm_message_10();
- assert!(!was_message_confirmation_successful(9..=12));
- });
- }
-
- #[test]
- fn was_successful_returns_true_for_successful_confirmation() {
- sp_io::TestExternalities::new(Default::default()).execute_with(|| {
- confirm_message_10();
- assert!(was_message_confirmation_successful(9..=10));
- });
- }
-}
diff --git a/bridges/bin/runtime-common/src/messages_generation.rs b/bridges/bin/runtime-common/src/messages_generation.rs
deleted file mode 100644
index c37aaa5d4d..0000000000
--- a/bridges/bin/runtime-common/src/messages_generation.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity Bridges Common is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity Bridges Common. If not, see .
-
-//! Helpers for generating message storage proofs, that are used by tests and by benchmarks.
-
-use crate::messages::{AccountIdOf, BridgedChain, HashOf, HasherOf, MessageBridge, ThisChain};
-
-use bp_messages::{
- storage_keys, InboundLaneData, LaneId, MessageKey, MessageNonce, MessagePayload,
- OutboundLaneData,
-};
-use bp_runtime::{record_all_trie_keys, RawStorageProof, StorageProofSize};
-use codec::Encode;
-use sp_std::{ops::RangeInclusive, prelude::*};
-use sp_trie::{trie_types::TrieDBMutBuilderV1, LayoutV1, MemoryDB, TrieMut};
-
-/// Simple and correct message data encode function.
-pub fn encode_all_messages(_: MessageNonce, m: &MessagePayload) -> Option> {
- Some(m.encode())
-}
-
-/// Simple and correct outbound lane data encode function.
-pub fn encode_lane_data(d: &OutboundLaneData) -> Vec {
- d.encode()
-}
-
-/// Prepare storage proof of given messages.
-///
-/// Returns state trie root and nodes with prepared messages.
-pub fn prepare_messages_storage_proof(
- lane: LaneId,
- message_nonces: RangeInclusive,
- outbound_lane_data: Option,
- size: StorageProofSize,
- message_payload: MessagePayload,
- encode_message: impl Fn(MessageNonce, &MessagePayload) -> Option>,
- encode_outbound_lane_data: impl Fn(&OutboundLaneData) -> Vec,
-) -> (HashOf>, RawStorageProof)
-where
- B: MessageBridge,
- HashOf>: Copy + Default,
-{
- // prepare Bridged chain storage with messages and (optionally) outbound lane state
- let message_count = message_nonces.end().saturating_sub(*message_nonces.start()) + 1;
- let mut storage_keys = Vec::with_capacity(message_count as usize + 1);
- let mut root = Default::default();
- let mut mdb = MemoryDB::default();
- {
- let mut trie =
- TrieDBMutBuilderV1::>>::new(&mut mdb, &mut root).build();
-
- // insert messages
- for (i, nonce) in message_nonces.into_iter().enumerate() {
- let message_key = MessageKey { lane_id: lane, nonce };
- let message_payload = match encode_message(nonce, &message_payload) {
- Some(message_payload) =>
- if i == 0 {
- grow_trie_leaf_value(message_payload, size)
- } else {
- message_payload
- },
- None => continue,
- };
- let storage_key = storage_keys::message_key(
- B::BRIDGED_MESSAGES_PALLET_NAME,
- &message_key.lane_id,
- message_key.nonce,
- )
- .0;
- trie.insert(&storage_key, &message_payload)
- .map_err(|_| "TrieMut::insert has failed")
- .expect("TrieMut::insert should not fail in benchmarks");
- storage_keys.push(storage_key);
- }
-
- // insert outbound lane state
- if let Some(outbound_lane_data) = outbound_lane_data.as_ref().map(encode_outbound_lane_data)
- {
- let storage_key =
- storage_keys::outbound_lane_data_key(B::BRIDGED_MESSAGES_PALLET_NAME, &lane).0;
- trie.insert(&storage_key, &outbound_lane_data)
- .map_err(|_| "TrieMut::insert has failed")
- .expect("TrieMut::insert should not fail in benchmarks");
- storage_keys.push(storage_key);
- }
- }
-
- // generate storage proof to be delivered to This chain
- let storage_proof = record_all_trie_keys::>>, _>(&mdb, &root)
- .map_err(|_| "record_all_trie_keys has failed")
- .expect("record_all_trie_keys should not fail in benchmarks");
- (root, storage_proof)
-}
-
-/// Prepare storage proof of given messages delivery.
-///
-/// Returns state trie root and nodes with prepared messages.
-pub fn prepare_message_delivery_storage_proof(
- lane: LaneId,
- inbound_lane_data: InboundLaneData>>,
- size: StorageProofSize,
-) -> (HashOf>, RawStorageProof)
-where
- B: MessageBridge,
-{
- // prepare Bridged chain storage with inbound lane state
- let storage_key = storage_keys::inbound_lane_data_key(B::BRIDGED_MESSAGES_PALLET_NAME, &lane).0;
- let mut root = Default::default();
- let mut mdb = MemoryDB::default();
- {
- let mut trie =
- TrieDBMutBuilderV1::