Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
feat(contracts): SkinHook, a Uniswap v4 hook that sells wearable 3D items as coins with wear-to-lock and an unskippable creator royalty
ni3a0ded27005619
diff --git a/contracts/v4-hooks/README.md b/contracts/v4-hooks/README.mdnew file mode 100644index 000000000..3f831a6de--- /dev/null+++ b/contracts/v4-hooks/README.md@@ -0,0 +1,107 @@+# three.ws Uniswap v4 hooks++Hooks that three.ws owns on Uniswap v4. Every hook here is an EVM surface; Solana is+the home chain, and each product built on a hook here has or will have a Solana leg.++| Hook | Source | Flags | Status |+| --- | --- | --- | --- |+| `SkinHook` | [`src/SkinHook.sol`](./src/SkinHook.sol) | `0x20CC` | Not deployed |++Background, prior art, and why these hooks: [`docs/uniswap-v4-hooks.md`](../../docs/uniswap-v4-hooks.md).++## SkinHook: wearable 3D items as coins++Every wearable is a fixed-supply ERC-20 ([`SkinToken`](./src/SkinToken.sol)) with its own+ETH pool, all launched through one singleton hook.++- **Wear-to-lock.** `equip(token)` locks exactly one whole token in the hook and+ `unequip(token)` returns it. A supply of 10,000 means at most 10,000 people can wear the+ item at once, and every wearer takes a token out of the float.+- **A royalty that cannot be skipped.** 2% of the ETH side of every swap is taken inside+ the swap: half to the creator, a quarter to the referrer, a quarter to the platform+ treasury. With no referrer, that quarter goes to the creator.+- **Embed-to-earn.** A swap names its referrer by passing `abi.encode(address)` as+ `hookData`. Anything else is ignored, and a swap with empty `hookData` works normally,+ so any router can trade these pools.+- **Fair launch by construction.** `launch` mints the whole supply into one permanent+ single-sided position that sells from the start price upward. Nothing is held back for+ the creator or the platform, and the position can never be withdrawn.+- **The model is pinned.** `SkinToken.modelHash` is the keccak256 of the GLB, fixed at+ launch. A renderer must refuse a file that does not match it.++Design decisions that matter to a reviewer:++- The hook is its own factory. v4 skips hook callbacks for calls a hook makes itself, so+ `beforeInitialize` only ever runs for an outsider, and it always reverts. Every pool+ that names this hook was launched by it.+- Fees are booked as ERC-6909 claims on the PoolManager and paid out by `claim(to)`.+ A swap never pushes ETH to anyone, so no recipient can block trading, and the first+ buy works even when the PoolManager holds no ETH.+- The fee is always in ETH. When ETH is the specified side of the swap it is taken in+ `beforeSwap` out of the specified amount; otherwise `afterSwap` takes it from the ETH+ that moved. Creators never accumulate their own token and never become sell pressure.+- A referrer can be the trader's own address. That is a 0.5% rebate, it is inherent to+ any on-chain referral, and it comes out of the referrer share only.+- Fee shares and the fee itself are constants. The only owner power is changing the+ treasury address (`Ownable2Step`).++```solidity+(SkinToken token, PoolKey memory key) = hook.launch(+ SkinHook.LaunchParams({+ name: "Halo",+ symbol: "HALO",+ supply: 10_000, // whole tokens, 100 to 1,000,000+ modelURI: "https://three.ws/cdn/skins/halo.glb",+ modelHash: keccak256(glbBytes),+ slot: "head",+ startTick: 92_200, // about 10,100 tokens per ETH; multiple of 200+ creator: msg.sender+ })+);++token.approve(address(hook), 1e18);+hook.equip(token); // wearing it: one token locked+hook.unequip(token); // token returned+hook.claim(payoutAddress); // creator, referrer or treasury withdraws ETH+```++## Build and test++Foundry is required (`curl -L https://foundry.paradigm.xyz | bash && foundryup`).++```bash+cd contracts/v4-hooks+forge build+forge test+```++The suite runs against the real v4-core `PoolManager` and its reference swap router, not+stand-ins. `test/HookMiner.t.sol` proves the production deploy path: a mined CREATE2 salt+lands the hook at an address that passes the hook's own permission check.++## Deploy++A v4 hook's permissions are the low 14 bits of its address, so it must be deployed with a+mined CREATE2 salt. `script/DeploySkinHook.s.sol` mines it and deploys through the+canonical CREATE2 deployer. Without `--broadcast` it is a dry run that prints the address.++```bash+POOL_MANAGER=0x498581ff718922c3f8e6a244956af099b2652b2b \+HOOK_OWNER=0x... HOOK_TREASURY=0x... \+forge script script/DeploySkinHook.s.sol --rpc-url base --broadcast --verify+```++`PoolManager` addresses per chain are in Uniswap's v4 deployment table. Deploying is an+on-chain spend and needs the owner's explicit approval each time. Source verification on+the target explorer is required before the hook can be listed in+[Uniswap/hooklist](https://github.com/Uniswap/hooklist).++## Vendored dependencies++- `lib/v4-core`: Uniswap v4-core at tag `v4.0.0`+ (commit `e50237c43811bd9b526eff40f26772152a42daba`), `src/` plus the one test utility+ the reference routers import. `PoolManager.sol` is BUSL-1.1 and is used here only to+ test against; the hooks import only MIT-licensed interfaces, libraries and types.+- `lib/solmate`: the three files v4-core imports, at the commit v4-core pins+ (`4b47a19038b798b4a33d9749d25e570443520647`).+- forge-std and OpenZeppelin are reused from [`../lib`](../lib).diff --git a/contracts/v4-hooks/foundry.toml b/contracts/v4-hooks/foundry.tomlnew file mode 100644index 000000000..0ea574b67--- /dev/null+++ b/contracts/v4-hooks/foundry.toml@@ -0,0 +1,40 @@+# Uniswap v4 hooks owned by three.ws. Its own profile, like `../hood-portfolios`:+# v4-core needs solc 0.8.26, cancun and via_ir, and the parent project's pinned+# 0.8.24 profile (which its deployed contracts' bytecode depends on) must not move.+# forge-std and OpenZeppelin are reused from `../lib`. v4-core and solmate are vendored+# under `lib/` (pinned commits in README.md): forge resolves a library outside the+# project root under two different paths, which breaks v4-core's import graph.+[profile.default]+src = 'src'+test = 'test'+script = 'script'+out = 'out'+libs = ['lib', '../lib']+solc = '0.8.26'+evm_version = 'cancun'+optimizer = true+optimizer_runs = 44444444+via_ir = true+bytecode_hash = 'none'+remappings = [+ '@uniswap/v4-core/=lib/v4-core/',+ 'solmate/=lib/solmate/',+ '@openzeppelin/contracts/=../lib/openzeppelin-contracts/contracts/',+ 'forge-std/=../lib/forge-std/src/',+]++[profile.default.fuzz]+runs = 512+seed = '0x736b696e'++[profile.ci.fuzz]+runs = 5000++[fmt]+line_length = 120+tab_width = 4+bracket_spacing = false+int_types = 'long'++[rpc_endpoints]+base = "${BASE_RPC_URL}"diff --git a/contracts/v4-hooks/lib/solmate/LICENSE b/contracts/v4-hooks/lib/solmate/LICENSEnew file mode 100644index 000000000..29ebfa545--- /dev/null+++ b/contracts/v4-hooks/lib/solmate/LICENSE@@ -0,0 +1,661 @@+ GNU AFFERO GENERAL PUBLIC LICENSE+ Version 3, 19 November 2007++ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++ Preamble++ The GNU Affero General Public License is a free, copyleft license for+software and other kinds of works, specifically designed to ensure+cooperation with the community in the case of network server software.++ The licenses for most software and other practical works are designed+to take away your freedom to share and change the works. By contrast,+our General Public Licenses are intended to guarantee your freedom to+share and change all versions of a program--to make sure it remains free+software for all its users.++ When we speak of free software, we are referring to freedom, not+price. Our General Public Licenses are designed to make sure that you+have the freedom to distribute copies of free software (and charge for+them if you wish), that you receive source code or can get it if you+want it, that you can change the software or use pieces of it in new+free programs, and that you know you can do these things.++ Developers that use our General Public Licenses protect your rights+with two steps: (1) assert copyright on the software, and (2) offer+you this License which gives you legal permission to copy, distribute+and/or modify the software.++ A secondary benefit of defending all users' freedom is that+improvements made in alternate versions of the program, if they+receive widespread use, become available for other developers to+incorporate. Many developers of free software are heartened and+encouraged by the resulting cooperation. However, in the case of+software used on network servers, this result may fail to come about.+The GNU General Public License permits making a modified version and+letting the public access it on a server without ever releasing its+source code to the public.++ The GNU Affero General Public License is designed specifically to+ensure that, in such cases, the modified source code becomes available+to the community. It requires the operator of a network server to+provide the source code of the modified version running there to the+users of that server. Therefore, public use of a modified version, on+a publicly accessible server, gives the public access to the source+code of the modified version.++ An older license, called the Affero General Public License and+published by Affero, was designed to accomplish similar goals. This is+a different license, not a version of the Affero GPL, but Affero has+released a new version of the Affero GPL which permits relicensing under+this license.++ The precise terms and conditions for copying, distribution and+modification follow.++ TERMS AND CONDITIONS++ 0. Definitions.++ "This License" refers to version 3 of the GNU Affero General Public License.++ "Copyright" also means copyright-like laws that apply to other kinds of+works, such as semiconductor masks.++ "The Program" refers to any copyrightable work licensed under this+License. Each licensee is addressed as "you". "Licensees" and+"recipients" may be individuals or organizations.++ To "modify" a work means to copy from or adapt all or part of the work+in a fashion requiring copyright permission, other than the making of an+exact copy. The resulting work is called a "modified version" of the+earlier work or a work "based on" the earlier work.++ A "covered work" means either the unmodified Program or a work based+on the Program.++ To "propagate" a work means to do anything with it that, without+permission, would make you directly or secondarily liable for+infringement under applicable copyright law, except executing it on a+computer or modifying a private copy. Propagation includes copying,+distribution (with or without modification), making available to the+public, and in some countries other activities as well.++ To "convey" a work means any kind of propagation that enables other+parties to make or receive copies. Mere interaction with a user through+a computer network, with no transfer of a copy, is not conveying.++ An interactive user interface displays "Appropriate Legal Notices"+to the extent that it includes a convenient and prominently visible+feature that (1) displays an appropriate copyright notice, and (2)+tells the user that there is no warranty for the work (except to the+extent that warranties are provided), that licensees may convey the+work under this License, and how to view a copy of this License. If+the interface presents a list of user commands or options, such as a+menu, a prominent item in the list meets this criterion.++ 1. Source Code.++ The "source code" for a work means the preferred form of the work+for making modifications to it. "Object code" means any non-source+form of a work.++ A "Standard Interface" means an interface that either is an official+standard defined by a recognized standards body, or, in the case of+interfaces specified for a particular programming language, one that+is widely used among developers working in that language.++ The "System Libraries" of an executable work include anything, other+than the work as a whole, that (a) is included in the normal form of+packaging a Major Component, but which is not part of that Major+Component, and (b) serves only to enable use of the work with that+Major Component, or to implement a Standard Interface for which an+implementation is available to the public in source code form. A+"Major Component", in this context, means a major essential component+(kernel, window system, and so on) of the specific operating system+(if any) on which the executable work runs, or a compiler used to+produce the work, or an object code interpreter used to run it.++ The "Corresponding Source" for a work in object code form means all+the source code needed to generate, install, and (for an executable+work) run the object code and to modify the work, including scripts to+control those activities. However, it does not include the work's+System Libraries, or general-purpose tools or generally available free+programs which are used unmodified in performing those activities but+which are not part of the work. For example, Corresponding Source+includes interface definition files associated with source files for+the work, and the source code for shared libraries and dynamically+linked subprograms that the work is specifically designed to require,+such as by intimate data communication or control flow between those+subprograms and other parts of the work.++ The Corresponding Source need not include anything that users+can regenerate automatically from other parts of the Corresponding+Source.++ The Corresponding Source for a work in source code form is that+same work.++ 2. Basic Permissions.++ All rights granted under this License are granted for the term of+copyright on the Program, and are irrevocable provided the stated+conditions are met. This License explicitly affirms your unlimited+permission to run the unmodified Program. The output from running a+covered work is covered by this License only if the output, given its+content, constitutes a covered work. This License acknowledges your+rights of fair use or other equivalent, as provided by copyright law.++ You may make, run and propagate covered works that you do not+convey, without conditions so long as your license otherwise remains+in force. You may convey covered works to others for the sole purpose+of having them make modifications exclusively for you, or provide you+with facilities for running those works, provided that you comply with+the terms of this License in conveying all material for which you do+not control copyright. Those thus making or running the covered works+for you must do so exclusively on your behalf, under your direction+and control, on terms that prohibit them from making any copies of+your copyrighted material outside their relationship with you.++ Conveying under any other circumstances is permitted solely under+the conditions stated below. Sublicensing is not allowed; section 10+makes it unnecessary.++ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.++ No covered work shall be deemed part of an effective technological+measure under any applicable law fulfilling obligations under article+11 of the WIPO copyright treaty adopted on 20 December 1996, or+similar laws prohibiting or restricting circumvention of such+measures.++ When you convey a covered work, you waive any legal power to forbid+circumvention of technological measures to the extent such circumvention+is effected by exercising rights under this License with respect to+the covered work, and you disclaim any intention to limit operation or+modification of the work as a means of enforcing, against the work's+users, your or third parties' legal rights to forbid circumvention of+technological measures.++ 4. Conveying Verbatim Copies.++ You may convey verbatim copies of the Program's source code as you+receive it, in any medium, provided that you conspicuously and+appropriately publish on each copy an appropriate copyright notice;+keep intact all notices stating that this License and any+non-permissive terms added in accord with section 7 apply to the code;+keep intact all notices of the absence of any warranty; and give all+recipients a copy of this License along with the Program.++ You may charge any price or no price for each copy that you convey,+and you may offer support or warranty protection for a fee.++ 5. Conveying Modified Source Versions.++ You may convey a work based on the Program, or the modifications to+produce it from the Program, in the form of source code under the+terms of section 4, provided that you also meet all of these conditions:++ a) The work must carry prominent notices stating that you modified+ it, and giving a relevant date.++ b) The work must carry prominent notices stating that it is+ released under this License and any conditions added under section+ 7. This requirement modifies the requirement in section 4 to+ "keep intact all notices".++ c) You must license the entire work, as a whole, under this+ License to anyone who comes into possession of a copy. This+ License will therefore apply, along with any applicable section 7+ additional terms, to the whole of the work, and all its parts,+ regardless of how they are packaged. This License gives no+ permission to license the work in any other way, but it does not+ invalidate such permission if you have separately received it.++ d) If the work has interactive user interfaces, each must display+ Appropriate Legal Notices; however, if the Program has interactive+ interfaces that do not display Appropriate Legal Notices, your+ work need not make them do so.++ A compilation of a covered work with other separate and independent+works, which are not by their nature extensions of the covered work,+and which are not combined with it such as to form a larger program,+in or on a volume of a storage or distribution medium, is called an+"aggregate" if the compilation and its resulting copyright are not+used to limit the access or legal rights of the compilation's users+beyond what the individual works permit. Inclusion of a covered work+in an aggregate does not cause this License to apply to the other+parts of the aggregate.++ 6. Conveying Non-Source Forms.++ You may convey a covered work in object code form under the terms+of sections 4 and 5, provided that you also convey the+machine-readable Corresponding Source under the terms of this License,+in one of these ways:++ a) Convey the object code in, or embodied in, a physical product+ (including a physical distribution medium), accompanied by the+ Corresponding Source fixed on a durable physical medium+ customarily used for software interchange.++ b) Convey the object code in, or embodied in, a physical product+ (including a physical distribution medium), accompanied by a+ written offer, valid for at least three years and valid for as+ long as you offer spare parts or customer support for that product+ model, to give anyone who possesses the object code either (1) a+ copy of the Corresponding Source for all the software in the+ product that is covered by this License, on a durable physical+ medium customarily used for software interchange, for a price no+ more than your reasonable cost of physically performing this+ conveying of source, or (2) access to copy the+ Corresponding Source from a network server at no charge.++ c) Convey individual copies of the object code with a copy of the+ written offer to provide the Corresponding Source. This+ alternative is allowed only occasionally and noncommercially, and+ only if you received the object code with such an offer, in accord+ with subsection 6b.++ d) Convey the object code by offering access from a designated+ place (gratis or for a charge), and offer equivalent access to the+ Corresponding Source in the same way through the same place at no+ further charge. You need not require recipients to copy the+ Corresponding Source along with the object code. If the place to+ copy the object code is a network server, the Corresponding Source+ may be on a different server (operated by you or a third party)+ that supports equivalent copying facilities, provided you maintain+ clear directions next to the object code saying where to find the+ Corresponding Source. Regardless of what server hosts the+ Corresponding Source, you remain obligated to ensure that it is+ available for as long as needed to satisfy these requirements.++ e) Convey the object code using peer-to-peer transmission, provided+ you inform other peers where the object code and Corresponding+ Source of the work are being offered to the general public at no+ charge under subsection 6d.++ A separable portion of the object code, whose source code is excluded+from the Corresponding Source as a System Library, need not be+included in conveying the object code work.++ A "User Product" is either (1) a "consumer product", which means any+tangible personal property which is normally used for personal, family,+or household purposes, or (2) anything designed or sold for incorporation+into a dwelling. In determining whether a product is a consumer product,+doubtful cases shall be resolved in favor of coverage. For a particular+product received by a particular user, "normally used" refers to a+typical or common use of that class of product, regardless of the status+of the particular user or of the way in which the particular user+actually uses, or expects or is expected to use, the product. A product+is a consumer product regardless of whether the product has substantial+commercial, industrial or non-consumer uses, unless such uses represent+the only significant mode of use of the product.++ "Installation Information" for a User Product means any methods,+procedures, authorization keys, or other information required to install+and execute modified versions of a covered work in that User Product from+a modified version of its Corresponding Source. The information must+suffice to ensure that the continued functioning of the modified object+code is in no case prevented or interfered with solely because+modification has been made.++ If you convey an object code work under this section in, or with, or+specifically for use in, a User Product, and the conveying occurs as+part of a transaction in which the right of possession and use of the+User Product is transferred to the recipient in perpetuity or for a+fixed term (regardless of how the transaction is characterized), the+Corresponding Source conveyed under this section must be accompanied+by the Installation Information. But this requirement does not apply+if neither you nor any third party retains the ability to install+modified object code on the User Product (for example, the work has+been installed in ROM).++ The requirement to provide Installation Information does not include a+requirement to continue to provide support service, warranty, or updates+for a work that has been modified or installed by the recipient, or for+the User Product in which it has been modified or installed. Access to a+network may be denied when the modification itself materially and+adversely affects the operation of the network or violates the rules and+protocols for communication across the network.++ Corresponding Source conveyed, and Installation Information provided,+in accord with this section must be in a format that is publicly+documented (and with an implementation available to the public in+source code form), and must require no special password or key for+unpacking, reading or copying.++ 7. Additional Terms.++ "Additional permissions" are terms that supplement the terms of this+License by making exceptions from one or more of its conditions.+Additional permissions that are applicable to the entire Program shall+be treated as though they were included in this License, to the extent+that they are valid under applicable law. If additional permissions+apply only to part of the Program, that part may be used separately+under those permissions, but the entire Program remains governed by+this License without regard to the additional permissions.++ When you convey a copy of a covered work, you may at your option+remove any additional permissions from that copy, or from any part of+it. (Additional permissions may be written to require their own+removal in certain cases when you modify the work.) You may place+additional permissions on material, added by you to a covered work,+for which you have or can give appropriate copyright permission.++ Notwithstanding any other provision of this License, for material you+add to a covered work, you may (if authorized by the copyright holders of+that material) supplement the terms of this License with terms:++ a) Disclaiming warranty or limiting liability differently from the+ terms of sections 15 and 16 of this License; or++ b) Requiring preservation of specified reasonable legal notices or+ author attributions in that material or in the Appropriate Legal+ Notices displayed by works containing it; or++ c) Prohibiting misrepresentation of the origin of that material, or+ requiring that modified versions of such material be marked in+ reasonable ways as different from the original version; or++ d) Limiting the use for publicity purposes of names of licensors or+ authors of the material; or++ e) Declining to grant rights under trademark law for use of some+ trade names, trademarks, or service marks; or++ f) Requiring indemnification of licensors and authors of that+ material by anyone who conveys the material (or modified versions of+ it) with contractual assumptions of liability to the recipient, for+ any liability that these contractual assumptions directly impose on+ those licensors and authors.++ All other non-permissive additional terms are considered "further+restrictions" within the meaning of section 10. If the Program as you+received it, or any part of it, contains a notice stating that it is+governed by this License along with a term that is a further+restriction, you may remove that term. If a license document contains+a further restriction but permits relicensing or conveying under this+License, you may add to a covered work material governed by the terms+of that license document, provided that the further restriction does+not survive such relicensing or conveying.++ If you add terms to a covered work in accord with this section, you+must place, in the relevant source files, a statement of the+additional terms that apply to those files, or a notice indicating+where to find the applicable terms.++ Additional terms, permissive or non-permissive, may be stated in the+form of a separately written license, or stated as exceptions;+the above requirements apply either way.++ 8. Termination.++ You may not propagate or modify a covered work except as expressly+provided under this License. Any attempt otherwise to propagate or+modify it is void, and will automatically terminate your rights under+this License (including any patent licenses granted under the third+paragraph of section 11).++ However, if you cease all violation of this License, then your+license from a particular copyright holder is reinstated (a)+provisionally, unless and until the copyright holder explicitly and+finally terminates your license, and (b) permanently, if the copyright+holder fails to notify you of the violation by some reasonable means+prior to 60 days after the cessation.++ Moreover, your license from a particular copyright holder is+reinstated permanently if the copyright holder notifies you of the+violation by some reasonable means, this is the first time you have+received notice of violation of this License (for any work) from that+copyright holder, and you cure the violation prior to 30 days after+your receipt of the notice.++ Termination of your rights under this section does not terminate the+licenses of parties who have received copies or rights from you under+this License. If your rights have been terminated and not permanently+reinstated, you do not qualify to receive new licenses for the same+material under section 10.++ 9. Acceptance Not Required for Having Copies.++ You are not required to accept this License in order to receive or+run a copy of the Program. Ancillary propagation of a covered work+occurring solely as a consequence of using peer-to-peer transmission+to receive a copy likewise does not require acceptance. However,+nothing other than this License grants you permission to propagate or+modify any covered work. These actions infringe copyright if you do+not accept this License. Therefore, by modifying or propagating a+covered work, you indicate your acceptance of this License to do so.++ 10. Automatic Licensing of Downstream Recipients.++ Each time you convey a covered work, the recipient automatically+receives a license from the original licensors, to run, modify and+propagate that work, subject to this License. You are not responsible+for enforcing compliance by third parties with this License.++ An "entity transaction" is a transaction transferring control of an+organization, or substantially all assets of one, or subdividing an+organization, or merging organizations. If propagation of a covered+work results from an entity transaction, each party to that+transaction who receives a copy of the work also receives whatever+licenses to the work the party's predecessor in interest had or could+give under the previous paragraph, plus a right to possession of the+Corresponding Source of the work from the predecessor in interest, if+the predecessor has it or can get it with reasonable efforts.++ You may not impose any further restrictions on the exercise of the+rights granted or affirmed under this License. For example, you may+not impose a license fee, royalty, or other charge for exercise of+rights granted under this License, and you may not initiate litigation+(including a cross-claim or counterclaim in a lawsuit) alleging that+any patent claim is infringed by making, using, selling, offering for+sale, or importing the Program or any portion of it.++ 11. Patents.++ A "contributor" is a copyright holder who authorizes use under this+License of the Program or a work on which the Program is based. The+work thus licensed is called the contributor's "contributor version".++ A contributor's "essential patent claims" are all patent claims+owned or controlled by the contributor, whether already acquired or+hereafter acquired, that would be infringed by some manner, permitted+by this License, of making, using, or selling its contributor version,+but do not include claims that would be infringed only as a+consequence of further modification of the contributor version. For+purposes of this definition, "control" includes the right to grant+patent sublicenses in a manner consistent with the requirements of+this License.++ Each contributor grants you a non-exclusive, worldwide, royalty-free+patent license under the contributor's essential patent claims, to+make, use, sell, offer for sale, import and otherwise run, modify and+propagate the contents of its contributor version.++ In the following three paragraphs, a "patent license" is any express+agreement or commitment, however denominated, not to enforce a patent+(such as an express permission to practice a patent or covenant not to+sue for patent infringement). To "grant" such a patent license to a+party means to make such an agreement or commitment not to enforce a+patent against the party.++ If you convey a covered work, knowingly relying on a patent license,+and the Corresponding Source of the work is not available for anyone+to copy, free of charge and under the terms of this License, through a+publicly available network server or other readily accessible means,+then you must either (1) cause the Corresponding Source to be so+available, or (2) arrange to deprive yourself of the benefit of the+patent license for this particular work, or (3) arrange, in a manner+consistent with the requirements of this License, to extend the patent+license to downstream recipients. "Knowingly relying" means you have+actual knowledge that, but for the patent license, your conveying the+covered work in a country, or your recipient's use of the covered work+in a country, would infringe one or more identifiable patents in that+country that you have reason to believe are valid.++ If, pursuant to or in connection with a single transaction or+arrangement, you convey, or propagate by procuring conveyance of, a+covered work, and grant a patent license to some of the parties+receiving the covered work authorizing them to use, propagate, modify+or convey a specific copy of the covered work, then the patent license+you grant is automatically extended to all recipients of the covered+work and works based on it.++ A patent license is "discriminatory" if it does not include within+the scope of its coverage, prohibits the exercise of, or is+conditioned on the non-exercise of one or more of the rights that are+specifically granted under this License. You may not convey a covered+work if you are a party to an arrangement with a third party that is+in the business of distributing software, under which you make payment+to the third party based on the extent of your activity of conveying+the work, and under which the third party grants, to any of the+parties who would receive the covered work from you, a discriminatory+patent license (a) in connection with copies of the covered work+conveyed by you (or copies made from those copies), or (b) primarily+for and in connection with specific products or compilations that+contain the covered work, unless you entered into that arrangement,+or that patent license was granted, prior to 28 March 2007.++ Nothing in this License shall be construed as excluding or limiting+any implied license or other defenses to infringement that may+otherwise be available to you under applicable patent law.++ 12. No Surrender of Others' Freedom.++ If conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License. If you cannot convey a+covered work so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you may+not convey it at all. For example, if you agree to terms that obligate you+to collect a royalty for further conveying from those to whom you convey+the Program, the only way you could satisfy both those terms and this+License would be to refrain entirely from conveying the Program.++ 13. Remote Network Interaction; Use with the GNU General Public License.++ Notwithstanding any other provision of this License, if you modify the+Program, your modified version must prominently offer all users+interacting with it remotely through a computer network (if your version+supports such interaction) an opportunity to receive the Corresponding+Source of your version by providing access to the Corresponding Source+from a network server at no charge, through some standard or customary+means of facilitating copying of software. This Corresponding Source+shall include the Corresponding Source for any work covered by version 3+of the GNU General Public License that is incorporated pursuant to the+following paragraph.++ Notwithstanding any other provision of this License, you have+permission to link or combine any covered work with a work licensed+under version 3 of the GNU General Public License into a single+combined work, and to convey the resulting work. The terms of this+License will continue to apply to the part which is the covered work,+but the work with which it is combined will remain governed by version+3 of the GNU General Public License.++ 14. Revised Versions of this License.++ The Free Software Foundation may publish revised and/or new versions of+the GNU Affero General Public License from time to time. Such new versions+will be similar in spirit to the present version, but may differ in detail to+address new problems or concerns.++ Each version is given a distinguishing version number. If the+Program specifies that a certain numbered version of the GNU Affero General+Public License "or any later version" applies to it, you have the+option of following the terms and conditions either of that numbered+version or of any later version published by the Free Software+Foundation. If the Program does not specify a version number of the+GNU Affero General Public License, you may choose any version ever published+by the Free Software Foundation.++ If the Program specifies that a proxy can decide which future+versions of the GNU Affero General Public License can be used, that proxy's+public statement of acceptance of a version permanently authorizes you+to choose that version for the Program.++ Later license versions may give you additional or different+permissions. However, no additional obligations are imposed on any+author or copyright holder as a result of your choosing to follow a+later version.++ 15. Disclaimer of Warranty.++ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++ 16. Limitation of Liability.++ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF+SUCH DAMAGES.++ 17. Interpretation of Sections 15 and 16.++ If the disclaimer of warranty and limitation of liability provided+above cannot be given local legal effect according to their terms,+reviewing courts shall apply local law that most closely approximates+an absolute waiver of all civil liability in connection with the+Program, unless a warranty or assumption of liability accompanies a+copy of the Program in return for a fee.++ END OF TERMS AND CONDITIONS++ How to Apply These Terms to Your New Programs++ If you develop a new program, and you want it to be of the greatest+possible use to the public, the best way to achieve this is to make it+free software which everyone can redistribute and change under these terms.++ To do so, attach the following notices to the program. It is safest+to attach them to the start of each source file to most effectively+state the exclusion of warranty; and each file should have at least+the "copyright" line and a pointer to where the full notice is found.++ <one line to give the program's name and a brief idea of what it does.>+ Copyright (C) <year> <name of author>++ This program is free software: you can redistribute it and/or modify+ it under the terms of the GNU Affero General Public License as published+ by the Free Software Foundation, either version 3 of the License, or+ (at your option) any later version.++ This program is distributed in the hope that it will be useful,+ but WITHOUT ANY WARRANTY; without even the implied warranty of+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+ GNU Affero General Public License for more details.++ You should have received a copy of the GNU Affero General Public License+ along with this program. If not, see <https://www.gnu.org/licenses/>.++Also add information on how to contact you by electronic and paper mail.++ If your software can interact with users remotely through a computer+network, you should also make sure that it provides a way for users to+get its source. For example, if your program is a web application, its+interface could display a "Source" link that leads users to an archive+of the code. There are many ways you could offer source, and different+solutions will be better for different programs; see section 13 for the+specific requirements.++ You should also get your employer (if you work as a programmer) or school,+if any, to sign a "copyright disclaimer" for the program, if necessary.+For more information on this, and how to apply and follow the GNU AGPL, see+<https://www.gnu.org/licenses/>.\ No newline at end of filediff --git a/contracts/v4-hooks/lib/solmate/src/auth/Owned.sol b/contracts/v4-hooks/lib/solmate/src/auth/Owned.solnew file mode 100644index 000000000..e82b44d83--- /dev/null+++ b/contracts/v4-hooks/lib/solmate/src/auth/Owned.sol@@ -0,0 +1,44 @@+// SPDX-License-Identifier: AGPL-3.0-only+pragma solidity >=0.8.0;++/// @notice Simple single owner authorization mixin.+/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)+abstract contract Owned {+ /*//////////////////////////////////////////////////////////////+ EVENTS+ //////////////////////////////////////////////////////////////*/++ event OwnershipTransferred(address indexed user, address indexed newOwner);++ /*//////////////////////////////////////////////////////////////+ OWNERSHIP STORAGE+ //////////////////////////////////////////////////////////////*/++ address public owner;++ modifier onlyOwner() virtual {+ require(msg.sender == owner, "UNAUTHORIZED");++ _;+ }++ /*//////////////////////////////////////////////////////////////+ CONSTRUCTOR+ //////////////////////////////////////////////////////////////*/++ constructor(address _owner) {+ owner = _owner;++ emit OwnershipTransferred(address(0), _owner);+ }++ /*//////////////////////////////////////////////////////////////+ OWNERSHIP LOGIC+ //////////////////////////////////////////////////////////////*/++ function transferOwnership(address newOwner) public virtual onlyOwner {+ owner = newOwner;++ emit OwnershipTransferred(msg.sender, newOwner);+ }+}diff --git a/contracts/v4-hooks/lib/solmate/src/test/utils/mocks/MockERC20.sol b/contracts/v4-hooks/lib/solmate/src/test/utils/mocks/MockERC20.solnew file mode 100644index 000000000..fbbaef5a1--- /dev/null+++ b/contracts/v4-hooks/lib/solmate/src/test/utils/mocks/MockERC20.sol@@ -0,0 +1,20 @@+// SPDX-License-Identifier: AGPL-3.0-only+pragma solidity >=0.8.0;++import {ERC20} from "../../../tokens/ERC20.sol";++contract MockERC20 is ERC20 {+ constructor(+ string memory _name,+ string memory _symbol,+ uint8 _decimals+ ) ERC20(_name, _symbol, _decimals) {}++ function mint(address to, uint256 value) public virtual {+ _mint(to, value);+ }++ function burn(address from, uint256 value) public virtual {+ _burn(from, value);+ }+}diff --git a/contracts/v4-hooks/lib/solmate/src/tokens/ERC20.sol b/contracts/v4-hooks/lib/solmate/src/tokens/ERC20.solnew file mode 100644index 000000000..965704466--- /dev/null+++ b/contracts/v4-hooks/lib/solmate/src/tokens/ERC20.sol@@ -0,0 +1,206 @@+// SPDX-License-Identifier: AGPL-3.0-only+pragma solidity >=0.8.0;++/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.+/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)+/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)+/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.+abstract contract ERC20 {+ /*//////////////////////////////////////////////////////////////+ EVENTS+ //////////////////////////////////////////////////////////////*/++ event Transfer(address indexed from, address indexed to, uint256 amount);++ event Approval(address indexed owner, address indexed spender, uint256 amount);++ /*//////////////////////////////////////////////////////////////+ METADATA STORAGE+ //////////////////////////////////////////////////////////////*/++ string public name;++ string public symbol;++ uint8 public immutable decimals;++ /*//////////////////////////////////////////////////////////////+ ERC20 STORAGE+ //////////////////////////////////////////////////////////////*/++ uint256 public totalSupply;++ mapping(address => uint256) public balanceOf;++ mapping(address => mapping(address => uint256)) public allowance;++ /*//////////////////////////////////////////////////////////////+ EIP-2612 STORAGE+ //////////////////////////////////////////////////////////////*/++ uint256 internal immutable INITIAL_CHAIN_ID;++ bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;++ mapping(address => uint256) public nonces;++ /*//////////////////////////////////////////////////////////////+ CONSTRUCTOR+ //////////////////////////////////////////////////////////////*/++ constructor(+ string memory _name,+ string memory _symbol,+ uint8 _decimals+ ) {+ name = _name;+ symbol = _symbol;+ decimals = _decimals;++ INITIAL_CHAIN_ID = block.chainid;+ INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();+ }++ /*//////////////////////////////////////////////////////////////+ ERC20 LOGIC+ //////////////////////////////////////////////////////////////*/++ function approve(address spender, uint256 amount) public virtual returns (bool) {+ allowance[msg.sender][spender] = amount;++ emit Approval(msg.sender, spender, amount);++ return true;+ }++ function transfer(address to, uint256 amount) public virtual returns (bool) {+ balanceOf[msg.sender] -= amount;++ // Cannot overflow because the sum of all user+ // balances can't exceed the max uint256 value.+ unchecked {+ balanceOf[to] += amount;+ }++ emit Transfer(msg.sender, to, amount);++ return true;+ }++ function transferFrom(+ address from,+ address to,+ uint256 amount+ ) public virtual returns (bool) {+ uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.++ if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;++ balanceOf[from] -= amount;++ // Cannot overflow because the sum of all user+ // balances can't exceed the max uint256 value.+ unchecked {+ balanceOf[to] += amount;+ }++ emit Transfer(from, to, amount);++ return true;+ }++ /*//////////////////////////////////////////////////////////////+ EIP-2612 LOGIC+ //////////////////////////////////////////////////////////////*/++ function permit(+ address owner,+ address spender,+ uint256 value,+ uint256 deadline,+ uint8 v,+ bytes32 r,+ bytes32 s+ ) public virtual {+ require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");++ // Unchecked because the only math done is incrementing+ // the owner's nonce which cannot realistically overflow.+ unchecked {+ address recoveredAddress = ecrecover(+ keccak256(+ abi.encodePacked(+ "\x19\x01",+ DOMAIN_SEPARATOR(),+ keccak256(+ abi.encode(+ keccak256(+ "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"+ ),+ owner,+ spender,+ value,+ nonces[owner]++,+ deadline+ )+ )+ )+ ),+ v,+ r,+ s+ );++ require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");++ allowance[recoveredAddress][spender] = value;+ }++ emit Approval(owner, spender, value);+ }++ function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {+ return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();+ }++ function computeDomainSeparator() internal view virtual returns (bytes32) {+ return+ keccak256(+ abi.encode(+ keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),+ keccak256(bytes(name)),+ keccak256("1"),+ block.chainid,+ address(this)+ )+ );+ }++ /*//////////////////////////////////////////////////////////////+ INTERNAL MINT/BURN LOGIC+ //////////////////////////////////////////////////////////////*/++ function _mint(address to, uint256 amount) internal virtual {+ totalSupply += amount;++ // Cannot overflow because the sum of all user+ // balances can't exceed the max uint256 value.+ unchecked {+ balanceOf[to] += amount;+ }++ emit Transfer(address(0), to, amount);+ }++ function _burn(address from, uint256 amount) internal virtual {+ balanceOf[from] -= amount;++ // Cannot underflow because a user's balance+ // will never be larger than the total supply.+ unchecked {+ totalSupply -= amount;+ }++ emit Transfer(from, address(0), amount);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/licenses/BUSL_LICENSE b/contracts/v4-hooks/lib/v4-core/licenses/BUSL_LICENSEnew file mode 100644index 000000000..8cbb61926--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/licenses/BUSL_LICENSE@@ -0,0 +1,63 @@+Business Source License 1.1++License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.+"Business Source License" is a trademark of MariaDB Corporation Ab.++-----------------------------------------------------------------------------++Parameters++Licensor: Universal Navigation Inc.++Licensed Work: Uniswap V4 Core+ The Licensed Work is (c) 2023 Universal Navigation Inc.++Additional Use Grant: Any uses listed and defined at+ v4-core-license-grants.uniswap.eth++Change Date: The earlier of 2027-06-15 or a date specified at+ v4-core-license-date.uniswap.eth++Change License: MIT License++-----------------------------------------------------------------------------++Terms++The Licensor hereby grants you the right to copy, modify, create derivative works, redistribute, and make non-production use of the Licensed Work. The Licensor may make an Additional Use Grant, above, permitting limited production use.++Effective on the Change Date, or the fourth anniversary of the first publicly available distribution of a specific version of the Licensed Work under this License, whichever comes first, the Licensor hereby grants you rights under the terms of the Change License, and the rights granted in the paragraph above terminate.++If your use of the Licensed Work does not comply with the requirements currently in effect as described in this License, you must purchase a commercial license from the Licensor, its affiliated entities, or authorized resellers, or you must refrain from using the Licensed Work.++All copies of the original and modified Licensed Work, and derivative works of the Licensed Work, are subject to this License. This License applies separately for each version of the Licensed Work and the Change Date may vary for each version of the Licensed Work released by Licensor.++You must conspicuously display this License on each original or modified copy of the Licensed Work. If you receive the Licensed Work in original or modified form from a third party, the terms and conditions set forth in this License apply to your use of that work.++Any use of the Licensed Work in violation of this License will automatically terminate your rights under this License for the current and all other versions of the Licensed Work.++This License does not grant you any right in any trademark or logo of Licensor or its affiliates (provided that you may use a trademark or logo of Licensor as expressly required by this License).++TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND TITLE.++MariaDB hereby grants you permission to use this License’s text to license your works, and to refer to it using the trademark "Business Source License", as long as you comply with the Covenants of Licensor below.++-----------------------------------------------------------------------------++Covenants of Licensor++In consideration of the right to use this License’s text and the "Business Source License" name and trademark, Licensor covenants to MariaDB, and to all other recipients of the licensed work to be provided by Licensor:++1. To specify as the Change License the GPL Version 2.0 or any later version, or a license that is compatible with GPL Version 2.0 or a later version, where "compatible" means that software provided under the Change License can be included in a program with software provided under GPL Version 2.0 or a later version. Licensor may specify additional Change Licenses without limitation.++2. To either: (a) specify an additional grant of rights to use that does not impose any additional restriction on the right granted in this License, as the Additional Use Grant; or (b) insert the text "None".++3. To specify a Change Date.++4. Not to modify this License in any other way.++-----------------------------------------------------------------------------++Notice++The Business Source License (this document, or the "License") is not an Open Source license. However, the Licensed Work will eventually be made available under an Open Source License, as stated in this License.diff --git a/contracts/v4-hooks/lib/v4-core/licenses/MIT_LICENSE b/contracts/v4-hooks/lib/v4-core/licenses/MIT_LICENSEnew file mode 100644index 000000000..e1ac41ac3--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/licenses/MIT_LICENSE@@ -0,0 +1,7 @@+Copyright 2023 Universal Navigation Inc.++Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:++The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\ No newline at end of filediff --git a/contracts/v4-hooks/lib/v4-core/src/ERC6909.sol b/contracts/v4-hooks/lib/v4-core/src/ERC6909.solnew file mode 100644index 000000000..3ba7e9b95--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/ERC6909.sol@@ -0,0 +1,90 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {IERC6909Claims} from "./interfaces/external/IERC6909Claims.sol";++/// @notice Minimalist and gas efficient standard ERC6909 implementation.+/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC6909.sol)+/// @dev Copied from the commit at 4b47a19038b798b4a33d9749d25e570443520647+/// @dev This contract has been modified from the implementation at the above link.+abstract contract ERC6909 is IERC6909Claims {+ /*//////////////////////////////////////////////////////////////+ ERC6909 STORAGE+ //////////////////////////////////////////////////////////////*/++ mapping(address owner => mapping(address operator => bool isOperator)) public isOperator;++ mapping(address owner => mapping(uint256 id => uint256 balance)) public balanceOf;++ mapping(address owner => mapping(address spender => mapping(uint256 id => uint256 amount))) public allowance;++ /*//////////////////////////////////////////////////////////////+ ERC6909 LOGIC+ //////////////////////////////////////////////////////////////*/++ function transfer(address receiver, uint256 id, uint256 amount) public virtual returns (bool) {+ balanceOf[msg.sender][id] -= amount;++ balanceOf[receiver][id] += amount;++ emit Transfer(msg.sender, msg.sender, receiver, id, amount);++ return true;+ }++ function transferFrom(address sender, address receiver, uint256 id, uint256 amount) public virtual returns (bool) {+ if (msg.sender != sender && !isOperator[sender][msg.sender]) {+ uint256 allowed = allowance[sender][msg.sender][id];+ if (allowed != type(uint256).max) allowance[sender][msg.sender][id] = allowed - amount;+ }++ balanceOf[sender][id] -= amount;++ balanceOf[receiver][id] += amount;++ emit Transfer(msg.sender, sender, receiver, id, amount);++ return true;+ }++ function approve(address spender, uint256 id, uint256 amount) public virtual returns (bool) {+ allowance[msg.sender][spender][id] = amount;++ emit Approval(msg.sender, spender, id, amount);++ return true;+ }++ function setOperator(address operator, bool approved) public virtual returns (bool) {+ isOperator[msg.sender][operator] = approved;++ emit OperatorSet(msg.sender, operator, approved);++ return true;+ }++ /*//////////////////////////////////////////////////////////////+ ERC165 LOGIC+ //////////////////////////////////////////////////////////////*/++ function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {+ return interfaceId == 0x01ffc9a7 // ERC165 Interface ID for ERC165+ || interfaceId == 0x0f632fb3; // ERC165 Interface ID for ERC6909+ }++ /*//////////////////////////////////////////////////////////////+ INTERNAL MINT/BURN LOGIC+ //////////////////////////////////////////////////////////////*/++ function _mint(address receiver, uint256 id, uint256 amount) internal virtual {+ balanceOf[receiver][id] += amount;++ emit Transfer(msg.sender, address(0), receiver, id, amount);+ }++ function _burn(address sender, uint256 id, uint256 amount) internal virtual {+ balanceOf[sender][id] -= amount;++ emit Transfer(msg.sender, sender, address(0), id, amount);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/ERC6909Claims.sol b/contracts/v4-hooks/lib/v4-core/src/ERC6909Claims.solnew file mode 100644index 000000000..fb0b212cc--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/ERC6909Claims.sol@@ -0,0 +1,23 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {ERC6909} from "./ERC6909.sol";++/// @notice ERC6909Claims inherits ERC6909 and implements an internal burnFrom function+abstract contract ERC6909Claims is ERC6909 {+ /// @notice Burn `amount` tokens of token type `id` from `from`.+ /// @dev if sender is not `from` they must be an operator or have sufficient allowance.+ /// @param from The address to burn tokens from.+ /// @param id The currency to burn.+ /// @param amount The amount to burn.+ function _burnFrom(address from, uint256 id, uint256 amount) internal {+ address sender = msg.sender;+ if (from != sender && !isOperator[from][sender]) {+ uint256 senderAllowance = allowance[from][sender][id];+ if (senderAllowance != type(uint256).max) {+ allowance[from][sender][id] = senderAllowance - amount;+ }+ }+ _burn(from, id, amount);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/Extsload.sol b/contracts/v4-hooks/lib/v4-core/src/Extsload.solnew file mode 100644index 000000000..96ddc43d1--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/Extsload.sol@@ -0,0 +1,64 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {IExtsload} from "./interfaces/IExtsload.sol";++/// @notice Enables public storage access for efficient state retrieval by external contracts.+/// https://eips.ethereum.org/EIPS/eip-2330#rationale+abstract contract Extsload is IExtsload {+ /// @inheritdoc IExtsload+ function extsload(bytes32 slot) external view returns (bytes32) {+ assembly ("memory-safe") {+ mstore(0, sload(slot))+ return(0, 0x20)+ }+ }++ /// @inheritdoc IExtsload+ function extsload(bytes32 startSlot, uint256 nSlots) external view returns (bytes32[] memory) {+ assembly ("memory-safe") {+ let memptr := mload(0x40)+ let start := memptr+ // A left bit-shift of 5 is equivalent to multiplying by 32 but costs less gas.+ let length := shl(5, nSlots)+ // The abi offset of dynamic array in the returndata is 32.+ mstore(memptr, 0x20)+ // Store the length of the array returned+ mstore(add(memptr, 0x20), nSlots)+ // update memptr to the first location to hold a result+ memptr := add(memptr, 0x40)+ let end := add(memptr, length)+ for {} 1 {} {+ mstore(memptr, sload(startSlot))+ memptr := add(memptr, 0x20)+ startSlot := add(startSlot, 1)+ if iszero(lt(memptr, end)) { break }+ }+ return(start, sub(end, start))+ }+ }++ /// @inheritdoc IExtsload+ function extsload(bytes32[] calldata slots) external view returns (bytes32[] memory) {+ assembly ("memory-safe") {+ let memptr := mload(0x40)+ let start := memptr+ // for abi encoding the response - the array will be found at 0x20+ mstore(memptr, 0x20)+ // next we store the length of the return array+ mstore(add(memptr, 0x20), slots.length)+ // update memptr to the first location to hold an array entry+ memptr := add(memptr, 0x40)+ // A left bit-shift of 5 is equivalent to multiplying by 32 but costs less gas.+ let end := add(memptr, shl(5, slots.length))+ let calldataptr := slots.offset+ for {} 1 {} {+ mstore(memptr, sload(calldataload(calldataptr)))+ memptr := add(memptr, 0x20)+ calldataptr := add(calldataptr, 0x20)+ if iszero(lt(memptr, end)) { break }+ }+ return(start, sub(end, start))+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/Exttload.sol b/contracts/v4-hooks/lib/v4-core/src/Exttload.solnew file mode 100644index 000000000..ad24b75a0--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/Exttload.sol@@ -0,0 +1,40 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.24;++import {IExttload} from "./interfaces/IExttload.sol";++/// @notice Enables public transient storage access for efficient state retrieval by external contracts.+/// https://eips.ethereum.org/EIPS/eip-2330#rationale+abstract contract Exttload is IExttload {+ /// @inheritdoc IExttload+ function exttload(bytes32 slot) external view returns (bytes32) {+ assembly ("memory-safe") {+ mstore(0, tload(slot))+ return(0, 0x20)+ }+ }++ /// @inheritdoc IExttload+ function exttload(bytes32[] calldata slots) external view returns (bytes32[] memory) {+ assembly ("memory-safe") {+ let memptr := mload(0x40)+ let start := memptr+ // for abi encoding the response - the array will be found at 0x20+ mstore(memptr, 0x20)+ // next we store the length of the return array+ mstore(add(memptr, 0x20), slots.length)+ // update memptr to the first location to hold an array entry+ memptr := add(memptr, 0x40)+ // A left bit-shift of 5 is equivalent to multiplying by 32 but costs less gas.+ let end := add(memptr, shl(5, slots.length))+ let calldataptr := slots.offset+ for {} 1 {} {+ mstore(memptr, tload(calldataload(calldataptr)))+ memptr := add(memptr, 0x20)+ calldataptr := add(calldataptr, 0x20)+ if iszero(lt(memptr, end)) { break }+ }+ return(start, sub(end, start))+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/NoDelegateCall.sol b/contracts/v4-hooks/lib/v4-core/src/NoDelegateCall.solnew file mode 100644index 000000000..5e6d9609a--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/NoDelegateCall.sol@@ -0,0 +1,33 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {CustomRevert} from "./libraries/CustomRevert.sol";++/// @title Prevents delegatecall to a contract+/// @notice Base contract that provides a modifier for preventing delegatecall to methods in a child contract+abstract contract NoDelegateCall {+ using CustomRevert for bytes4;++ error DelegateCallNotAllowed();++ /// @dev The original address of this contract+ address private immutable original;++ constructor() {+ // Immutables are computed in the init code of the contract, and then inlined into the deployed bytecode.+ // In other words, this variable won't change when it's checked at runtime.+ original = address(this);+ }++ /// @dev Private method is used instead of inlining into modifier because modifiers are copied into each method,+ /// and the use of immutable means the address bytes are copied in every place the modifier is used.+ function checkNotDelegateCall() private view {+ if (address(this) != original) DelegateCallNotAllowed.selector.revertWith();+ }++ /// @notice Prevents delegatecall into the modified method+ modifier noDelegateCall() {+ checkNotDelegateCall();+ _;+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/PoolManager.sol b/contracts/v4-hooks/lib/v4-core/src/PoolManager.solnew file mode 100644index 000000000..c24fbc0ea--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/PoolManager.sol@@ -0,0 +1,393 @@+// SPDX-License-Identifier: BUSL-1.1+pragma solidity 0.8.26;++import {Hooks} from "./libraries/Hooks.sol";+import {Pool} from "./libraries/Pool.sol";+import {SafeCast} from "./libraries/SafeCast.sol";+import {Position} from "./libraries/Position.sol";+import {LPFeeLibrary} from "./libraries/LPFeeLibrary.sol";+import {Currency, CurrencyLibrary} from "./types/Currency.sol";+import {PoolKey} from "./types/PoolKey.sol";+import {TickMath} from "./libraries/TickMath.sol";+import {NoDelegateCall} from "./NoDelegateCall.sol";+import {IHooks} from "./interfaces/IHooks.sol";+import {IPoolManager} from "./interfaces/IPoolManager.sol";+import {IUnlockCallback} from "./interfaces/callback/IUnlockCallback.sol";+import {ProtocolFees} from "./ProtocolFees.sol";+import {ERC6909Claims} from "./ERC6909Claims.sol";+import {PoolId} from "./types/PoolId.sol";+import {BalanceDelta, BalanceDeltaLibrary} from "./types/BalanceDelta.sol";+import {BeforeSwapDelta} from "./types/BeforeSwapDelta.sol";+import {Lock} from "./libraries/Lock.sol";+import {CurrencyDelta} from "./libraries/CurrencyDelta.sol";+import {NonzeroDeltaCount} from "./libraries/NonzeroDeltaCount.sol";+import {CurrencyReserves} from "./libraries/CurrencyReserves.sol";+import {Extsload} from "./Extsload.sol";+import {Exttload} from "./Exttload.sol";+import {CustomRevert} from "./libraries/CustomRevert.sol";++// 4+// 44+// 444+// 444 4444+// 4444 4444 4444+// 4444 4444444 4444 4+// 4444 44444444 4444 4+// 44444 4444444 4444444444444444 444444+// 4 44444 44444444 444444444444444444444 4444+// 4 44444 4444444 4444444444444444444444 44444+// 4 444444 4444444 44444444444444444444444 44 4+// 44 44444 444444 444444444444444444444 4 4+// 44 44444 44444 4444444444444444444 4 44+// 44 4444 44 444444444444444 444+// 444 4444 4444444+// 4444444444444 44 4+// 44444444444 444444 444444444 44+// 444444 4444 4444 4444444444 44+// 4444 44 44 4 44444444444+// 44444 444444444 444444444444 4444+// 44444 44444444 4444 44444444 444444+// 44444 4444 444444444 44444444+// 44444 4444 44444444 4444444444+// 44444 4444 444444444 444444444444+// 44444 4444 44444444 444444444444+// 4444444 4444 44444444 4444444+// 4444444 44444 44444444 4444444+// 44444444 44444444444444444444444444444 4444+// 4444444444 44444444444444444444444444444 444+// 444444444444 444444444444444444444444444444 444 444+// 44444444444444 444444444 44444+// 44444 44444444444 444 44444444 444444+// 44444 4444444444 4444444444 444444 44444444 444444444444+// 444444444444444 4444 444444 4444444 44444444 444444444444+// 444444444444444 444 444444 444444 44444444 44444444444+// 4444444444444 4444 444444 4444 4444444444+// 444444444444 4 44444 4444 444444444+// 44444444444 444444 444 44444444+// 44444444 444444 4444 4444444+// 44444 444 44444+// 44444 444 4 4444+// 44444 444 44 444+// 44444 444 4444+// 444444 44444 444+// 444444444 444+// 44444 444+// 444++/// @title PoolManager+/// @notice Holds the state for all pools+contract PoolManager is IPoolManager, ProtocolFees, NoDelegateCall, ERC6909Claims, Extsload, Exttload {+ using SafeCast for *;+ using Pool for *;+ using Hooks for IHooks;+ using CurrencyDelta for Currency;+ using LPFeeLibrary for uint24;+ using CurrencyReserves for Currency;+ using CustomRevert for bytes4;++ int24 private constant MAX_TICK_SPACING = TickMath.MAX_TICK_SPACING;++ int24 private constant MIN_TICK_SPACING = TickMath.MIN_TICK_SPACING;++ mapping(PoolId id => Pool.State) internal _pools;++ /// @notice This will revert if the contract is locked+ modifier onlyWhenUnlocked() {+ if (!Lock.isUnlocked()) ManagerLocked.selector.revertWith();+ _;+ }++ constructor(address initialOwner) ProtocolFees(initialOwner) {}++ /// @inheritdoc IPoolManager+ function unlock(bytes calldata data) external override returns (bytes memory result) {+ if (Lock.isUnlocked()) AlreadyUnlocked.selector.revertWith();++ Lock.unlock();++ // the caller does everything in this callback, including paying what they owe via calls to settle+ result = IUnlockCallback(msg.sender).unlockCallback(data);++ if (NonzeroDeltaCount.read() != 0) CurrencyNotSettled.selector.revertWith();+ Lock.lock();+ }++ /// @inheritdoc IPoolManager+ function initialize(PoolKey memory key, uint160 sqrtPriceX96) external noDelegateCall returns (int24 tick) {+ // see TickBitmap.sol for overflow conditions that can arise from tick spacing being too large+ if (key.tickSpacing > MAX_TICK_SPACING) TickSpacingTooLarge.selector.revertWith(key.tickSpacing);+ if (key.tickSpacing < MIN_TICK_SPACING) TickSpacingTooSmall.selector.revertWith(key.tickSpacing);+ if (key.currency0 >= key.currency1) {+ CurrenciesOutOfOrderOrEqual.selector.revertWith(+ Currency.unwrap(key.currency0), Currency.unwrap(key.currency1)+ );+ }+ if (!key.hooks.isValidHookAddress(key.fee)) Hooks.HookAddressNotValid.selector.revertWith(address(key.hooks));++ uint24 lpFee = key.fee.getInitialLPFee();++ key.hooks.beforeInitialize(key, sqrtPriceX96);++ PoolId id = key.toId();++ tick = _pools[id].initialize(sqrtPriceX96, lpFee);++ // event is emitted before the afterInitialize call to ensure events are always emitted in order+ // emit all details of a pool key. poolkeys are not saved in storage and must always be provided by the caller+ // the key's fee may be a static fee or a sentinel to denote a dynamic fee.+ emit Initialize(id, key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks, sqrtPriceX96, tick);++ key.hooks.afterInitialize(key, sqrtPriceX96, tick);+ }++ /// @inheritdoc IPoolManager+ function modifyLiquidity(+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ bytes calldata hookData+ ) external onlyWhenUnlocked noDelegateCall returns (BalanceDelta callerDelta, BalanceDelta feesAccrued) {+ PoolId id = key.toId();+ {+ Pool.State storage pool = _getPool(id);+ pool.checkPoolInitialized();++ key.hooks.beforeModifyLiquidity(key, params, hookData);++ BalanceDelta principalDelta;+ (principalDelta, feesAccrued) = pool.modifyLiquidity(+ Pool.ModifyLiquidityParams({+ owner: msg.sender,+ tickLower: params.tickLower,+ tickUpper: params.tickUpper,+ liquidityDelta: params.liquidityDelta.toInt128(),+ tickSpacing: key.tickSpacing,+ salt: params.salt+ })+ );++ // fee delta and principal delta are both accrued to the caller+ callerDelta = principalDelta + feesAccrued;+ }++ // event is emitted before the afterModifyLiquidity call to ensure events are always emitted in order+ emit ModifyLiquidity(id, msg.sender, params.tickLower, params.tickUpper, params.liquidityDelta, params.salt);++ BalanceDelta hookDelta;+ (callerDelta, hookDelta) = key.hooks.afterModifyLiquidity(key, params, callerDelta, feesAccrued, hookData);++ // if the hook doesn't have the flag to be able to return deltas, hookDelta will always be 0+ if (hookDelta != BalanceDeltaLibrary.ZERO_DELTA) _accountPoolBalanceDelta(key, hookDelta, address(key.hooks));++ _accountPoolBalanceDelta(key, callerDelta, msg.sender);+ }++ /// @inheritdoc IPoolManager+ function swap(PoolKey memory key, IPoolManager.SwapParams memory params, bytes calldata hookData)+ external+ onlyWhenUnlocked+ noDelegateCall+ returns (BalanceDelta swapDelta)+ {+ if (params.amountSpecified == 0) SwapAmountCannotBeZero.selector.revertWith();+ PoolId id = key.toId();+ Pool.State storage pool = _getPool(id);+ pool.checkPoolInitialized();++ BeforeSwapDelta beforeSwapDelta;+ {+ int256 amountToSwap;+ uint24 lpFeeOverride;+ (amountToSwap, beforeSwapDelta, lpFeeOverride) = key.hooks.beforeSwap(key, params, hookData);++ // execute swap, account protocol fees, and emit swap event+ // _swap is needed to avoid stack too deep error+ swapDelta = _swap(+ pool,+ id,+ Pool.SwapParams({+ tickSpacing: key.tickSpacing,+ zeroForOne: params.zeroForOne,+ amountSpecified: amountToSwap,+ sqrtPriceLimitX96: params.sqrtPriceLimitX96,+ lpFeeOverride: lpFeeOverride+ }),+ params.zeroForOne ? key.currency0 : key.currency1 // input token+ );+ }++ BalanceDelta hookDelta;+ (swapDelta, hookDelta) = key.hooks.afterSwap(key, params, swapDelta, hookData, beforeSwapDelta);++ // if the hook doesn't have the flag to be able to return deltas, hookDelta will always be 0+ if (hookDelta != BalanceDeltaLibrary.ZERO_DELTA) _accountPoolBalanceDelta(key, hookDelta, address(key.hooks));++ _accountPoolBalanceDelta(key, swapDelta, msg.sender);+ }++ /// @notice Internal swap function to execute a swap, take protocol fees on input token, and emit the swap event+ function _swap(Pool.State storage pool, PoolId id, Pool.SwapParams memory params, Currency inputCurrency)+ internal+ returns (BalanceDelta)+ {+ (BalanceDelta delta, uint256 amountToProtocol, uint24 swapFee, Pool.SwapResult memory result) =+ pool.swap(params);++ // the fee is on the input currency+ if (amountToProtocol > 0) _updateProtocolFees(inputCurrency, amountToProtocol);++ // event is emitted before the afterSwap call to ensure events are always emitted in order+ emit Swap(+ id,+ msg.sender,+ delta.amount0(),+ delta.amount1(),+ result.sqrtPriceX96,+ result.liquidity,+ result.tick,+ swapFee+ );++ return delta;+ }++ /// @inheritdoc IPoolManager+ function donate(PoolKey memory key, uint256 amount0, uint256 amount1, bytes calldata hookData)+ external+ onlyWhenUnlocked+ noDelegateCall+ returns (BalanceDelta delta)+ {+ PoolId poolId = key.toId();+ Pool.State storage pool = _getPool(poolId);+ pool.checkPoolInitialized();++ key.hooks.beforeDonate(key, amount0, amount1, hookData);++ delta = pool.donate(amount0, amount1);++ _accountPoolBalanceDelta(key, delta, msg.sender);++ // event is emitted before the afterDonate call to ensure events are always emitted in order+ emit Donate(poolId, msg.sender, amount0, amount1);++ key.hooks.afterDonate(key, amount0, amount1, hookData);+ }++ /// @inheritdoc IPoolManager+ function sync(Currency currency) external {+ // address(0) is used for the native currency+ if (currency.isAddressZero()) {+ // The reserves balance is not used for native settling, so we only need to reset the currency.+ CurrencyReserves.resetCurrency();+ } else {+ uint256 balance = currency.balanceOfSelf();+ CurrencyReserves.syncCurrencyAndReserves(currency, balance);+ }+ }++ /// @inheritdoc IPoolManager+ function take(Currency currency, address to, uint256 amount) external onlyWhenUnlocked {+ unchecked {+ // negation must be safe as amount is not negative+ _accountDelta(currency, -(amount.toInt128()), msg.sender);+ currency.transfer(to, amount);+ }+ }++ /// @inheritdoc IPoolManager+ function settle() external payable onlyWhenUnlocked returns (uint256) {+ return _settle(msg.sender);+ }++ /// @inheritdoc IPoolManager+ function settleFor(address recipient) external payable onlyWhenUnlocked returns (uint256) {+ return _settle(recipient);+ }++ /// @inheritdoc IPoolManager+ function clear(Currency currency, uint256 amount) external onlyWhenUnlocked {+ int256 current = currency.getDelta(msg.sender);+ // Because input is `uint256`, only positive amounts can be cleared.+ int128 amountDelta = amount.toInt128();+ if (amountDelta != current) MustClearExactPositiveDelta.selector.revertWith();+ // negation must be safe as amountDelta is positive+ unchecked {+ _accountDelta(currency, -(amountDelta), msg.sender);+ }+ }++ /// @inheritdoc IPoolManager+ function mint(address to, uint256 id, uint256 amount) external onlyWhenUnlocked {+ unchecked {+ Currency currency = CurrencyLibrary.fromId(id);+ // negation must be safe as amount is not negative+ _accountDelta(currency, -(amount.toInt128()), msg.sender);+ _mint(to, currency.toId(), amount);+ }+ }++ /// @inheritdoc IPoolManager+ function burn(address from, uint256 id, uint256 amount) external onlyWhenUnlocked {+ Currency currency = CurrencyLibrary.fromId(id);+ _accountDelta(currency, amount.toInt128(), msg.sender);+ _burnFrom(from, currency.toId(), amount);+ }++ /// @inheritdoc IPoolManager+ function updateDynamicLPFee(PoolKey memory key, uint24 newDynamicLPFee) external {+ if (!key.fee.isDynamicFee() || msg.sender != address(key.hooks)) {+ UnauthorizedDynamicLPFeeUpdate.selector.revertWith();+ }+ newDynamicLPFee.validate();+ PoolId id = key.toId();+ _pools[id].setLPFee(newDynamicLPFee);+ }++ // if settling native, integrators should still call `sync` first to avoid DoS attack vectors+ function _settle(address recipient) internal returns (uint256 paid) {+ Currency currency = CurrencyReserves.getSyncedCurrency();++ // if not previously synced, or the syncedCurrency slot has been reset, expects native currency to be settled+ if (currency.isAddressZero()) {+ paid = msg.value;+ } else {+ if (msg.value > 0) NonzeroNativeValue.selector.revertWith();+ // Reserves are guaranteed to be set because currency and reserves are always set together+ uint256 reservesBefore = CurrencyReserves.getSyncedReserves();+ uint256 reservesNow = currency.balanceOfSelf();+ paid = reservesNow - reservesBefore;+ CurrencyReserves.resetCurrency();+ }++ _accountDelta(currency, paid.toInt128(), recipient);+ }++ /// @notice Adds a balance delta in a currency for a target address+ function _accountDelta(Currency currency, int128 delta, address target) internal {+ if (delta == 0) return;++ (int256 previous, int256 next) = currency.applyDelta(target, delta);++ if (next == 0) {+ NonzeroDeltaCount.decrement();+ } else if (previous == 0) {+ NonzeroDeltaCount.increment();+ }+ }++ /// @notice Accounts the deltas of 2 currencies to a target address+ function _accountPoolBalanceDelta(PoolKey memory key, BalanceDelta delta, address target) internal {+ _accountDelta(key.currency0, delta.amount0(), target);+ _accountDelta(key.currency1, delta.amount1(), target);+ }++ /// @notice Implementation of the _getPool function defined in ProtocolFees+ function _getPool(PoolId id) internal view override returns (Pool.State storage) {+ return _pools[id];+ }++ /// @notice Implementation of the _isUnlocked function defined in ProtocolFees+ function _isUnlocked() internal view override returns (bool) {+ return Lock.isUnlocked();+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/ProtocolFees.sol b/contracts/v4-hooks/lib/v4-core/src/ProtocolFees.solnew file mode 100644index 000000000..36d29d666--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/ProtocolFees.sol@@ -0,0 +1,71 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {Currency} from "./types/Currency.sol";+import {CurrencyReserves} from "./libraries/CurrencyReserves.sol";+import {IProtocolFees} from "./interfaces/IProtocolFees.sol";+import {PoolKey} from "./types/PoolKey.sol";+import {ProtocolFeeLibrary} from "./libraries/ProtocolFeeLibrary.sol";+import {Owned} from "solmate/src/auth/Owned.sol";+import {PoolId} from "./types/PoolId.sol";+import {Pool} from "./libraries/Pool.sol";+import {CustomRevert} from "./libraries/CustomRevert.sol";++/// @notice Contract handling the setting and accrual of protocol fees+abstract contract ProtocolFees is IProtocolFees, Owned {+ using ProtocolFeeLibrary for uint24;+ using Pool for Pool.State;+ using CustomRevert for bytes4;++ /// @inheritdoc IProtocolFees+ mapping(Currency currency => uint256 amount) public protocolFeesAccrued;++ /// @inheritdoc IProtocolFees+ address public protocolFeeController;++ constructor(address initialOwner) Owned(initialOwner) {}++ /// @inheritdoc IProtocolFees+ function setProtocolFeeController(address controller) external onlyOwner {+ protocolFeeController = controller;+ emit ProtocolFeeControllerUpdated(controller);+ }++ /// @inheritdoc IProtocolFees+ function setProtocolFee(PoolKey memory key, uint24 newProtocolFee) external {+ if (msg.sender != protocolFeeController) InvalidCaller.selector.revertWith();+ if (!newProtocolFee.isValidProtocolFee()) ProtocolFeeTooLarge.selector.revertWith(newProtocolFee);+ PoolId id = key.toId();+ _getPool(id).setProtocolFee(newProtocolFee);+ emit ProtocolFeeUpdated(id, newProtocolFee);+ }++ /// @inheritdoc IProtocolFees+ function collectProtocolFees(address recipient, Currency currency, uint256 amount)+ external+ returns (uint256 amountCollected)+ {+ if (msg.sender != protocolFeeController) InvalidCaller.selector.revertWith();+ if (!currency.isAddressZero() && CurrencyReserves.getSyncedCurrency() == currency) {+ // prevent transfer between the sync and settle balanceOfs (native settle uses msg.value)+ ProtocolFeeCurrencySynced.selector.revertWith();+ }++ amountCollected = (amount == 0) ? protocolFeesAccrued[currency] : amount;+ protocolFeesAccrued[currency] -= amountCollected;+ currency.transfer(recipient, amountCollected);+ }++ /// @dev abstract internal function to allow the ProtocolFees contract to access the lock+ function _isUnlocked() internal virtual returns (bool);++ /// @dev abstract internal function to allow the ProtocolFees contract to access pool state+ /// @dev this is overridden in PoolManager.sol to give access to the _pools mapping+ function _getPool(PoolId id) internal virtual returns (Pool.State storage);++ function _updateProtocolFees(Currency currency, uint256 amount) internal {+ unchecked {+ protocolFeesAccrued[currency] += amount;+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/interfaces/IExtsload.sol b/contracts/v4-hooks/lib/v4-core/src/interfaces/IExtsload.solnew file mode 100644index 000000000..600402d79--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/interfaces/IExtsload.sol@@ -0,0 +1,21 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @notice Interface for functions to access any storage slot in a contract+interface IExtsload {+ /// @notice Called by external contracts to access granular pool state+ /// @param slot Key of slot to sload+ /// @return value The value of the slot as bytes32+ function extsload(bytes32 slot) external view returns (bytes32 value);++ /// @notice Called by external contracts to access granular pool state+ /// @param startSlot Key of slot to start sloading from+ /// @param nSlots Number of slots to load into return value+ /// @return values List of loaded values.+ function extsload(bytes32 startSlot, uint256 nSlots) external view returns (bytes32[] memory values);++ /// @notice Called by external contracts to access sparse pool state+ /// @param slots List of slots to SLOAD from.+ /// @return values List of loaded values.+ function extsload(bytes32[] calldata slots) external view returns (bytes32[] memory values);+}diff --git a/contracts/v4-hooks/lib/v4-core/src/interfaces/IExttload.sol b/contracts/v4-hooks/lib/v4-core/src/interfaces/IExttload.solnew file mode 100644index 000000000..1e0482e84--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/interfaces/IExttload.sol@@ -0,0 +1,15 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.24;++/// @notice Interface for functions to access any transient storage slot in a contract+interface IExttload {+ /// @notice Called by external contracts to access transient storage of the contract+ /// @param slot Key of slot to tload+ /// @return value The value of the slot as bytes32+ function exttload(bytes32 slot) external view returns (bytes32 value);++ /// @notice Called by external contracts to access sparse transient pool state+ /// @param slots List of slots to tload+ /// @return values List of loaded values+ function exttload(bytes32[] calldata slots) external view returns (bytes32[] memory values);+}diff --git a/contracts/v4-hooks/lib/v4-core/src/interfaces/IHooks.sol b/contracts/v4-hooks/lib/v4-core/src/interfaces/IHooks.solnew file mode 100644index 000000000..4acfe941a--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/interfaces/IHooks.sol@@ -0,0 +1,155 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {IPoolManager} from "./IPoolManager.sol";+import {BeforeSwapDelta} from "../types/BeforeSwapDelta.sol";++/// @notice V4 decides whether to invoke specific hooks by inspecting the least significant bits+/// of the address that the hooks contract is deployed to.+/// For example, a hooks contract deployed to address: 0x0000000000000000000000000000000000002400+/// has the lowest bits '10 0100 0000 0000' which would cause the 'before initialize' and 'after add liquidity' hooks to be used.+/// See the Hooks library for the full spec.+/// @dev Should only be callable by the v4 PoolManager.+interface IHooks {+ /// @notice The hook called before the state of a pool is initialized+ /// @param sender The initial msg.sender for the initialize call+ /// @param key The key for the pool being initialized+ /// @param sqrtPriceX96 The sqrt(price) of the pool as a Q64.96+ /// @return bytes4 The function selector for the hook+ function beforeInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96) external returns (bytes4);++ /// @notice The hook called after the state of a pool is initialized+ /// @param sender The initial msg.sender for the initialize call+ /// @param key The key for the pool being initialized+ /// @param sqrtPriceX96 The sqrt(price) of the pool as a Q64.96+ /// @param tick The current tick after the state of a pool is initialized+ /// @return bytes4 The function selector for the hook+ function afterInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96, int24 tick)+ external+ returns (bytes4);++ /// @notice The hook called before liquidity is added+ /// @param sender The initial msg.sender for the add liquidity call+ /// @param key The key for the pool+ /// @param params The parameters for adding liquidity+ /// @param hookData Arbitrary data handed into the PoolManager by the liquidity provider to be passed on to the hook+ /// @return bytes4 The function selector for the hook+ function beforeAddLiquidity(+ address sender,+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata params,+ bytes calldata hookData+ ) external returns (bytes4);++ /// @notice The hook called after liquidity is added+ /// @param sender The initial msg.sender for the add liquidity call+ /// @param key The key for the pool+ /// @param params The parameters for adding liquidity+ /// @param delta The caller's balance delta after adding liquidity; the sum of principal delta, fees accrued, and hook delta+ /// @param feesAccrued The fees accrued since the last time fees were collected from this position+ /// @param hookData Arbitrary data handed into the PoolManager by the liquidity provider to be passed on to the hook+ /// @return bytes4 The function selector for the hook+ /// @return BalanceDelta The hook's delta in token0 and token1. Positive: the hook is owed/took currency, negative: the hook owes/sent currency+ function afterAddLiquidity(+ address sender,+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata params,+ BalanceDelta delta,+ BalanceDelta feesAccrued,+ bytes calldata hookData+ ) external returns (bytes4, BalanceDelta);++ /// @notice The hook called before liquidity is removed+ /// @param sender The initial msg.sender for the remove liquidity call+ /// @param key The key for the pool+ /// @param params The parameters for removing liquidity+ /// @param hookData Arbitrary data handed into the PoolManager by the liquidity provider to be be passed on to the hook+ /// @return bytes4 The function selector for the hook+ function beforeRemoveLiquidity(+ address sender,+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata params,+ bytes calldata hookData+ ) external returns (bytes4);++ /// @notice The hook called after liquidity is removed+ /// @param sender The initial msg.sender for the remove liquidity call+ /// @param key The key for the pool+ /// @param params The parameters for removing liquidity+ /// @param delta The caller's balance delta after removing liquidity; the sum of principal delta, fees accrued, and hook delta+ /// @param feesAccrued The fees accrued since the last time fees were collected from this position+ /// @param hookData Arbitrary data handed into the PoolManager by the liquidity provider to be be passed on to the hook+ /// @return bytes4 The function selector for the hook+ /// @return BalanceDelta The hook's delta in token0 and token1. Positive: the hook is owed/took currency, negative: the hook owes/sent currency+ function afterRemoveLiquidity(+ address sender,+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata params,+ BalanceDelta delta,+ BalanceDelta feesAccrued,+ bytes calldata hookData+ ) external returns (bytes4, BalanceDelta);++ /// @notice The hook called before a swap+ /// @param sender The initial msg.sender for the swap call+ /// @param key The key for the pool+ /// @param params The parameters for the swap+ /// @param hookData Arbitrary data handed into the PoolManager by the swapper to be be passed on to the hook+ /// @return bytes4 The function selector for the hook+ /// @return BeforeSwapDelta The hook's delta in specified and unspecified currencies. Positive: the hook is owed/took currency, negative: the hook owes/sent currency+ /// @return uint24 Optionally override the lp fee, only used if three conditions are met: 1. the Pool has a dynamic fee, 2. the value's 2nd highest bit is set (23rd bit, 0x400000), and 3. the value is less than or equal to the maximum fee (1 million)+ function beforeSwap(+ address sender,+ PoolKey calldata key,+ IPoolManager.SwapParams calldata params,+ bytes calldata hookData+ ) external returns (bytes4, BeforeSwapDelta, uint24);++ /// @notice The hook called after a swap+ /// @param sender The initial msg.sender for the swap call+ /// @param key The key for the pool+ /// @param params The parameters for the swap+ /// @param delta The amount owed to the caller (positive) or owed to the pool (negative)+ /// @param hookData Arbitrary data handed into the PoolManager by the swapper to be be passed on to the hook+ /// @return bytes4 The function selector for the hook+ /// @return int128 The hook's delta in unspecified currency. Positive: the hook is owed/took currency, negative: the hook owes/sent currency+ function afterSwap(+ address sender,+ PoolKey calldata key,+ IPoolManager.SwapParams calldata params,+ BalanceDelta delta,+ bytes calldata hookData+ ) external returns (bytes4, int128);++ /// @notice The hook called before donate+ /// @param sender The initial msg.sender for the donate call+ /// @param key The key for the pool+ /// @param amount0 The amount of token0 being donated+ /// @param amount1 The amount of token1 being donated+ /// @param hookData Arbitrary data handed into the PoolManager by the donor to be be passed on to the hook+ /// @return bytes4 The function selector for the hook+ function beforeDonate(+ address sender,+ PoolKey calldata key,+ uint256 amount0,+ uint256 amount1,+ bytes calldata hookData+ ) external returns (bytes4);++ /// @notice The hook called after donate+ /// @param sender The initial msg.sender for the donate call+ /// @param key The key for the pool+ /// @param amount0 The amount of token0 being donated+ /// @param amount1 The amount of token1 being donated+ /// @param hookData Arbitrary data handed into the PoolManager by the donor to be be passed on to the hook+ /// @return bytes4 The function selector for the hook+ function afterDonate(+ address sender,+ PoolKey calldata key,+ uint256 amount0,+ uint256 amount1,+ bytes calldata hookData+ ) external returns (bytes4);+}diff --git a/contracts/v4-hooks/lib/v4-core/src/interfaces/IPoolManager.sol b/contracts/v4-hooks/lib/v4-core/src/interfaces/IPoolManager.solnew file mode 100644index 000000000..85703ef79--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/interfaces/IPoolManager.sol@@ -0,0 +1,235 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.24;++import {Currency} from "../types/Currency.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {IHooks} from "./IHooks.sol";+import {IERC6909Claims} from "./external/IERC6909Claims.sol";+import {IProtocolFees} from "./IProtocolFees.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {PoolId} from "../types/PoolId.sol";+import {IExtsload} from "./IExtsload.sol";+import {IExttload} from "./IExttload.sol";++/// @notice Interface for the PoolManager+interface IPoolManager is IProtocolFees, IERC6909Claims, IExtsload, IExttload {+ /// @notice Thrown when a currency is not netted out after the contract is unlocked+ error CurrencyNotSettled();++ /// @notice Thrown when trying to interact with a non-initialized pool+ error PoolNotInitialized();++ /// @notice Thrown when unlock is called, but the contract is already unlocked+ error AlreadyUnlocked();++ /// @notice Thrown when a function is called that requires the contract to be unlocked, but it is not+ error ManagerLocked();++ /// @notice Pools are limited to type(int16).max tickSpacing in #initialize, to prevent overflow+ error TickSpacingTooLarge(int24 tickSpacing);++ /// @notice Pools must have a positive non-zero tickSpacing passed to #initialize+ error TickSpacingTooSmall(int24 tickSpacing);++ /// @notice PoolKey must have currencies where address(currency0) < address(currency1)+ error CurrenciesOutOfOrderOrEqual(address currency0, address currency1);++ /// @notice Thrown when a call to updateDynamicLPFee is made by an address that is not the hook,+ /// or on a pool that does not have a dynamic swap fee.+ error UnauthorizedDynamicLPFeeUpdate();++ /// @notice Thrown when trying to swap amount of 0+ error SwapAmountCannotBeZero();++ ///@notice Thrown when native currency is passed to a non native settlement+ error NonzeroNativeValue();++ /// @notice Thrown when `clear` is called with an amount that is not exactly equal to the open currency delta.+ error MustClearExactPositiveDelta();++ /// @notice Emitted when a new pool is initialized+ /// @param id The abi encoded hash of the pool key struct for the new pool+ /// @param currency0 The first currency of the pool by address sort order+ /// @param currency1 The second currency of the pool by address sort order+ /// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip+ /// @param tickSpacing The minimum number of ticks between initialized ticks+ /// @param hooks The hooks contract address for the pool, or address(0) if none+ /// @param sqrtPriceX96 The price of the pool on initialization+ /// @param tick The initial tick of the pool corresponding to the initialized price+ event Initialize(+ PoolId indexed id,+ Currency indexed currency0,+ Currency indexed currency1,+ uint24 fee,+ int24 tickSpacing,+ IHooks hooks,+ uint160 sqrtPriceX96,+ int24 tick+ );++ /// @notice Emitted when a liquidity position is modified+ /// @param id The abi encoded hash of the pool key struct for the pool that was modified+ /// @param sender The address that modified the pool+ /// @param tickLower The lower tick of the position+ /// @param tickUpper The upper tick of the position+ /// @param liquidityDelta The amount of liquidity that was added or removed+ /// @param salt The extra data to make positions unique+ event ModifyLiquidity(+ PoolId indexed id, address indexed sender, int24 tickLower, int24 tickUpper, int256 liquidityDelta, bytes32 salt+ );++ /// @notice Emitted for swaps between currency0 and currency1+ /// @param id The abi encoded hash of the pool key struct for the pool that was modified+ /// @param sender The address that initiated the swap call, and that received the callback+ /// @param amount0 The delta of the currency0 balance of the pool+ /// @param amount1 The delta of the currency1 balance of the pool+ /// @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96+ /// @param liquidity The liquidity of the pool after the swap+ /// @param tick The log base 1.0001 of the price of the pool after the swap+ /// @param fee The swap fee in hundredths of a bip+ event Swap(+ PoolId indexed id,+ address indexed sender,+ int128 amount0,+ int128 amount1,+ uint160 sqrtPriceX96,+ uint128 liquidity,+ int24 tick,+ uint24 fee+ );++ /// @notice Emitted for donations+ /// @param id The abi encoded hash of the pool key struct for the pool that was donated to+ /// @param sender The address that initiated the donate call+ /// @param amount0 The amount donated in currency0+ /// @param amount1 The amount donated in currency1+ event Donate(PoolId indexed id, address indexed sender, uint256 amount0, uint256 amount1);++ /// @notice All interactions on the contract that account deltas require unlocking. A caller that calls `unlock` must implement+ /// `IUnlockCallback(msg.sender).unlockCallback(data)`, where they interact with the remaining functions on this contract.+ /// @dev The only functions callable without an unlocking are `initialize` and `updateDynamicLPFee`+ /// @param data Any data to pass to the callback, via `IUnlockCallback(msg.sender).unlockCallback(data)`+ /// @return The data returned by the call to `IUnlockCallback(msg.sender).unlockCallback(data)`+ function unlock(bytes calldata data) external returns (bytes memory);++ /// @notice Initialize the state for a given pool ID+ /// @dev A swap fee totaling MAX_SWAP_FEE (100%) makes exact output swaps impossible since the input is entirely consumed by the fee+ /// @param key The pool key for the pool to initialize+ /// @param sqrtPriceX96 The initial square root price+ /// @return tick The initial tick of the pool+ function initialize(PoolKey memory key, uint160 sqrtPriceX96) external returns (int24 tick);++ struct ModifyLiquidityParams {+ // the lower and upper tick of the position+ int24 tickLower;+ int24 tickUpper;+ // how to modify the liquidity+ int256 liquidityDelta;+ // a value to set if you want unique liquidity positions at the same range+ bytes32 salt;+ }++ /// @notice Modify the liquidity for the given pool+ /// @dev Poke by calling with a zero liquidityDelta+ /// @param key The pool to modify liquidity in+ /// @param params The parameters for modifying the liquidity+ /// @param hookData The data to pass through to the add/removeLiquidity hooks+ /// @return callerDelta The balance delta of the caller of modifyLiquidity. This is the total of both principal, fee deltas, and hook deltas if applicable+ /// @return feesAccrued The balance delta of the fees generated in the liquidity range. Returned for informational purposes+ /// @dev Note that feesAccrued can be artificially inflated by a malicious actor and integrators should be careful using the value+ /// For pools with a single liquidity position, actors can donate to themselves to inflate feeGrowthGlobal (and consequently feesAccrued)+ /// atomically donating and collecting fees in the same unlockCallback may make the inflated value more extreme+ function modifyLiquidity(PoolKey memory key, ModifyLiquidityParams memory params, bytes calldata hookData)+ external+ returns (BalanceDelta callerDelta, BalanceDelta feesAccrued);++ struct SwapParams {+ /// Whether to swap token0 for token1 or vice versa+ bool zeroForOne;+ /// The desired input amount if negative (exactIn), or the desired output amount if positive (exactOut)+ int256 amountSpecified;+ /// The sqrt price at which, if reached, the swap will stop executing+ uint160 sqrtPriceLimitX96;+ }++ /// @notice Swap against the given pool+ /// @param key The pool to swap in+ /// @param params The parameters for swapping+ /// @param hookData The data to pass through to the swap hooks+ /// @return swapDelta The balance delta of the address swapping+ /// @dev Swapping on low liquidity pools may cause unexpected swap amounts when liquidity available is less than amountSpecified.+ /// Additionally note that if interacting with hooks that have the BEFORE_SWAP_RETURNS_DELTA_FLAG or AFTER_SWAP_RETURNS_DELTA_FLAG+ /// the hook may alter the swap input/output. Integrators should perform checks on the returned swapDelta.+ function swap(PoolKey memory key, SwapParams memory params, bytes calldata hookData)+ external+ returns (BalanceDelta swapDelta);++ /// @notice Donate the given currency amounts to the in-range liquidity providers of a pool+ /// @dev Calls to donate can be frontrun adding just-in-time liquidity, with the aim of receiving a portion donated funds.+ /// Donors should keep this in mind when designing donation mechanisms.+ /// @dev This function donates to in-range LPs at slot0.tick. In certain edge-cases of the swap algorithm, the `sqrtPrice` of+ /// a pool can be at the lower boundary of tick `n`, but the `slot0.tick` of the pool is already `n - 1`. In this case a call to+ /// `donate` would donate to tick `n - 1` (slot0.tick) not tick `n` (getTickAtSqrtPrice(slot0.sqrtPriceX96)).+ /// Read the comments in `Pool.swap()` for more information about this.+ /// @param key The key of the pool to donate to+ /// @param amount0 The amount of currency0 to donate+ /// @param amount1 The amount of currency1 to donate+ /// @param hookData The data to pass through to the donate hooks+ /// @return BalanceDelta The delta of the caller after the donate+ function donate(PoolKey memory key, uint256 amount0, uint256 amount1, bytes calldata hookData)+ external+ returns (BalanceDelta);++ /// @notice Writes the current ERC20 balance of the specified currency to transient storage+ /// This is used to checkpoint balances for the manager and derive deltas for the caller.+ /// @dev This MUST be called before any ERC20 tokens are sent into the contract, but can be skipped+ /// for native tokens because the amount to settle is determined by the sent value.+ /// However, if an ERC20 token has been synced and not settled, and the caller instead wants to settle+ /// native funds, this function can be called with the native currency to then be able to settle the native currency+ function sync(Currency currency) external;++ /// @notice Called by the user to net out some value owed to the user+ /// @dev Will revert if the requested amount is not available, consider using `mint` instead+ /// @dev Can also be used as a mechanism for free flash loans+ /// @param currency The currency to withdraw from the pool manager+ /// @param to The address to withdraw to+ /// @param amount The amount of currency to withdraw+ function take(Currency currency, address to, uint256 amount) external;++ /// @notice Called by the user to pay what is owed+ /// @return paid The amount of currency settled+ function settle() external payable returns (uint256 paid);++ /// @notice Called by the user to pay on behalf of another address+ /// @param recipient The address to credit for the payment+ /// @return paid The amount of currency settled+ function settleFor(address recipient) external payable returns (uint256 paid);++ /// @notice WARNING - Any currency that is cleared, will be non-retrievable, and locked in the contract permanently.+ /// A call to clear will zero out a positive balance WITHOUT a corresponding transfer.+ /// @dev This could be used to clear a balance that is considered dust.+ /// Additionally, the amount must be the exact positive balance. This is to enforce that the caller is aware of the amount being cleared.+ function clear(Currency currency, uint256 amount) external;++ /// @notice Called by the user to move value into ERC6909 balance+ /// @param to The address to mint the tokens to+ /// @param id The currency address to mint to ERC6909s, as a uint256+ /// @param amount The amount of currency to mint+ /// @dev The id is converted to a uint160 to correspond to a currency address+ /// If the upper 12 bytes are not 0, they will be 0-ed out+ function mint(address to, uint256 id, uint256 amount) external;++ /// @notice Called by the user to move value from ERC6909 balance+ /// @param from The address to burn the tokens from+ /// @param id The currency address to burn from ERC6909s, as a uint256+ /// @param amount The amount of currency to burn+ /// @dev The id is converted to a uint160 to correspond to a currency address+ /// If the upper 12 bytes are not 0, they will be 0-ed out+ function burn(address from, uint256 id, uint256 amount) external;++ /// @notice Updates the pools lp fees for the a pool that has enabled dynamic lp fees.+ /// @dev A swap fee totaling MAX_SWAP_FEE (100%) makes exact output swaps impossible since the input is entirely consumed by the fee+ /// @param key The key of the pool to update dynamic LP fees for+ /// @param newDynamicLPFee The new dynamic pool LP fee+ function updateDynamicLPFee(PoolKey memory key, uint24 newDynamicLPFee) external;+}diff --git a/contracts/v4-hooks/lib/v4-core/src/interfaces/IProtocolFees.sol b/contracts/v4-hooks/lib/v4-core/src/interfaces/IProtocolFees.solnew file mode 100644index 000000000..2c2af5944--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/interfaces/IProtocolFees.sol@@ -0,0 +1,52 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {Currency} from "../types/Currency.sol";+import {PoolId} from "../types/PoolId.sol";+import {PoolKey} from "../types/PoolKey.sol";++/// @notice Interface for all protocol-fee related functions in the pool manager+interface IProtocolFees {+ /// @notice Thrown when protocol fee is set too high+ error ProtocolFeeTooLarge(uint24 fee);++ /// @notice Thrown when collectProtocolFees or setProtocolFee is not called by the controller.+ error InvalidCaller();++ /// @notice Thrown when collectProtocolFees is attempted on a token that is synced.+ error ProtocolFeeCurrencySynced();++ /// @notice Emitted when the protocol fee controller address is updated in setProtocolFeeController.+ event ProtocolFeeControllerUpdated(address indexed protocolFeeController);++ /// @notice Emitted when the protocol fee is updated for a pool.+ event ProtocolFeeUpdated(PoolId indexed id, uint24 protocolFee);++ /// @notice Given a currency address, returns the protocol fees accrued in that currency+ /// @param currency The currency to check+ /// @return amount The amount of protocol fees accrued in the currency+ function protocolFeesAccrued(Currency currency) external view returns (uint256 amount);++ /// @notice Sets the protocol fee for the given pool+ /// @param key The key of the pool to set a protocol fee for+ /// @param newProtocolFee The fee to set+ function setProtocolFee(PoolKey memory key, uint24 newProtocolFee) external;++ /// @notice Sets the protocol fee controller+ /// @param controller The new protocol fee controller+ function setProtocolFeeController(address controller) external;++ /// @notice Collects the protocol fees for a given recipient and currency, returning the amount collected+ /// @dev This will revert if the contract is unlocked+ /// @param recipient The address to receive the protocol fees+ /// @param currency The currency to withdraw+ /// @param amount The amount of currency to withdraw+ /// @return amountCollected The amount of currency successfully withdrawn+ function collectProtocolFees(address recipient, Currency currency, uint256 amount)+ external+ returns (uint256 amountCollected);++ /// @notice Returns the current protocol fee controller address+ /// @return address The current protocol fee controller address+ function protocolFeeController() external view returns (address);+}diff --git a/contracts/v4-hooks/lib/v4-core/src/interfaces/callback/IUnlockCallback.sol b/contracts/v4-hooks/lib/v4-core/src/interfaces/callback/IUnlockCallback.solnew file mode 100644index 000000000..7957de5cf--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/interfaces/callback/IUnlockCallback.sol@@ -0,0 +1,10 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @notice Interface for the callback executed when an address unlocks the pool manager+interface IUnlockCallback {+ /// @notice Called by the pool manager on `msg.sender` when the manager is unlocked+ /// @param data The data that was passed to the call to unlock+ /// @return Any data that you want to be returned from the unlock call+ function unlockCallback(bytes calldata data) external returns (bytes memory);+}diff --git a/contracts/v4-hooks/lib/v4-core/src/interfaces/external/IERC20Minimal.sol b/contracts/v4-hooks/lib/v4-core/src/interfaces/external/IERC20Minimal.solnew file mode 100644index 000000000..11e1db4e9--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/interfaces/external/IERC20Minimal.sol@@ -0,0 +1,48 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @title Minimal ERC20 interface for Uniswap+/// @notice Contains a subset of the full ERC20 interface that is used in Uniswap V3+interface IERC20Minimal {+ /// @notice Returns an account's balance in the token+ /// @param account The account for which to look up the number of tokens it has, i.e. its balance+ /// @return The number of tokens held by the account+ function balanceOf(address account) external view returns (uint256);++ /// @notice Transfers the amount of token from the `msg.sender` to the recipient+ /// @param recipient The account that will receive the amount transferred+ /// @param amount The number of tokens to send from the sender to the recipient+ /// @return Returns true for a successful transfer, false for an unsuccessful transfer+ function transfer(address recipient, uint256 amount) external returns (bool);++ /// @notice Returns the current allowance given to a spender by an owner+ /// @param owner The account of the token owner+ /// @param spender The account of the token spender+ /// @return The current allowance granted by `owner` to `spender`+ function allowance(address owner, address spender) external view returns (uint256);++ /// @notice Sets the allowance of a spender from the `msg.sender` to the value `amount`+ /// @param spender The account which will be allowed to spend a given amount of the owners tokens+ /// @param amount The amount of tokens allowed to be used by `spender`+ /// @return Returns true for a successful approval, false for unsuccessful+ function approve(address spender, uint256 amount) external returns (bool);++ /// @notice Transfers `amount` tokens from `sender` to `recipient` up to the allowance given to the `msg.sender`+ /// @param sender The account from which the transfer will be initiated+ /// @param recipient The recipient of the transfer+ /// @param amount The amount of the transfer+ /// @return Returns true for a successful transfer, false for unsuccessful+ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);++ /// @notice Event emitted when tokens are transferred from one address to another, either via `#transfer` or `#transferFrom`.+ /// @param from The account from which the tokens were sent, i.e. the balance decreased+ /// @param to The account to which the tokens were sent, i.e. the balance increased+ /// @param value The amount of tokens that were transferred+ event Transfer(address indexed from, address indexed to, uint256 value);++ /// @notice Event emitted when the approval amount for the spender of a given owner's tokens changes.+ /// @param owner The account that approved spending of its tokens+ /// @param spender The account for which the spending allowance was modified+ /// @param value The new allowance from the owner to the spender+ event Approval(address indexed owner, address indexed spender, uint256 value);+}diff --git a/contracts/v4-hooks/lib/v4-core/src/interfaces/external/IERC6909Claims.sol b/contracts/v4-hooks/lib/v4-core/src/interfaces/external/IERC6909Claims.solnew file mode 100644index 000000000..f32ac97fe--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/interfaces/external/IERC6909Claims.sol@@ -0,0 +1,66 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @notice Interface for claims over a contract balance, wrapped as a ERC6909+interface IERC6909Claims {+ /*//////////////////////////////////////////////////////////////+ EVENTS+ //////////////////////////////////////////////////////////////*/++ event OperatorSet(address indexed owner, address indexed operator, bool approved);++ event Approval(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount);++ event Transfer(address caller, address indexed from, address indexed to, uint256 indexed id, uint256 amount);++ /*//////////////////////////////////////////////////////////////+ FUNCTIONS+ //////////////////////////////////////////////////////////////*/++ /// @notice Owner balance of an id.+ /// @param owner The address of the owner.+ /// @param id The id of the token.+ /// @return amount The balance of the token.+ function balanceOf(address owner, uint256 id) external view returns (uint256 amount);++ /// @notice Spender allowance of an id.+ /// @param owner The address of the owner.+ /// @param spender The address of the spender.+ /// @param id The id of the token.+ /// @return amount The allowance of the token.+ function allowance(address owner, address spender, uint256 id) external view returns (uint256 amount);++ /// @notice Checks if a spender is approved by an owner as an operator+ /// @param owner The address of the owner.+ /// @param spender The address of the spender.+ /// @return approved The approval status.+ function isOperator(address owner, address spender) external view returns (bool approved);++ /// @notice Transfers an amount of an id from the caller to a receiver.+ /// @param receiver The address of the receiver.+ /// @param id The id of the token.+ /// @param amount The amount of the token.+ /// @return bool True, always, unless the function reverts+ function transfer(address receiver, uint256 id, uint256 amount) external returns (bool);++ /// @notice Transfers an amount of an id from a sender to a receiver.+ /// @param sender The address of the sender.+ /// @param receiver The address of the receiver.+ /// @param id The id of the token.+ /// @param amount The amount of the token.+ /// @return bool True, always, unless the function reverts+ function transferFrom(address sender, address receiver, uint256 id, uint256 amount) external returns (bool);++ /// @notice Approves an amount of an id to a spender.+ /// @param spender The address of the spender.+ /// @param id The id of the token.+ /// @param amount The amount of the token.+ /// @return bool True, always+ function approve(address spender, uint256 id, uint256 amount) external returns (bool);++ /// @notice Sets or removes an operator for the caller.+ /// @param operator The address of the operator.+ /// @param approved The approval status.+ /// @return bool True, always+ function setOperator(address operator, bool approved) external returns (bool);+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/BitMath.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/BitMath.solnew file mode 100644index 000000000..6c20495bb--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/BitMath.sol@@ -0,0 +1,49 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @title BitMath+/// @dev This library provides functionality for computing bit properties of an unsigned integer+/// @author Solady (https://github.com/Vectorized/solady/blob/8200a70e8dc2a77ecb074fc2e99a2a0d36547522/src/utils/LibBit.sol)+library BitMath {+ /// @notice Returns the index of the most significant bit of the number,+ /// where the least significant bit is at index 0 and the most significant bit is at index 255+ /// @param x the value for which to compute the most significant bit, must be greater than 0+ /// @return r the index of the most significant bit+ function mostSignificantBit(uint256 x) internal pure returns (uint8 r) {+ require(x > 0);++ assembly ("memory-safe") {+ r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))+ r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))+ r := or(r, shl(5, lt(0xffffffff, shr(r, x))))+ r := or(r, shl(4, lt(0xffff, shr(r, x))))+ r := or(r, shl(3, lt(0xff, shr(r, x))))+ // forgefmt: disable-next-item+ r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),+ 0x0706060506020500060203020504000106050205030304010505030400000000))+ }+ }++ /// @notice Returns the index of the least significant bit of the number,+ /// where the least significant bit is at index 0 and the most significant bit is at index 255+ /// @param x the value for which to compute the least significant bit, must be greater than 0+ /// @return r the index of the least significant bit+ function leastSignificantBit(uint256 x) internal pure returns (uint8 r) {+ require(x > 0);++ assembly ("memory-safe") {+ // Isolate the least significant bit.+ x := and(x, sub(0, x))+ // For the upper 3 bits of the result, use a De Bruijn-like lookup.+ // Credit to adhusson: https://blog.adhusson.com/cheap-find-first-set-evm/+ // forgefmt: disable-next-item+ r := shl(5, shr(252, shl(shl(2, shr(250, mul(x,+ 0xb6db6db6ddddddddd34d34d349249249210842108c6318c639ce739cffffffff))),+ 0x8040405543005266443200005020610674053026020000107506200176117077)))+ // For the lower 5 bits of the result, use a De Bruijn lookup.+ // forgefmt: disable-next-item+ r := or(r, byte(and(div(0xd76453e0, shr(r, x)), 0x1f),+ 0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405))+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/CurrencyDelta.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/CurrencyDelta.solnew file mode 100644index 000000000..a1049067a--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/CurrencyDelta.sol@@ -0,0 +1,42 @@+// SPDX-License-Identifier: BUSL-1.1+pragma solidity ^0.8.24;++import {Currency} from "../types/Currency.sol";++/// @title a library to store callers' currency deltas in transient storage+/// @dev this library implements the equivalent of a mapping, as transient storage can only be accessed in assembly+library CurrencyDelta {+ /// @notice calculates which storage slot a delta should be stored in for a given account and currency+ function _computeSlot(address target, Currency currency) internal pure returns (bytes32 hashSlot) {+ assembly ("memory-safe") {+ mstore(0, and(target, 0xffffffffffffffffffffffffffffffffffffffff))+ mstore(32, and(currency, 0xffffffffffffffffffffffffffffffffffffffff))+ hashSlot := keccak256(0, 64)+ }+ }++ function getDelta(Currency currency, address target) internal view returns (int256 delta) {+ bytes32 hashSlot = _computeSlot(target, currency);+ assembly ("memory-safe") {+ delta := tload(hashSlot)+ }+ }++ /// @notice applies a new currency delta for a given account and currency+ /// @return previous The prior value+ /// @return next The modified result+ function applyDelta(Currency currency, address target, int128 delta)+ internal+ returns (int256 previous, int256 next)+ {+ bytes32 hashSlot = _computeSlot(target, currency);++ assembly ("memory-safe") {+ previous := tload(hashSlot)+ }+ next = previous + delta;+ assembly ("memory-safe") {+ tstore(hashSlot, next)+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/CurrencyReserves.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/CurrencyReserves.solnew file mode 100644index 000000000..3a3309c33--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/CurrencyReserves.sol@@ -0,0 +1,39 @@+// SPDX-License-Identifier: BUSL-1.1+pragma solidity ^0.8.24;++import {Currency} from "../types/Currency.sol";+import {CustomRevert} from "./CustomRevert.sol";++library CurrencyReserves {+ using CustomRevert for bytes4;++ /// bytes32(uint256(keccak256("ReservesOf")) - 1)+ bytes32 constant RESERVES_OF_SLOT = 0x1e0745a7db1623981f0b2a5d4232364c00787266eb75ad546f190e6cebe9bd95;+ /// bytes32(uint256(keccak256("Currency")) - 1)+ bytes32 constant CURRENCY_SLOT = 0x27e098c505d44ec3574004bca052aabf76bd35004c182099d8c575fb238593b9;++ function getSyncedCurrency() internal view returns (Currency currency) {+ assembly ("memory-safe") {+ currency := tload(CURRENCY_SLOT)+ }+ }++ function resetCurrency() internal {+ assembly ("memory-safe") {+ tstore(CURRENCY_SLOT, 0)+ }+ }++ function syncCurrencyAndReserves(Currency currency, uint256 value) internal {+ assembly ("memory-safe") {+ tstore(CURRENCY_SLOT, and(currency, 0xffffffffffffffffffffffffffffffffffffffff))+ tstore(RESERVES_OF_SLOT, value)+ }+ }++ function getSyncedReserves() internal view returns (uint256 value) {+ assembly ("memory-safe") {+ value := tload(RESERVES_OF_SLOT)+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/CustomRevert.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/CustomRevert.solnew file mode 100644index 000000000..5d7073308--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/CustomRevert.sol@@ -0,0 +1,120 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @title Library for reverting with custom errors efficiently+/// @notice Contains functions for reverting with custom errors with different argument types efficiently+/// @dev To use this library, declare `using CustomRevert for bytes4;` and replace `revert CustomError()` with+/// `CustomError.selector.revertWith()`+/// @dev The functions may tamper with the free memory pointer but it is fine since the call context is exited immediately+library CustomRevert {+ /// @dev ERC-7751 error for wrapping bubbled up reverts+ error WrappedError(address target, bytes4 selector, bytes reason, bytes details);++ /// @dev Reverts with the selector of a custom error in the scratch space+ function revertWith(bytes4 selector) internal pure {+ assembly ("memory-safe") {+ mstore(0, selector)+ revert(0, 0x04)+ }+ }++ /// @dev Reverts with a custom error with an address argument in the scratch space+ function revertWith(bytes4 selector, address addr) internal pure {+ assembly ("memory-safe") {+ mstore(0, selector)+ mstore(0x04, and(addr, 0xffffffffffffffffffffffffffffffffffffffff))+ revert(0, 0x24)+ }+ }++ /// @dev Reverts with a custom error with an int24 argument in the scratch space+ function revertWith(bytes4 selector, int24 value) internal pure {+ assembly ("memory-safe") {+ mstore(0, selector)+ mstore(0x04, signextend(2, value))+ revert(0, 0x24)+ }+ }++ /// @dev Reverts with a custom error with a uint160 argument in the scratch space+ function revertWith(bytes4 selector, uint160 value) internal pure {+ assembly ("memory-safe") {+ mstore(0, selector)+ mstore(0x04, and(value, 0xffffffffffffffffffffffffffffffffffffffff))+ revert(0, 0x24)+ }+ }++ /// @dev Reverts with a custom error with two int24 arguments+ function revertWith(bytes4 selector, int24 value1, int24 value2) internal pure {+ assembly ("memory-safe") {+ let fmp := mload(0x40)+ mstore(fmp, selector)+ mstore(add(fmp, 0x04), signextend(2, value1))+ mstore(add(fmp, 0x24), signextend(2, value2))+ revert(fmp, 0x44)+ }+ }++ /// @dev Reverts with a custom error with two uint160 arguments+ function revertWith(bytes4 selector, uint160 value1, uint160 value2) internal pure {+ assembly ("memory-safe") {+ let fmp := mload(0x40)+ mstore(fmp, selector)+ mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff))+ mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff))+ revert(fmp, 0x44)+ }+ }++ /// @dev Reverts with a custom error with two address arguments+ function revertWith(bytes4 selector, address value1, address value2) internal pure {+ assembly ("memory-safe") {+ let fmp := mload(0x40)+ mstore(fmp, selector)+ mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff))+ mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff))+ revert(fmp, 0x44)+ }+ }++ /// @notice bubble up the revert message returned by a call and revert with a wrapped ERC-7751 error+ /// @dev this method can be vulnerable to revert data bombs+ function bubbleUpAndRevertWith(+ address revertingContract,+ bytes4 revertingFunctionSelector,+ bytes4 additionalContext+ ) internal pure {+ bytes4 wrappedErrorSelector = WrappedError.selector;+ assembly ("memory-safe") {+ // Ensure the size of the revert data is a multiple of 32 bytes+ let encodedDataSize := mul(div(add(returndatasize(), 31), 32), 32)++ let fmp := mload(0x40)++ // Encode wrapped error selector, address, function selector, offset, additional context, size, revert reason+ mstore(fmp, wrappedErrorSelector)+ mstore(add(fmp, 0x04), and(revertingContract, 0xffffffffffffffffffffffffffffffffffffffff))+ mstore(+ add(fmp, 0x24),+ and(revertingFunctionSelector, 0xffffffff00000000000000000000000000000000000000000000000000000000)+ )+ // offset revert reason+ mstore(add(fmp, 0x44), 0x80)+ // offset additional context+ mstore(add(fmp, 0x64), add(0xa0, encodedDataSize))+ // size revert reason+ mstore(add(fmp, 0x84), returndatasize())+ // revert reason+ returndatacopy(add(fmp, 0xa4), 0, returndatasize())+ // size additional context+ mstore(add(fmp, add(0xa4, encodedDataSize)), 0x04)+ // additional context+ mstore(+ add(fmp, add(0xc4, encodedDataSize)),+ and(additionalContext, 0xffffffff00000000000000000000000000000000000000000000000000000000)+ )+ revert(fmp, add(0xe4, encodedDataSize))+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/FixedPoint128.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/FixedPoint128.solnew file mode 100644index 000000000..ef69ae80e--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/FixedPoint128.sol@@ -0,0 +1,8 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @title FixedPoint128+/// @notice A library for handling binary fixed point numbers, see https://en.wikipedia.org/wiki/Q_(number_format)+library FixedPoint128 {+ uint256 internal constant Q128 = 0x100000000000000000000000000000000;+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/FixedPoint96.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/FixedPoint96.solnew file mode 100644index 000000000..8e704cb34--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/FixedPoint96.sol@@ -0,0 +1,10 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @title FixedPoint96+/// @notice A library for handling binary fixed point numbers, see https://en.wikipedia.org/wiki/Q_(number_format)+/// @dev Used in SqrtPriceMath.sol+library FixedPoint96 {+ uint8 internal constant RESOLUTION = 96;+ uint256 internal constant Q96 = 0x1000000000000000000000000;+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/FullMath.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/FullMath.solnew file mode 100644index 000000000..2dc13788d--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/FullMath.sol@@ -0,0 +1,117 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @title Contains 512-bit math functions+/// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision+/// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits+library FullMath {+ /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0+ /// @param a The multiplicand+ /// @param b The multiplier+ /// @param denominator The divisor+ /// @return result The 256-bit result+ /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv+ function mulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {+ unchecked {+ // 512-bit multiply [prod1 prod0] = a * b+ // Compute the product mod 2**256 and mod 2**256 - 1+ // then use the Chinese Remainder Theorem to reconstruct+ // the 512 bit result. The result is stored in two 256+ // variables such that product = prod1 * 2**256 + prod0+ uint256 prod0 = a * b; // Least significant 256 bits of the product+ uint256 prod1; // Most significant 256 bits of the product+ assembly ("memory-safe") {+ let mm := mulmod(a, b, not(0))+ prod1 := sub(sub(mm, prod0), lt(mm, prod0))+ }++ // Make sure the result is less than 2**256.+ // Also prevents denominator == 0+ require(denominator > prod1);++ // Handle non-overflow cases, 256 by 256 division+ if (prod1 == 0) {+ assembly ("memory-safe") {+ result := div(prod0, denominator)+ }+ return result;+ }++ ///////////////////////////////////////////////+ // 512 by 256 division.+ ///////////////////////////////////////////////++ // Make division exact by subtracting the remainder from [prod1 prod0]+ // Compute remainder using mulmod+ uint256 remainder;+ assembly ("memory-safe") {+ remainder := mulmod(a, b, denominator)+ }+ // Subtract 256 bit number from 512 bit number+ assembly ("memory-safe") {+ prod1 := sub(prod1, gt(remainder, prod0))+ prod0 := sub(prod0, remainder)+ }++ // Factor powers of two out of denominator+ // Compute largest power of two divisor of denominator.+ // Always >= 1.+ uint256 twos = (0 - denominator) & denominator;+ // Divide denominator by power of two+ assembly ("memory-safe") {+ denominator := div(denominator, twos)+ }++ // Divide [prod1 prod0] by the factors of two+ assembly ("memory-safe") {+ prod0 := div(prod0, twos)+ }+ // Shift in bits from prod1 into prod0. For this we need+ // to flip `twos` such that it is 2**256 / twos.+ // If twos is zero, then it becomes one+ assembly ("memory-safe") {+ twos := add(div(sub(0, twos), twos), 1)+ }+ prod0 |= prod1 * twos;++ // Invert denominator mod 2**256+ // Now that denominator is an odd number, it has an inverse+ // modulo 2**256 such that denominator * inv = 1 mod 2**256.+ // Compute the inverse by starting with a seed that is correct+ // correct for four bits. That is, denominator * inv = 1 mod 2**4+ uint256 inv = (3 * denominator) ^ 2;+ // Now use Newton-Raphson iteration to improve the precision.+ // Thanks to Hensel's lifting lemma, this also works in modular+ // arithmetic, doubling the correct bits in each step.+ inv *= 2 - denominator * inv; // inverse mod 2**8+ inv *= 2 - denominator * inv; // inverse mod 2**16+ inv *= 2 - denominator * inv; // inverse mod 2**32+ inv *= 2 - denominator * inv; // inverse mod 2**64+ inv *= 2 - denominator * inv; // inverse mod 2**128+ inv *= 2 - denominator * inv; // inverse mod 2**256++ // Because the division is now exact we can divide by multiplying+ // with the modular inverse of denominator. This will give us the+ // correct result modulo 2**256. Since the preconditions guarantee+ // that the outcome is less than 2**256, this is the final result.+ // We don't need to compute the high bits of the result and prod1+ // is no longer required.+ result = prod0 * inv;+ return result;+ }+ }++ /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0+ /// @param a The multiplicand+ /// @param b The multiplier+ /// @param denominator The divisor+ /// @return result The 256-bit result+ function mulDivRoundingUp(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {+ unchecked {+ result = mulDiv(a, b, denominator);+ if (mulmod(a, b, denominator) != 0) {+ require(++result > 0);+ }+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/Hooks.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/Hooks.solnew file mode 100644index 000000000..0b8c869da--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/Hooks.sol@@ -0,0 +1,339 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {PoolKey} from "../types/PoolKey.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {SafeCast} from "./SafeCast.sol";+import {LPFeeLibrary} from "./LPFeeLibrary.sol";+import {BalanceDelta, toBalanceDelta, BalanceDeltaLibrary} from "../types/BalanceDelta.sol";+import {BeforeSwapDelta, BeforeSwapDeltaLibrary} from "../types/BeforeSwapDelta.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {ParseBytes} from "./ParseBytes.sol";+import {CustomRevert} from "./CustomRevert.sol";++/// @notice V4 decides whether to invoke specific hooks by inspecting the least significant bits+/// of the address that the hooks contract is deployed to.+/// For example, a hooks contract deployed to address: 0x0000000000000000000000000000000000002400+/// has the lowest bits '10 0100 0000 0000' which would cause the 'before initialize' and 'after add liquidity' hooks to be used.+library Hooks {+ using LPFeeLibrary for uint24;+ using Hooks for IHooks;+ using SafeCast for int256;+ using BeforeSwapDeltaLibrary for BeforeSwapDelta;+ using ParseBytes for bytes;+ using CustomRevert for bytes4;++ uint160 internal constant ALL_HOOK_MASK = uint160((1 << 14) - 1);++ uint160 internal constant BEFORE_INITIALIZE_FLAG = 1 << 13;+ uint160 internal constant AFTER_INITIALIZE_FLAG = 1 << 12;++ uint160 internal constant BEFORE_ADD_LIQUIDITY_FLAG = 1 << 11;+ uint160 internal constant AFTER_ADD_LIQUIDITY_FLAG = 1 << 10;++ uint160 internal constant BEFORE_REMOVE_LIQUIDITY_FLAG = 1 << 9;+ uint160 internal constant AFTER_REMOVE_LIQUIDITY_FLAG = 1 << 8;++ uint160 internal constant BEFORE_SWAP_FLAG = 1 << 7;+ uint160 internal constant AFTER_SWAP_FLAG = 1 << 6;++ uint160 internal constant BEFORE_DONATE_FLAG = 1 << 5;+ uint160 internal constant AFTER_DONATE_FLAG = 1 << 4;++ uint160 internal constant BEFORE_SWAP_RETURNS_DELTA_FLAG = 1 << 3;+ uint160 internal constant AFTER_SWAP_RETURNS_DELTA_FLAG = 1 << 2;+ uint160 internal constant AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG = 1 << 1;+ uint160 internal constant AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG = 1 << 0;++ struct Permissions {+ bool beforeInitialize;+ bool afterInitialize;+ bool beforeAddLiquidity;+ bool afterAddLiquidity;+ bool beforeRemoveLiquidity;+ bool afterRemoveLiquidity;+ bool beforeSwap;+ bool afterSwap;+ bool beforeDonate;+ bool afterDonate;+ bool beforeSwapReturnDelta;+ bool afterSwapReturnDelta;+ bool afterAddLiquidityReturnDelta;+ bool afterRemoveLiquidityReturnDelta;+ }++ /// @notice Thrown if the address will not lead to the specified hook calls being called+ /// @param hooks The address of the hooks contract+ error HookAddressNotValid(address hooks);++ /// @notice Hook did not return its selector+ error InvalidHookResponse();++ /// @notice Additional context for ERC-7751 wrapped error when a hook call fails+ error HookCallFailed();++ /// @notice The hook's delta changed the swap from exactIn to exactOut or vice versa+ error HookDeltaExceedsSwapAmount();++ /// @notice Utility function intended to be used in hook constructors to ensure+ /// the deployed hooks address causes the intended hooks to be called+ /// @param permissions The hooks that are intended to be called+ /// @dev permissions param is memory as the function will be called from constructors+ function validateHookPermissions(IHooks self, Permissions memory permissions) internal pure {+ if (+ permissions.beforeInitialize != self.hasPermission(BEFORE_INITIALIZE_FLAG)+ || permissions.afterInitialize != self.hasPermission(AFTER_INITIALIZE_FLAG)+ || permissions.beforeAddLiquidity != self.hasPermission(BEFORE_ADD_LIQUIDITY_FLAG)+ || permissions.afterAddLiquidity != self.hasPermission(AFTER_ADD_LIQUIDITY_FLAG)+ || permissions.beforeRemoveLiquidity != self.hasPermission(BEFORE_REMOVE_LIQUIDITY_FLAG)+ || permissions.afterRemoveLiquidity != self.hasPermission(AFTER_REMOVE_LIQUIDITY_FLAG)+ || permissions.beforeSwap != self.hasPermission(BEFORE_SWAP_FLAG)+ || permissions.afterSwap != self.hasPermission(AFTER_SWAP_FLAG)+ || permissions.beforeDonate != self.hasPermission(BEFORE_DONATE_FLAG)+ || permissions.afterDonate != self.hasPermission(AFTER_DONATE_FLAG)+ || permissions.beforeSwapReturnDelta != self.hasPermission(BEFORE_SWAP_RETURNS_DELTA_FLAG)+ || permissions.afterSwapReturnDelta != self.hasPermission(AFTER_SWAP_RETURNS_DELTA_FLAG)+ || permissions.afterAddLiquidityReturnDelta != self.hasPermission(AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG)+ || permissions.afterRemoveLiquidityReturnDelta+ != self.hasPermission(AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG)+ ) {+ HookAddressNotValid.selector.revertWith(address(self));+ }+ }++ /// @notice Ensures that the hook address includes at least one hook flag or dynamic fees, or is the 0 address+ /// @param self The hook to verify+ /// @param fee The fee of the pool the hook is used with+ /// @return bool True if the hook address is valid+ function isValidHookAddress(IHooks self, uint24 fee) internal pure returns (bool) {+ // The hook can only have a flag to return a hook delta on an action if it also has the corresponding action flag+ if (!self.hasPermission(BEFORE_SWAP_FLAG) && self.hasPermission(BEFORE_SWAP_RETURNS_DELTA_FLAG)) return false;+ if (!self.hasPermission(AFTER_SWAP_FLAG) && self.hasPermission(AFTER_SWAP_RETURNS_DELTA_FLAG)) return false;+ if (!self.hasPermission(AFTER_ADD_LIQUIDITY_FLAG) && self.hasPermission(AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG))+ {+ return false;+ }+ if (+ !self.hasPermission(AFTER_REMOVE_LIQUIDITY_FLAG)+ && self.hasPermission(AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG)+ ) return false;++ // If there is no hook contract set, then fee cannot be dynamic+ // If a hook contract is set, it must have at least 1 flag set, or have a dynamic fee+ return address(self) == address(0)+ ? !fee.isDynamicFee()+ : (uint160(address(self)) & ALL_HOOK_MASK > 0 || fee.isDynamicFee());+ }++ /// @notice performs a hook call using the given calldata on the given hook that doesn't return a delta+ /// @return result The complete data returned by the hook+ function callHook(IHooks self, bytes memory data) internal returns (bytes memory result) {+ bool success;+ assembly ("memory-safe") {+ success := call(gas(), self, 0, add(data, 0x20), mload(data), 0, 0)+ }+ // Revert with FailedHookCall, containing any error message to bubble up+ if (!success) CustomRevert.bubbleUpAndRevertWith(address(self), bytes4(data), HookCallFailed.selector);++ // The call was successful, fetch the returned data+ assembly ("memory-safe") {+ // allocate result byte array from the free memory pointer+ result := mload(0x40)+ // store new free memory pointer at the end of the array padded to 32 bytes+ mstore(0x40, add(result, and(add(returndatasize(), 0x3f), not(0x1f))))+ // store length in memory+ mstore(result, returndatasize())+ // copy return data to result+ returndatacopy(add(result, 0x20), 0, returndatasize())+ }++ // Length must be at least 32 to contain the selector. Check expected selector and returned selector match.+ if (result.length < 32 || result.parseSelector() != data.parseSelector()) {+ InvalidHookResponse.selector.revertWith();+ }+ }++ /// @notice performs a hook call using the given calldata on the given hook+ /// @return int256 The delta returned by the hook+ function callHookWithReturnDelta(IHooks self, bytes memory data, bool parseReturn) internal returns (int256) {+ bytes memory result = callHook(self, data);++ // If this hook wasn't meant to return something, default to 0 delta+ if (!parseReturn) return 0;++ // A length of 64 bytes is required to return a bytes4, and a 32 byte delta+ if (result.length != 64) InvalidHookResponse.selector.revertWith();+ return result.parseReturnDelta();+ }++ /// @notice modifier to prevent calling a hook if they initiated the action+ modifier noSelfCall(IHooks self) {+ if (msg.sender != address(self)) {+ _;+ }+ }++ /// @notice calls beforeInitialize hook if permissioned and validates return value+ function beforeInitialize(IHooks self, PoolKey memory key, uint160 sqrtPriceX96) internal noSelfCall(self) {+ if (self.hasPermission(BEFORE_INITIALIZE_FLAG)) {+ self.callHook(abi.encodeCall(IHooks.beforeInitialize, (msg.sender, key, sqrtPriceX96)));+ }+ }++ /// @notice calls afterInitialize hook if permissioned and validates return value+ function afterInitialize(IHooks self, PoolKey memory key, uint160 sqrtPriceX96, int24 tick)+ internal+ noSelfCall(self)+ {+ if (self.hasPermission(AFTER_INITIALIZE_FLAG)) {+ self.callHook(abi.encodeCall(IHooks.afterInitialize, (msg.sender, key, sqrtPriceX96, tick)));+ }+ }++ /// @notice calls beforeModifyLiquidity hook if permissioned and validates return value+ function beforeModifyLiquidity(+ IHooks self,+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ bytes calldata hookData+ ) internal noSelfCall(self) {+ if (params.liquidityDelta > 0 && self.hasPermission(BEFORE_ADD_LIQUIDITY_FLAG)) {+ self.callHook(abi.encodeCall(IHooks.beforeAddLiquidity, (msg.sender, key, params, hookData)));+ } else if (params.liquidityDelta <= 0 && self.hasPermission(BEFORE_REMOVE_LIQUIDITY_FLAG)) {+ self.callHook(abi.encodeCall(IHooks.beforeRemoveLiquidity, (msg.sender, key, params, hookData)));+ }+ }++ /// @notice calls afterModifyLiquidity hook if permissioned and validates return value+ function afterModifyLiquidity(+ IHooks self,+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ BalanceDelta delta,+ BalanceDelta feesAccrued,+ bytes calldata hookData+ ) internal returns (BalanceDelta callerDelta, BalanceDelta hookDelta) {+ if (msg.sender == address(self)) return (delta, BalanceDeltaLibrary.ZERO_DELTA);++ callerDelta = delta;+ if (params.liquidityDelta > 0) {+ if (self.hasPermission(AFTER_ADD_LIQUIDITY_FLAG)) {+ hookDelta = BalanceDelta.wrap(+ self.callHookWithReturnDelta(+ abi.encodeCall(+ IHooks.afterAddLiquidity, (msg.sender, key, params, delta, feesAccrued, hookData)+ ),+ self.hasPermission(AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG)+ )+ );+ callerDelta = callerDelta - hookDelta;+ }+ } else {+ if (self.hasPermission(AFTER_REMOVE_LIQUIDITY_FLAG)) {+ hookDelta = BalanceDelta.wrap(+ self.callHookWithReturnDelta(+ abi.encodeCall(+ IHooks.afterRemoveLiquidity, (msg.sender, key, params, delta, feesAccrued, hookData)+ ),+ self.hasPermission(AFTER_REMOVE_LIQUIDITY_RETURNS_DELTA_FLAG)+ )+ );+ callerDelta = callerDelta - hookDelta;+ }+ }+ }++ /// @notice calls beforeSwap hook if permissioned and validates return value+ function beforeSwap(IHooks self, PoolKey memory key, IPoolManager.SwapParams memory params, bytes calldata hookData)+ internal+ returns (int256 amountToSwap, BeforeSwapDelta hookReturn, uint24 lpFeeOverride)+ {+ amountToSwap = params.amountSpecified;+ if (msg.sender == address(self)) return (amountToSwap, BeforeSwapDeltaLibrary.ZERO_DELTA, lpFeeOverride);++ if (self.hasPermission(BEFORE_SWAP_FLAG)) {+ bytes memory result = callHook(self, abi.encodeCall(IHooks.beforeSwap, (msg.sender, key, params, hookData)));++ // A length of 96 bytes is required to return a bytes4, a 32 byte delta, and an LP fee+ if (result.length != 96) InvalidHookResponse.selector.revertWith();++ // dynamic fee pools that want to override the cache fee, return a valid fee with the override flag. If override flag+ // is set but an invalid fee is returned, the transaction will revert. Otherwise the current LP fee will be used+ if (key.fee.isDynamicFee()) lpFeeOverride = result.parseFee();++ // skip this logic for the case where the hook return is 0+ if (self.hasPermission(BEFORE_SWAP_RETURNS_DELTA_FLAG)) {+ hookReturn = BeforeSwapDelta.wrap(result.parseReturnDelta());++ // any return in unspecified is passed to the afterSwap hook for handling+ int128 hookDeltaSpecified = hookReturn.getSpecifiedDelta();++ // Update the swap amount according to the hook's return, and check that the swap type doesn't change (exact input/output)+ if (hookDeltaSpecified != 0) {+ bool exactInput = amountToSwap < 0;+ amountToSwap += hookDeltaSpecified;+ if (exactInput ? amountToSwap > 0 : amountToSwap < 0) {+ HookDeltaExceedsSwapAmount.selector.revertWith();+ }+ }+ }+ }+ }++ /// @notice calls afterSwap hook if permissioned and validates return value+ function afterSwap(+ IHooks self,+ PoolKey memory key,+ IPoolManager.SwapParams memory params,+ BalanceDelta swapDelta,+ bytes calldata hookData,+ BeforeSwapDelta beforeSwapHookReturn+ ) internal returns (BalanceDelta, BalanceDelta) {+ if (msg.sender == address(self)) return (swapDelta, BalanceDeltaLibrary.ZERO_DELTA);++ int128 hookDeltaSpecified = beforeSwapHookReturn.getSpecifiedDelta();+ int128 hookDeltaUnspecified = beforeSwapHookReturn.getUnspecifiedDelta();++ if (self.hasPermission(AFTER_SWAP_FLAG)) {+ hookDeltaUnspecified += self.callHookWithReturnDelta(+ abi.encodeCall(IHooks.afterSwap, (msg.sender, key, params, swapDelta, hookData)),+ self.hasPermission(AFTER_SWAP_RETURNS_DELTA_FLAG)+ ).toInt128();+ }++ BalanceDelta hookDelta;+ if (hookDeltaUnspecified != 0 || hookDeltaSpecified != 0) {+ hookDelta = (params.amountSpecified < 0 == params.zeroForOne)+ ? toBalanceDelta(hookDeltaSpecified, hookDeltaUnspecified)+ : toBalanceDelta(hookDeltaUnspecified, hookDeltaSpecified);++ // the caller has to pay for (or receive) the hook's delta+ swapDelta = swapDelta - hookDelta;+ }+ return (swapDelta, hookDelta);+ }++ /// @notice calls beforeDonate hook if permissioned and validates return value+ function beforeDonate(IHooks self, PoolKey memory key, uint256 amount0, uint256 amount1, bytes calldata hookData)+ internal+ noSelfCall(self)+ {+ if (self.hasPermission(BEFORE_DONATE_FLAG)) {+ self.callHook(abi.encodeCall(IHooks.beforeDonate, (msg.sender, key, amount0, amount1, hookData)));+ }+ }++ /// @notice calls afterDonate hook if permissioned and validates return value+ function afterDonate(IHooks self, PoolKey memory key, uint256 amount0, uint256 amount1, bytes calldata hookData)+ internal+ noSelfCall(self)+ {+ if (self.hasPermission(AFTER_DONATE_FLAG)) {+ self.callHook(abi.encodeCall(IHooks.afterDonate, (msg.sender, key, amount0, amount1, hookData)));+ }+ }++ function hasPermission(IHooks self, uint160 flag) internal pure returns (bool) {+ return uint160(address(self)) & flag != 0;+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/LPFeeLibrary.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/LPFeeLibrary.solnew file mode 100644index 000000000..5a68f963e--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/LPFeeLibrary.sol@@ -0,0 +1,79 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {CustomRevert} from "./CustomRevert.sol";++/// @notice Library of helper functions for a pools LP fee+library LPFeeLibrary {+ using LPFeeLibrary for uint24;+ using CustomRevert for bytes4;++ /// @notice Thrown when the static or dynamic fee on a pool exceeds 100%.+ error LPFeeTooLarge(uint24 fee);++ /// @notice An lp fee of exactly 0b1000000... signals a dynamic fee pool. This isn't a valid static fee as it is > MAX_LP_FEE+ uint24 public constant DYNAMIC_FEE_FLAG = 0x800000;++ /// @notice the second bit of the fee returned by beforeSwap is used to signal if the stored LP fee should be overridden in this swap+ // only dynamic-fee pools can return a fee via the beforeSwap hook+ uint24 public constant OVERRIDE_FEE_FLAG = 0x400000;++ /// @notice mask to remove the override fee flag from a fee returned by the beforeSwaphook+ uint24 public constant REMOVE_OVERRIDE_MASK = 0xBFFFFF;++ /// @notice the lp fee is represented in hundredths of a bip, so the max is 100%+ uint24 public constant MAX_LP_FEE = 1000000;++ /// @notice returns true if a pool's LP fee signals that the pool has a dynamic fee+ /// @param self The fee to check+ /// @return bool True of the fee is dynamic+ function isDynamicFee(uint24 self) internal pure returns (bool) {+ return self == DYNAMIC_FEE_FLAG;+ }++ /// @notice returns true if an LP fee is valid, aka not above the maximum permitted fee+ /// @param self The fee to check+ /// @return bool True of the fee is valid+ function isValid(uint24 self) internal pure returns (bool) {+ return self <= MAX_LP_FEE;+ }++ /// @notice validates whether an LP fee is larger than the maximum, and reverts if invalid+ /// @param self The fee to validate+ function validate(uint24 self) internal pure {+ if (!self.isValid()) LPFeeTooLarge.selector.revertWith(self);+ }++ /// @notice gets and validates the initial LP fee for a pool. Dynamic fee pools have an initial fee of 0.+ /// @dev if a dynamic fee pool wants a non-0 initial fee, it should call `updateDynamicLPFee` in the afterInitialize hook+ /// @param self The fee to get the initial LP from+ /// @return initialFee 0 if the fee is dynamic, otherwise the fee (if valid)+ function getInitialLPFee(uint24 self) internal pure returns (uint24) {+ // the initial fee for a dynamic fee pool is 0+ if (self.isDynamicFee()) return 0;+ self.validate();+ return self;+ }++ /// @notice returns true if the fee has the override flag set (2nd highest bit of the uint24)+ /// @param self The fee to check+ /// @return bool True of the fee has the override flag set+ function isOverride(uint24 self) internal pure returns (bool) {+ return self & OVERRIDE_FEE_FLAG != 0;+ }++ /// @notice returns a fee with the override flag removed+ /// @param self The fee to remove the override flag from+ /// @return fee The fee without the override flag set+ function removeOverrideFlag(uint24 self) internal pure returns (uint24) {+ return self & REMOVE_OVERRIDE_MASK;+ }++ /// @notice Removes the override flag and validates the fee (reverts if the fee is too large)+ /// @param self The fee to remove the override flag from, and then validate+ /// @return fee The fee without the override flag set (if valid)+ function removeOverrideFlagAndValidate(uint24 self) internal pure returns (uint24 fee) {+ fee = self.removeOverrideFlag();+ fee.validate();+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/LiquidityMath.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/LiquidityMath.solnew file mode 100644index 000000000..ce5cfcd4f--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/LiquidityMath.sol@@ -0,0 +1,20 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @title Math library for liquidity+library LiquidityMath {+ /// @notice Add a signed liquidity delta to liquidity and revert if it overflows or underflows+ /// @param x The liquidity before change+ /// @param y The delta by which liquidity should be changed+ /// @return z The liquidity delta+ function addDelta(uint128 x, int128 y) internal pure returns (uint128 z) {+ assembly ("memory-safe") {+ z := add(and(x, 0xffffffffffffffffffffffffffffffff), signextend(15, y))+ if shr(128, z) {+ // revert SafeCastOverflow()+ mstore(0, 0x93dafdf1)+ revert(0x1c, 0x04)+ }+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/Lock.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/Lock.solnew file mode 100644index 000000000..cea38bf7b--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/Lock.sol@@ -0,0 +1,28 @@+// SPDX-License-Identifier: BUSL-1.1+pragma solidity ^0.8.24;++/// @notice This is a temporary library that allows us to use transient storage (tstore/tload)+/// TODO: This library can be deleted when we have the transient keyword support in solidity.+library Lock {+ // The slot holding the unlocked state, transiently. bytes32(uint256(keccak256("Unlocked")) - 1)+ bytes32 internal constant IS_UNLOCKED_SLOT = 0xc090fc4683624cfc3884e9d8de5eca132f2d0ec062aff75d43c0465d5ceeab23;++ function unlock() internal {+ assembly ("memory-safe") {+ // unlock+ tstore(IS_UNLOCKED_SLOT, true)+ }+ }++ function lock() internal {+ assembly ("memory-safe") {+ tstore(IS_UNLOCKED_SLOT, false)+ }+ }++ function isUnlocked() internal view returns (bool unlocked) {+ assembly ("memory-safe") {+ unlocked := tload(IS_UNLOCKED_SLOT)+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/NonzeroDeltaCount.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/NonzeroDeltaCount.solnew file mode 100644index 000000000..3221df0c9--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/NonzeroDeltaCount.sol@@ -0,0 +1,35 @@+// SPDX-License-Identifier: BUSL-1.1+pragma solidity ^0.8.24;++/// @notice This is a temporary library that allows us to use transient storage (tstore/tload)+/// for the nonzero delta count.+/// TODO: This library can be deleted when we have the transient keyword support in solidity.+library NonzeroDeltaCount {+ // The slot holding the number of nonzero deltas. bytes32(uint256(keccak256("NonzeroDeltaCount")) - 1)+ bytes32 internal constant NONZERO_DELTA_COUNT_SLOT =+ 0x7d4b3164c6e45b97e7d87b7125a44c5828d005af88f9d751cfd78729c5d99a0b;++ function read() internal view returns (uint256 count) {+ assembly ("memory-safe") {+ count := tload(NONZERO_DELTA_COUNT_SLOT)+ }+ }++ function increment() internal {+ assembly ("memory-safe") {+ let count := tload(NONZERO_DELTA_COUNT_SLOT)+ count := add(count, 1)+ tstore(NONZERO_DELTA_COUNT_SLOT, count)+ }+ }++ /// @notice Potential to underflow. Ensure checks are performed by integrating contracts to ensure this does not happen.+ /// Current usage ensures this will not happen because we call decrement with known boundaries (only up to the number of times we call increment).+ function decrement() internal {+ assembly ("memory-safe") {+ let count := tload(NONZERO_DELTA_COUNT_SLOT)+ count := sub(count, 1)+ tstore(NONZERO_DELTA_COUNT_SLOT, count)+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/ParseBytes.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/ParseBytes.solnew file mode 100644index 000000000..3503fe4a4--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/ParseBytes.sol@@ -0,0 +1,29 @@+// SPDX-License-Identifier: MIT++pragma solidity ^0.8.0;++/// @notice Parses bytes returned from hooks and the byte selector used to check return selectors from hooks.+/// @dev parseSelector also is used to parse the expected selector+/// For parsing hook returns, note that all hooks return either bytes4 or (bytes4, 32-byte-delta) or (bytes4, 32-byte-delta, uint24).+library ParseBytes {+ function parseSelector(bytes memory result) internal pure returns (bytes4 selector) {+ // equivalent: (selector,) = abi.decode(result, (bytes4, int256));+ assembly ("memory-safe") {+ selector := mload(add(result, 0x20))+ }+ }++ function parseFee(bytes memory result) internal pure returns (uint24 lpFee) {+ // equivalent: (,, lpFee) = abi.decode(result, (bytes4, int256, uint24));+ assembly ("memory-safe") {+ lpFee := mload(add(result, 0x60))+ }+ }++ function parseReturnDelta(bytes memory result) internal pure returns (int256 hookReturn) {+ // equivalent: (, hookReturnDelta) = abi.decode(result, (bytes4, int256));+ assembly ("memory-safe") {+ hookReturn := mload(add(result, 0x40))+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/Pool.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/Pool.solnew file mode 100644index 000000000..65a77a203--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/Pool.sol@@ -0,0 +1,613 @@+// SPDX-License-Identifier: BUSL-1.1+pragma solidity ^0.8.0;++import {SafeCast} from "./SafeCast.sol";+import {TickBitmap} from "./TickBitmap.sol";+import {Position} from "./Position.sol";+import {UnsafeMath} from "./UnsafeMath.sol";+import {FixedPoint128} from "./FixedPoint128.sol";+import {TickMath} from "./TickMath.sol";+import {SqrtPriceMath} from "./SqrtPriceMath.sol";+import {SwapMath} from "./SwapMath.sol";+import {BalanceDelta, toBalanceDelta, BalanceDeltaLibrary} from "../types/BalanceDelta.sol";+import {Slot0} from "../types/Slot0.sol";+import {ProtocolFeeLibrary} from "./ProtocolFeeLibrary.sol";+import {LiquidityMath} from "./LiquidityMath.sol";+import {LPFeeLibrary} from "./LPFeeLibrary.sol";+import {CustomRevert} from "./CustomRevert.sol";++/// @notice a library with all actions that can be performed on a pool+library Pool {+ using SafeCast for *;+ using TickBitmap for mapping(int16 => uint256);+ using Position for mapping(bytes32 => Position.State);+ using Position for Position.State;+ using Pool for State;+ using ProtocolFeeLibrary for *;+ using LPFeeLibrary for uint24;+ using CustomRevert for bytes4;++ /// @notice Thrown when tickLower is not below tickUpper+ /// @param tickLower The invalid tickLower+ /// @param tickUpper The invalid tickUpper+ error TicksMisordered(int24 tickLower, int24 tickUpper);++ /// @notice Thrown when tickLower is less than min tick+ /// @param tickLower The invalid tickLower+ error TickLowerOutOfBounds(int24 tickLower);++ /// @notice Thrown when tickUpper exceeds max tick+ /// @param tickUpper The invalid tickUpper+ error TickUpperOutOfBounds(int24 tickUpper);++ /// @notice For the tick spacing, the tick has too much liquidity+ error TickLiquidityOverflow(int24 tick);++ /// @notice Thrown when trying to initialize an already initialized pool+ error PoolAlreadyInitialized();++ /// @notice Thrown when trying to interact with a non-initialized pool+ error PoolNotInitialized();++ /// @notice Thrown when sqrtPriceLimitX96 on a swap has already exceeded its limit+ /// @param sqrtPriceCurrentX96 The invalid, already surpassed sqrtPriceLimitX96+ /// @param sqrtPriceLimitX96 The surpassed price limit+ error PriceLimitAlreadyExceeded(uint160 sqrtPriceCurrentX96, uint160 sqrtPriceLimitX96);++ /// @notice Thrown when sqrtPriceLimitX96 lies outside of valid tick/price range+ /// @param sqrtPriceLimitX96 The invalid, out-of-bounds sqrtPriceLimitX96+ error PriceLimitOutOfBounds(uint160 sqrtPriceLimitX96);++ /// @notice Thrown by donate if there is currently 0 liquidity, since the fees will not go to any liquidity providers+ error NoLiquidityToReceiveFees();++ /// @notice Thrown when trying to swap with max lp fee and specifying an output amount+ error InvalidFeeForExactOut();++ // info stored for each initialized individual tick+ struct TickInfo {+ // the total position liquidity that references this tick+ uint128 liquidityGross;+ // amount of net liquidity added (subtracted) when tick is crossed from left to right (right to left),+ int128 liquidityNet;+ // fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick)+ // only has relative meaning, not absolute — the value depends on when the tick is initialized+ uint256 feeGrowthOutside0X128;+ uint256 feeGrowthOutside1X128;+ }++ /// @notice The state of a pool+ /// @dev Note that feeGrowthGlobal can be artificially inflated+ /// For pools with a single liquidity position, actors can donate to themselves to freely inflate feeGrowthGlobal+ /// atomically donating and collecting fees in the same unlockCallback may make the inflated value more extreme+ struct State {+ Slot0 slot0;+ uint256 feeGrowthGlobal0X128;+ uint256 feeGrowthGlobal1X128;+ uint128 liquidity;+ mapping(int24 tick => TickInfo) ticks;+ mapping(int16 wordPos => uint256) tickBitmap;+ mapping(bytes32 positionKey => Position.State) positions;+ }++ /// @dev Common checks for valid tick inputs.+ function checkTicks(int24 tickLower, int24 tickUpper) private pure {+ if (tickLower >= tickUpper) TicksMisordered.selector.revertWith(tickLower, tickUpper);+ if (tickLower < TickMath.MIN_TICK) TickLowerOutOfBounds.selector.revertWith(tickLower);+ if (tickUpper > TickMath.MAX_TICK) TickUpperOutOfBounds.selector.revertWith(tickUpper);+ }++ function initialize(State storage self, uint160 sqrtPriceX96, uint24 lpFee) internal returns (int24 tick) {+ if (self.slot0.sqrtPriceX96() != 0) PoolAlreadyInitialized.selector.revertWith();++ tick = TickMath.getTickAtSqrtPrice(sqrtPriceX96);++ // the initial protocolFee is 0 so doesn't need to be set+ self.slot0 = Slot0.wrap(bytes32(0)).setSqrtPriceX96(sqrtPriceX96).setTick(tick).setLpFee(lpFee);+ }++ function setProtocolFee(State storage self, uint24 protocolFee) internal {+ self.checkPoolInitialized();+ self.slot0 = self.slot0.setProtocolFee(protocolFee);+ }++ /// @notice Only dynamic fee pools may update the lp fee.+ function setLPFee(State storage self, uint24 lpFee) internal {+ self.checkPoolInitialized();+ self.slot0 = self.slot0.setLpFee(lpFee);+ }++ struct ModifyLiquidityParams {+ // the address that owns the position+ address owner;+ // the lower and upper tick of the position+ int24 tickLower;+ int24 tickUpper;+ // any change in liquidity+ int128 liquidityDelta;+ // the spacing between ticks+ int24 tickSpacing;+ // used to distinguish positions of the same owner, at the same tick range+ bytes32 salt;+ }++ struct ModifyLiquidityState {+ bool flippedLower;+ uint128 liquidityGrossAfterLower;+ bool flippedUpper;+ uint128 liquidityGrossAfterUpper;+ }++ /// @notice Effect changes to a position in a pool+ /// @dev PoolManager checks that the pool is initialized before calling+ /// @param params the position details and the change to the position's liquidity to effect+ /// @return delta the deltas of the token balances of the pool, from the liquidity change+ /// @return feeDelta the fees generated by the liquidity range+ function modifyLiquidity(State storage self, ModifyLiquidityParams memory params)+ internal+ returns (BalanceDelta delta, BalanceDelta feeDelta)+ {+ int128 liquidityDelta = params.liquidityDelta;+ int24 tickLower = params.tickLower;+ int24 tickUpper = params.tickUpper;+ checkTicks(tickLower, tickUpper);++ {+ ModifyLiquidityState memory state;++ // if we need to update the ticks, do it+ if (liquidityDelta != 0) {+ (state.flippedLower, state.liquidityGrossAfterLower) =+ updateTick(self, tickLower, liquidityDelta, false);+ (state.flippedUpper, state.liquidityGrossAfterUpper) = updateTick(self, tickUpper, liquidityDelta, true);++ // `>` and `>=` are logically equivalent here but `>=` is cheaper+ if (liquidityDelta >= 0) {+ uint128 maxLiquidityPerTick = tickSpacingToMaxLiquidityPerTick(params.tickSpacing);+ if (state.liquidityGrossAfterLower > maxLiquidityPerTick) {+ TickLiquidityOverflow.selector.revertWith(tickLower);+ }+ if (state.liquidityGrossAfterUpper > maxLiquidityPerTick) {+ TickLiquidityOverflow.selector.revertWith(tickUpper);+ }+ }++ if (state.flippedLower) {+ self.tickBitmap.flipTick(tickLower, params.tickSpacing);+ }+ if (state.flippedUpper) {+ self.tickBitmap.flipTick(tickUpper, params.tickSpacing);+ }+ }++ {+ (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) =+ getFeeGrowthInside(self, tickLower, tickUpper);++ Position.State storage position = self.positions.get(params.owner, tickLower, tickUpper, params.salt);+ (uint256 feesOwed0, uint256 feesOwed1) =+ position.update(liquidityDelta, feeGrowthInside0X128, feeGrowthInside1X128);++ // Fees earned from LPing are calculated, and returned+ feeDelta = toBalanceDelta(feesOwed0.toInt128(), feesOwed1.toInt128());+ }++ // clear any tick data that is no longer needed+ if (liquidityDelta < 0) {+ if (state.flippedLower) {+ clearTick(self, tickLower);+ }+ if (state.flippedUpper) {+ clearTick(self, tickUpper);+ }+ }+ }++ if (liquidityDelta != 0) {+ Slot0 _slot0 = self.slot0;+ (int24 tick, uint160 sqrtPriceX96) = (_slot0.tick(), _slot0.sqrtPriceX96());+ if (tick < tickLower) {+ // current tick is below the passed range; liquidity can only become in range by crossing from left to+ // right, when we'll need _more_ currency0 (it's becoming more valuable) so user must provide it+ delta = toBalanceDelta(+ SqrtPriceMath.getAmount0Delta(+ TickMath.getSqrtPriceAtTick(tickLower), TickMath.getSqrtPriceAtTick(tickUpper), liquidityDelta+ ).toInt128(),+ 0+ );+ } else if (tick < tickUpper) {+ delta = toBalanceDelta(+ SqrtPriceMath.getAmount0Delta(sqrtPriceX96, TickMath.getSqrtPriceAtTick(tickUpper), liquidityDelta)+ .toInt128(),+ SqrtPriceMath.getAmount1Delta(TickMath.getSqrtPriceAtTick(tickLower), sqrtPriceX96, liquidityDelta)+ .toInt128()+ );++ self.liquidity = LiquidityMath.addDelta(self.liquidity, liquidityDelta);+ } else {+ // current tick is above the passed range; liquidity can only become in range by crossing from right to+ // left, when we'll need _more_ currency1 (it's becoming more valuable) so user must provide it+ delta = toBalanceDelta(+ 0,+ SqrtPriceMath.getAmount1Delta(+ TickMath.getSqrtPriceAtTick(tickLower), TickMath.getSqrtPriceAtTick(tickUpper), liquidityDelta+ ).toInt128()+ );+ }+ }+ }++ // Tracks the state of a pool throughout a swap, and returns these values at the end of the swap+ struct SwapResult {+ // the current sqrt(price)+ uint160 sqrtPriceX96;+ // the tick associated with the current price+ int24 tick;+ // the current liquidity in range+ uint128 liquidity;+ }++ struct StepComputations {+ // the price at the beginning of the step+ uint160 sqrtPriceStartX96;+ // the next tick to swap to from the current tick in the swap direction+ int24 tickNext;+ // whether tickNext is initialized or not+ bool initialized;+ // sqrt(price) for the next tick (1/0)+ uint160 sqrtPriceNextX96;+ // how much is being swapped in in this step+ uint256 amountIn;+ // how much is being swapped out+ uint256 amountOut;+ // how much fee is being paid in+ uint256 feeAmount;+ // the global fee growth of the input token. updated in storage at the end of swap+ uint256 feeGrowthGlobalX128;+ }++ struct SwapParams {+ int256 amountSpecified;+ int24 tickSpacing;+ bool zeroForOne;+ uint160 sqrtPriceLimitX96;+ uint24 lpFeeOverride;+ }++ /// @notice Executes a swap against the state, and returns the amount deltas of the pool+ /// @dev PoolManager checks that the pool is initialized before calling+ function swap(State storage self, SwapParams memory params)+ internal+ returns (BalanceDelta swapDelta, uint256 amountToProtocol, uint24 swapFee, SwapResult memory result)+ {+ Slot0 slot0Start = self.slot0;+ bool zeroForOne = params.zeroForOne;++ uint256 protocolFee =+ zeroForOne ? slot0Start.protocolFee().getZeroForOneFee() : slot0Start.protocolFee().getOneForZeroFee();++ // the amount remaining to be swapped in/out of the input/output asset. initially set to the amountSpecified+ int256 amountSpecifiedRemaining = params.amountSpecified;+ // the amount swapped out/in of the output/input asset. initially set to 0+ int256 amountCalculated = 0;+ // initialize to the current sqrt(price)+ result.sqrtPriceX96 = slot0Start.sqrtPriceX96();+ // initialize to the current tick+ result.tick = slot0Start.tick();+ // initialize to the current liquidity+ result.liquidity = self.liquidity;++ // if the beforeSwap hook returned a valid fee override, use that as the LP fee, otherwise load from storage+ // lpFee, swapFee, and protocolFee are all in pips+ {+ uint24 lpFee = params.lpFeeOverride.isOverride()+ ? params.lpFeeOverride.removeOverrideFlagAndValidate()+ : slot0Start.lpFee();++ swapFee = protocolFee == 0 ? lpFee : uint16(protocolFee).calculateSwapFee(lpFee);+ }++ // a swap fee totaling MAX_SWAP_FEE (100%) makes exact output swaps impossible since the input is entirely consumed by the fee+ if (swapFee >= SwapMath.MAX_SWAP_FEE) {+ // if exactOutput+ if (params.amountSpecified > 0) {+ InvalidFeeForExactOut.selector.revertWith();+ }+ }++ // swapFee is the pool's fee in pips (LP fee + protocol fee)+ // when the amount swapped is 0, there is no protocolFee applied and the fee amount paid to the protocol is set to 0+ if (params.amountSpecified == 0) return (BalanceDeltaLibrary.ZERO_DELTA, 0, swapFee, result);++ if (zeroForOne) {+ if (params.sqrtPriceLimitX96 >= slot0Start.sqrtPriceX96()) {+ PriceLimitAlreadyExceeded.selector.revertWith(slot0Start.sqrtPriceX96(), params.sqrtPriceLimitX96);+ }+ // Swaps can never occur at MIN_TICK, only at MIN_TICK + 1, except at initialization of a pool+ // Under certain circumstances outlined below, the tick will preemptively reach MIN_TICK without swapping there+ if (params.sqrtPriceLimitX96 <= TickMath.MIN_SQRT_PRICE) {+ PriceLimitOutOfBounds.selector.revertWith(params.sqrtPriceLimitX96);+ }+ } else {+ if (params.sqrtPriceLimitX96 <= slot0Start.sqrtPriceX96()) {+ PriceLimitAlreadyExceeded.selector.revertWith(slot0Start.sqrtPriceX96(), params.sqrtPriceLimitX96);+ }+ if (params.sqrtPriceLimitX96 >= TickMath.MAX_SQRT_PRICE) {+ PriceLimitOutOfBounds.selector.revertWith(params.sqrtPriceLimitX96);+ }+ }++ StepComputations memory step;+ step.feeGrowthGlobalX128 = zeroForOne ? self.feeGrowthGlobal0X128 : self.feeGrowthGlobal1X128;++ // continue swapping as long as we haven't used the entire input/output and haven't reached the price limit+ while (!(amountSpecifiedRemaining == 0 || result.sqrtPriceX96 == params.sqrtPriceLimitX96)) {+ step.sqrtPriceStartX96 = result.sqrtPriceX96;++ (step.tickNext, step.initialized) =+ self.tickBitmap.nextInitializedTickWithinOneWord(result.tick, params.tickSpacing, zeroForOne);++ // ensure that we do not overshoot the min/max tick, as the tick bitmap is not aware of these bounds+ if (step.tickNext <= TickMath.MIN_TICK) {+ step.tickNext = TickMath.MIN_TICK;+ }+ if (step.tickNext >= TickMath.MAX_TICK) {+ step.tickNext = TickMath.MAX_TICK;+ }++ // get the price for the next tick+ step.sqrtPriceNextX96 = TickMath.getSqrtPriceAtTick(step.tickNext);++ // compute values to swap to the target tick, price limit, or point where input/output amount is exhausted+ (result.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount) = SwapMath.computeSwapStep(+ result.sqrtPriceX96,+ SwapMath.getSqrtPriceTarget(zeroForOne, step.sqrtPriceNextX96, params.sqrtPriceLimitX96),+ result.liquidity,+ amountSpecifiedRemaining,+ swapFee+ );++ // if exactOutput+ if (params.amountSpecified > 0) {+ unchecked {+ amountSpecifiedRemaining -= step.amountOut.toInt256();+ }+ amountCalculated -= (step.amountIn + step.feeAmount).toInt256();+ } else {+ // safe because we test that amountSpecified > amountIn + feeAmount in SwapMath+ unchecked {+ amountSpecifiedRemaining += (step.amountIn + step.feeAmount).toInt256();+ }+ amountCalculated += step.amountOut.toInt256();+ }++ // if the protocol fee is on, calculate how much is owed, decrement feeAmount, and increment protocolFee+ if (protocolFee > 0) {+ unchecked {+ // step.amountIn does not include the swap fee, as it's already been taken from it,+ // so add it back to get the total amountIn and use that to calculate the amount of fees owed to the protocol+ // cannot overflow due to limits on the size of protocolFee and params.amountSpecified+ // this rounds down to favor LPs over the protocol+ uint256 delta = (swapFee == protocolFee)+ ? step.feeAmount // lp fee is 0, so the entire fee is owed to the protocol instead+ : (step.amountIn + step.feeAmount) * protocolFee / ProtocolFeeLibrary.PIPS_DENOMINATOR;+ // subtract it from the total fee and add it to the protocol fee+ step.feeAmount -= delta;+ amountToProtocol += delta;+ }+ }++ // update global fee tracker+ if (result.liquidity > 0) {+ unchecked {+ // FullMath.mulDiv isn't needed as the numerator can't overflow uint256 since tokens have a max supply of type(uint128).max+ step.feeGrowthGlobalX128 +=+ UnsafeMath.simpleMulDiv(step.feeAmount, FixedPoint128.Q128, result.liquidity);+ }+ }++ // Shift tick if we reached the next price, and preemptively decrement for zeroForOne swaps to tickNext - 1.+ // If the swap doesn't continue (if amountRemaining == 0 or sqrtPriceLimit is met), slot0.tick will be 1 less+ // than getTickAtSqrtPrice(slot0.sqrtPrice). This doesn't affect swaps, but donation calls should verify both+ // price and tick to reward the correct LPs.+ if (result.sqrtPriceX96 == step.sqrtPriceNextX96) {+ // if the tick is initialized, run the tick transition+ if (step.initialized) {+ (uint256 feeGrowthGlobal0X128, uint256 feeGrowthGlobal1X128) = zeroForOne+ ? (step.feeGrowthGlobalX128, self.feeGrowthGlobal1X128)+ : (self.feeGrowthGlobal0X128, step.feeGrowthGlobalX128);+ int128 liquidityNet =+ Pool.crossTick(self, step.tickNext, feeGrowthGlobal0X128, feeGrowthGlobal1X128);+ // if we're moving leftward, we interpret liquidityNet as the opposite sign+ // safe because liquidityNet cannot be type(int128).min+ unchecked {+ if (zeroForOne) liquidityNet = -liquidityNet;+ }++ result.liquidity = LiquidityMath.addDelta(result.liquidity, liquidityNet);+ }++ unchecked {+ result.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;+ }+ } else if (result.sqrtPriceX96 != step.sqrtPriceStartX96) {+ // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved+ result.tick = TickMath.getTickAtSqrtPrice(result.sqrtPriceX96);+ }+ }++ self.slot0 = slot0Start.setTick(result.tick).setSqrtPriceX96(result.sqrtPriceX96);++ // update liquidity if it changed+ if (self.liquidity != result.liquidity) self.liquidity = result.liquidity;++ // update fee growth global+ if (!zeroForOne) {+ self.feeGrowthGlobal1X128 = step.feeGrowthGlobalX128;+ } else {+ self.feeGrowthGlobal0X128 = step.feeGrowthGlobalX128;+ }++ unchecked {+ // "if currency1 is specified"+ if (zeroForOne != (params.amountSpecified < 0)) {+ swapDelta = toBalanceDelta(+ amountCalculated.toInt128(), (params.amountSpecified - amountSpecifiedRemaining).toInt128()+ );+ } else {+ swapDelta = toBalanceDelta(+ (params.amountSpecified - amountSpecifiedRemaining).toInt128(), amountCalculated.toInt128()+ );+ }+ }+ }++ /// @notice Donates the given amount of currency0 and currency1 to the pool+ function donate(State storage state, uint256 amount0, uint256 amount1) internal returns (BalanceDelta delta) {+ uint128 liquidity = state.liquidity;+ if (liquidity == 0) NoLiquidityToReceiveFees.selector.revertWith();+ unchecked {+ // negation safe as amount0 and amount1 are always positive+ delta = toBalanceDelta(-(amount0.toInt128()), -(amount1.toInt128()));+ // FullMath.mulDiv is unnecessary because the numerator is bounded by type(int128).max * Q128, which is less than type(uint256).max+ if (amount0 > 0) {+ state.feeGrowthGlobal0X128 += UnsafeMath.simpleMulDiv(amount0, FixedPoint128.Q128, liquidity);+ }+ if (amount1 > 0) {+ state.feeGrowthGlobal1X128 += UnsafeMath.simpleMulDiv(amount1, FixedPoint128.Q128, liquidity);+ }+ }+ }++ /// @notice Retrieves fee growth data+ /// @param self The Pool state struct+ /// @param tickLower The lower tick boundary of the position+ /// @param tickUpper The upper tick boundary of the position+ /// @return feeGrowthInside0X128 The all-time fee growth in token0, per unit of liquidity, inside the position's tick boundaries+ /// @return feeGrowthInside1X128 The all-time fee growth in token1, per unit of liquidity, inside the position's tick boundaries+ function getFeeGrowthInside(State storage self, int24 tickLower, int24 tickUpper)+ internal+ view+ returns (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128)+ {+ TickInfo storage lower = self.ticks[tickLower];+ TickInfo storage upper = self.ticks[tickUpper];+ int24 tickCurrent = self.slot0.tick();++ unchecked {+ if (tickCurrent < tickLower) {+ feeGrowthInside0X128 = lower.feeGrowthOutside0X128 - upper.feeGrowthOutside0X128;+ feeGrowthInside1X128 = lower.feeGrowthOutside1X128 - upper.feeGrowthOutside1X128;+ } else if (tickCurrent >= tickUpper) {+ feeGrowthInside0X128 = upper.feeGrowthOutside0X128 - lower.feeGrowthOutside0X128;+ feeGrowthInside1X128 = upper.feeGrowthOutside1X128 - lower.feeGrowthOutside1X128;+ } else {+ feeGrowthInside0X128 =+ self.feeGrowthGlobal0X128 - lower.feeGrowthOutside0X128 - upper.feeGrowthOutside0X128;+ feeGrowthInside1X128 =+ self.feeGrowthGlobal1X128 - lower.feeGrowthOutside1X128 - upper.feeGrowthOutside1X128;+ }+ }+ }++ /// @notice Updates a tick and returns true if the tick was flipped from initialized to uninitialized, or vice versa+ /// @param self The mapping containing all tick information for initialized ticks+ /// @param tick The tick that will be updated+ /// @param liquidityDelta A new amount of liquidity to be added (subtracted) when tick is crossed from left to right (right to left)+ /// @param upper true for updating a position's upper tick, or false for updating a position's lower tick+ /// @return flipped Whether the tick was flipped from initialized to uninitialized, or vice versa+ /// @return liquidityGrossAfter The total amount of liquidity for all positions that references the tick after the update+ function updateTick(State storage self, int24 tick, int128 liquidityDelta, bool upper)+ internal+ returns (bool flipped, uint128 liquidityGrossAfter)+ {+ TickInfo storage info = self.ticks[tick];++ uint128 liquidityGrossBefore = info.liquidityGross;+ int128 liquidityNetBefore = info.liquidityNet;++ liquidityGrossAfter = LiquidityMath.addDelta(liquidityGrossBefore, liquidityDelta);++ flipped = (liquidityGrossAfter == 0) != (liquidityGrossBefore == 0);++ if (liquidityGrossBefore == 0) {+ // by convention, we assume that all growth before a tick was initialized happened _below_ the tick+ if (tick <= self.slot0.tick()) {+ info.feeGrowthOutside0X128 = self.feeGrowthGlobal0X128;+ info.feeGrowthOutside1X128 = self.feeGrowthGlobal1X128;+ }+ }++ // when the lower (upper) tick is crossed left to right, liquidity must be added (removed)+ // when the lower (upper) tick is crossed right to left, liquidity must be removed (added)+ int128 liquidityNet = upper ? liquidityNetBefore - liquidityDelta : liquidityNetBefore + liquidityDelta;+ assembly ("memory-safe") {+ // liquidityGrossAfter and liquidityNet are packed in the first slot of `info`+ // So we can store them with a single sstore by packing them ourselves first+ sstore(+ info.slot,+ // bitwise OR to pack liquidityGrossAfter and liquidityNet+ or(+ // Put liquidityGrossAfter in the lower bits, clearing out the upper bits+ and(liquidityGrossAfter, 0xffffffffffffffffffffffffffffffff),+ // Shift liquidityNet to put it in the upper bits (no need for signextend since we're shifting left)+ shl(128, liquidityNet)+ )+ )+ }+ }++ /// @notice Derives max liquidity per tick from given tick spacing+ /// @dev Executed when adding liquidity+ /// @param tickSpacing The amount of required tick separation, realized in multiples of `tickSpacing`+ /// e.g., a tickSpacing of 3 requires ticks to be initialized every 3rd tick i.e., ..., -6, -3, 0, 3, 6, ...+ /// @return result The max liquidity per tick+ function tickSpacingToMaxLiquidityPerTick(int24 tickSpacing) internal pure returns (uint128 result) {+ // Equivalent to:+ // int24 minTick = (TickMath.MIN_TICK / tickSpacing);+ // if (TickMath.MIN_TICK % tickSpacing != 0) minTick--;+ // int24 maxTick = (TickMath.MAX_TICK / tickSpacing);+ // uint24 numTicks = maxTick - minTick + 1;+ // return type(uint128).max / numTicks;+ int24 MAX_TICK = TickMath.MAX_TICK;+ int24 MIN_TICK = TickMath.MIN_TICK;+ // tick spacing will never be 0 since TickMath.MIN_TICK_SPACING is 1+ assembly ("memory-safe") {+ tickSpacing := signextend(2, tickSpacing)+ let minTick := sub(sdiv(MIN_TICK, tickSpacing), slt(smod(MIN_TICK, tickSpacing), 0))+ let maxTick := sdiv(MAX_TICK, tickSpacing)+ let numTicks := add(sub(maxTick, minTick), 1)+ result := div(sub(shl(128, 1), 1), numTicks)+ }+ }++ /// @notice Reverts if the given pool has not been initialized+ function checkPoolInitialized(State storage self) internal view {+ if (self.slot0.sqrtPriceX96() == 0) PoolNotInitialized.selector.revertWith();+ }++ /// @notice Clears tick data+ /// @param self The mapping containing all initialized tick information for initialized ticks+ /// @param tick The tick that will be cleared+ function clearTick(State storage self, int24 tick) internal {+ delete self.ticks[tick];+ }++ /// @notice Transitions to next tick as needed by price movement+ /// @param self The Pool state struct+ /// @param tick The destination tick of the transition+ /// @param feeGrowthGlobal0X128 The all-time global fee growth, per unit of liquidity, in token0+ /// @param feeGrowthGlobal1X128 The all-time global fee growth, per unit of liquidity, in token1+ /// @return liquidityNet The amount of liquidity added (subtracted) when tick is crossed from left to right (right to left)+ function crossTick(State storage self, int24 tick, uint256 feeGrowthGlobal0X128, uint256 feeGrowthGlobal1X128)+ internal+ returns (int128 liquidityNet)+ {+ unchecked {+ TickInfo storage info = self.ticks[tick];+ info.feeGrowthOutside0X128 = feeGrowthGlobal0X128 - info.feeGrowthOutside0X128;+ info.feeGrowthOutside1X128 = feeGrowthGlobal1X128 - info.feeGrowthOutside1X128;+ liquidityNet = info.liquidityNet;+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/Position.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/Position.solnew file mode 100644index 000000000..40821ae31--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/Position.sol@@ -0,0 +1,103 @@+// SPDX-License-Identifier: BUSL-1.1+pragma solidity ^0.8.0;++import {FullMath} from "./FullMath.sol";+import {FixedPoint128} from "./FixedPoint128.sol";+import {LiquidityMath} from "./LiquidityMath.sol";+import {CustomRevert} from "./CustomRevert.sol";++/// @title Position+/// @notice Positions represent an owner address' liquidity between a lower and upper tick boundary+/// @dev Positions store additional state for tracking fees owed to the position+library Position {+ using CustomRevert for bytes4;++ /// @notice Cannot update a position with no liquidity+ error CannotUpdateEmptyPosition();++ // info stored for each user's position+ struct State {+ // the amount of liquidity owned by this position+ uint128 liquidity;+ // fee growth per unit of liquidity as of the last update to liquidity or fees owed+ uint256 feeGrowthInside0LastX128;+ uint256 feeGrowthInside1LastX128;+ }++ /// @notice Returns the State struct of a position, given an owner and position boundaries+ /// @param self The mapping containing all user positions+ /// @param owner The address of the position owner+ /// @param tickLower The lower tick boundary of the position+ /// @param tickUpper The upper tick boundary of the position+ /// @param salt A unique value to differentiate between multiple positions in the same range+ /// @return position The position info struct of the given owners' position+ function get(mapping(bytes32 => State) storage self, address owner, int24 tickLower, int24 tickUpper, bytes32 salt)+ internal+ view+ returns (State storage position)+ {+ bytes32 positionKey = calculatePositionKey(owner, tickLower, tickUpper, salt);+ position = self[positionKey];+ }++ /// @notice A helper function to calculate the position key+ /// @param owner The address of the position owner+ /// @param tickLower the lower tick boundary of the position+ /// @param tickUpper the upper tick boundary of the position+ /// @param salt A unique value to differentiate between multiple positions in the same range, by the same owner. Passed in by the caller.+ function calculatePositionKey(address owner, int24 tickLower, int24 tickUpper, bytes32 salt)+ internal+ pure+ returns (bytes32 positionKey)+ {+ // positionKey = keccak256(abi.encodePacked(owner, tickLower, tickUpper, salt))+ assembly ("memory-safe") {+ let fmp := mload(0x40)+ mstore(add(fmp, 0x26), salt) // [0x26, 0x46)+ mstore(add(fmp, 0x06), tickUpper) // [0x23, 0x26)+ mstore(add(fmp, 0x03), tickLower) // [0x20, 0x23)+ mstore(fmp, owner) // [0x0c, 0x20)+ positionKey := keccak256(add(fmp, 0x0c), 0x3a) // len is 58 bytes++ // now clean the memory we used+ mstore(add(fmp, 0x40), 0) // fmp+0x40 held salt+ mstore(add(fmp, 0x20), 0) // fmp+0x20 held tickLower, tickUpper, salt+ mstore(fmp, 0) // fmp held owner+ }+ }++ /// @notice Credits accumulated fees to a user's position+ /// @param self The individual position to update+ /// @param liquidityDelta The change in pool liquidity as a result of the position update+ /// @param feeGrowthInside0X128 The all-time fee growth in currency0, per unit of liquidity, inside the position's tick boundaries+ /// @param feeGrowthInside1X128 The all-time fee growth in currency1, per unit of liquidity, inside the position's tick boundaries+ /// @return feesOwed0 The amount of currency0 owed to the position owner+ /// @return feesOwed1 The amount of currency1 owed to the position owner+ function update(+ State storage self,+ int128 liquidityDelta,+ uint256 feeGrowthInside0X128,+ uint256 feeGrowthInside1X128+ ) internal returns (uint256 feesOwed0, uint256 feesOwed1) {+ uint128 liquidity = self.liquidity;++ if (liquidityDelta == 0) {+ // disallow pokes for 0 liquidity positions+ if (liquidity == 0) CannotUpdateEmptyPosition.selector.revertWith();+ } else {+ self.liquidity = LiquidityMath.addDelta(liquidity, liquidityDelta);+ }++ // calculate accumulated fees. overflow in the subtraction of fee growth is expected+ unchecked {+ feesOwed0 =+ FullMath.mulDiv(feeGrowthInside0X128 - self.feeGrowthInside0LastX128, liquidity, FixedPoint128.Q128);+ feesOwed1 =+ FullMath.mulDiv(feeGrowthInside1X128 - self.feeGrowthInside1LastX128, liquidity, FixedPoint128.Q128);+ }++ // update the position+ self.feeGrowthInside0LastX128 = feeGrowthInside0X128;+ self.feeGrowthInside1LastX128 = feeGrowthInside1X128;+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/ProtocolFeeLibrary.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/ProtocolFeeLibrary.solnew file mode 100644index 000000000..c155b86aa--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/ProtocolFeeLibrary.sol@@ -0,0 +1,47 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @notice library of functions related to protocol fees+library ProtocolFeeLibrary {+ /// @notice Max protocol fee is 0.1% (1000 pips)+ /// @dev Increasing these values could lead to overflow in Pool.swap+ uint16 public constant MAX_PROTOCOL_FEE = 1000;++ /// @notice Thresholds used for optimized bounds checks on protocol fees+ uint24 internal constant FEE_0_THRESHOLD = 1001;+ uint24 internal constant FEE_1_THRESHOLD = 1001 << 12;++ /// @notice the protocol fee is represented in hundredths of a bip+ uint256 internal constant PIPS_DENOMINATOR = 1_000_000;++ function getZeroForOneFee(uint24 self) internal pure returns (uint16) {+ return uint16(self & 0xfff);+ }++ function getOneForZeroFee(uint24 self) internal pure returns (uint16) {+ return uint16(self >> 12);+ }++ function isValidProtocolFee(uint24 self) internal pure returns (bool valid) {+ // Equivalent to: getZeroForOneFee(self) <= MAX_PROTOCOL_FEE && getOneForZeroFee(self) <= MAX_PROTOCOL_FEE+ assembly ("memory-safe") {+ let isZeroForOneFeeOk := lt(and(self, 0xfff), FEE_0_THRESHOLD)+ let isOneForZeroFeeOk := lt(and(self, 0xfff000), FEE_1_THRESHOLD)+ valid := and(isZeroForOneFeeOk, isOneForZeroFeeOk)+ }+ }++ // The protocol fee is taken from the input amount first and then the LP fee is taken from the remaining+ // The swap fee is capped at 100%+ // Equivalent to protocolFee + lpFee(1_000_000 - protocolFee) / 1_000_000 (rounded up)+ /// @dev here `self` is just a single direction's protocol fee, not a packed type of 2 protocol fees+ function calculateSwapFee(uint16 self, uint24 lpFee) internal pure returns (uint24 swapFee) {+ // protocolFee + lpFee - (protocolFee * lpFee / 1_000_000)+ assembly ("memory-safe") {+ self := and(self, 0xfff)+ lpFee := and(lpFee, 0xffffff)+ let numerator := mul(self, lpFee)+ swapFee := sub(add(self, lpFee), div(numerator, PIPS_DENOMINATOR))+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/SafeCast.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/SafeCast.solnew file mode 100644index 000000000..118b02cd1--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/SafeCast.sol@@ -0,0 +1,60 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {CustomRevert} from "./CustomRevert.sol";++/// @title Safe casting methods+/// @notice Contains methods for safely casting between types+library SafeCast {+ using CustomRevert for bytes4;++ error SafeCastOverflow();++ /// @notice Cast a uint256 to a uint160, revert on overflow+ /// @param x The uint256 to be downcasted+ /// @return y The downcasted integer, now type uint160+ function toUint160(uint256 x) internal pure returns (uint160 y) {+ y = uint160(x);+ if (y != x) SafeCastOverflow.selector.revertWith();+ }++ /// @notice Cast a uint256 to a uint128, revert on overflow+ /// @param x The uint256 to be downcasted+ /// @return y The downcasted integer, now type uint128+ function toUint128(uint256 x) internal pure returns (uint128 y) {+ y = uint128(x);+ if (x != y) SafeCastOverflow.selector.revertWith();+ }++ /// @notice Cast a int128 to a uint128, revert on overflow or underflow+ /// @param x The int128 to be casted+ /// @return y The casted integer, now type uint128+ function toUint128(int128 x) internal pure returns (uint128 y) {+ if (x < 0) SafeCastOverflow.selector.revertWith();+ y = uint128(x);+ }++ /// @notice Cast a int256 to a int128, revert on overflow or underflow+ /// @param x The int256 to be downcasted+ /// @return y The downcasted integer, now type int128+ function toInt128(int256 x) internal pure returns (int128 y) {+ y = int128(x);+ if (y != x) SafeCastOverflow.selector.revertWith();+ }++ /// @notice Cast a uint256 to a int256, revert on overflow+ /// @param x The uint256 to be casted+ /// @return y The casted integer, now type int256+ function toInt256(uint256 x) internal pure returns (int256 y) {+ y = int256(x);+ if (y < 0) SafeCastOverflow.selector.revertWith();+ }++ /// @notice Cast a uint256 to a int128, revert on overflow+ /// @param x The uint256 to be downcasted+ /// @return The downcasted integer, now type int128+ function toInt128(uint256 x) internal pure returns (int128) {+ if (x >= 1 << 127) SafeCastOverflow.selector.revertWith();+ return int128(int256(x));+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/SqrtPriceMath.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/SqrtPriceMath.solnew file mode 100644index 000000000..0b706ba13--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/SqrtPriceMath.sol@@ -0,0 +1,289 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {SafeCast} from "./SafeCast.sol";++import {FullMath} from "./FullMath.sol";+import {UnsafeMath} from "./UnsafeMath.sol";+import {FixedPoint96} from "./FixedPoint96.sol";++/// @title Functions based on Q64.96 sqrt price and liquidity+/// @notice Contains the math that uses square root of price as a Q64.96 and liquidity to compute deltas+library SqrtPriceMath {+ using SafeCast for uint256;++ error InvalidPriceOrLiquidity();+ error InvalidPrice();+ error NotEnoughLiquidity();+ error PriceOverflow();++ /// @notice Gets the next sqrt price given a delta of currency0+ /// @dev Always rounds up, because in the exact output case (increasing price) we need to move the price at least+ /// far enough to get the desired output amount, and in the exact input case (decreasing price) we need to move the+ /// price less in order to not send too much output.+ /// The most precise formula for this is liquidity * sqrtPX96 / (liquidity +- amount * sqrtPX96),+ /// if this is impossible because of overflow, we calculate liquidity / (liquidity / sqrtPX96 +- amount).+ /// @param sqrtPX96 The starting price, i.e. before accounting for the currency0 delta+ /// @param liquidity The amount of usable liquidity+ /// @param amount How much of currency0 to add or remove from virtual reserves+ /// @param add Whether to add or remove the amount of currency0+ /// @return The price after adding or removing amount, depending on add+ function getNextSqrtPriceFromAmount0RoundingUp(uint160 sqrtPX96, uint128 liquidity, uint256 amount, bool add)+ internal+ pure+ returns (uint160)+ {+ // we short circuit amount == 0 because the result is otherwise not guaranteed to equal the input price+ if (amount == 0) return sqrtPX96;+ uint256 numerator1 = uint256(liquidity) << FixedPoint96.RESOLUTION;++ if (add) {+ unchecked {+ uint256 product = amount * sqrtPX96;+ if (product / amount == sqrtPX96) {+ uint256 denominator = numerator1 + product;+ if (denominator >= numerator1) {+ // always fits in 160 bits+ return uint160(FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator));+ }+ }+ }+ // denominator is checked for overflow+ return uint160(UnsafeMath.divRoundingUp(numerator1, (numerator1 / sqrtPX96) + amount));+ } else {+ unchecked {+ uint256 product = amount * sqrtPX96;+ // if the product overflows, we know the denominator underflows+ // in addition, we must check that the denominator does not underflow+ // equivalent: if (product / amount != sqrtPX96 || numerator1 <= product) revert PriceOverflow();+ assembly ("memory-safe") {+ if iszero(+ and(+ eq(div(product, amount), and(sqrtPX96, 0xffffffffffffffffffffffffffffffffffffffff)),+ gt(numerator1, product)+ )+ ) {+ mstore(0, 0xf5c787f1) // selector for PriceOverflow()+ revert(0x1c, 0x04)+ }+ }+ uint256 denominator = numerator1 - product;+ return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator).toUint160();+ }+ }+ }++ /// @notice Gets the next sqrt price given a delta of currency1+ /// @dev Always rounds down, because in the exact output case (decreasing price) we need to move the price at least+ /// far enough to get the desired output amount, and in the exact input case (increasing price) we need to move the+ /// price less in order to not send too much output.+ /// The formula we compute is within <1 wei of the lossless version: sqrtPX96 +- amount / liquidity+ /// @param sqrtPX96 The starting price, i.e., before accounting for the currency1 delta+ /// @param liquidity The amount of usable liquidity+ /// @param amount How much of currency1 to add, or remove, from virtual reserves+ /// @param add Whether to add, or remove, the amount of currency1+ /// @return The price after adding or removing `amount`+ function getNextSqrtPriceFromAmount1RoundingDown(uint160 sqrtPX96, uint128 liquidity, uint256 amount, bool add)+ internal+ pure+ returns (uint160)+ {+ // if we're adding (subtracting), rounding down requires rounding the quotient down (up)+ // in both cases, avoid a mulDiv for most inputs+ if (add) {+ uint256 quotient = (+ amount <= type(uint160).max+ ? (amount << FixedPoint96.RESOLUTION) / liquidity+ : FullMath.mulDiv(amount, FixedPoint96.Q96, liquidity)+ );++ return (uint256(sqrtPX96) + quotient).toUint160();+ } else {+ uint256 quotient = (+ amount <= type(uint160).max+ ? UnsafeMath.divRoundingUp(amount << FixedPoint96.RESOLUTION, liquidity)+ : FullMath.mulDivRoundingUp(amount, FixedPoint96.Q96, liquidity)+ );++ // equivalent: if (sqrtPX96 <= quotient) revert NotEnoughLiquidity();+ assembly ("memory-safe") {+ if iszero(gt(and(sqrtPX96, 0xffffffffffffffffffffffffffffffffffffffff), quotient)) {+ mstore(0, 0x4323a555) // selector for NotEnoughLiquidity()+ revert(0x1c, 0x04)+ }+ }+ // always fits 160 bits+ unchecked {+ return uint160(sqrtPX96 - quotient);+ }+ }+ }++ /// @notice Gets the next sqrt price given an input amount of currency0 or currency1+ /// @dev Throws if price or liquidity are 0, or if the next price is out of bounds+ /// @param sqrtPX96 The starting price, i.e., before accounting for the input amount+ /// @param liquidity The amount of usable liquidity+ /// @param amountIn How much of currency0, or currency1, is being swapped in+ /// @param zeroForOne Whether the amount in is currency0 or currency1+ /// @return uint160 The price after adding the input amount to currency0 or currency1+ function getNextSqrtPriceFromInput(uint160 sqrtPX96, uint128 liquidity, uint256 amountIn, bool zeroForOne)+ internal+ pure+ returns (uint160)+ {+ // equivalent: if (sqrtPX96 == 0 || liquidity == 0) revert InvalidPriceOrLiquidity();+ assembly ("memory-safe") {+ if or(+ iszero(and(sqrtPX96, 0xffffffffffffffffffffffffffffffffffffffff)),+ iszero(and(liquidity, 0xffffffffffffffffffffffffffffffff))+ ) {+ mstore(0, 0x4f2461b8) // selector for InvalidPriceOrLiquidity()+ revert(0x1c, 0x04)+ }+ }++ // round to make sure that we don't pass the target price+ return zeroForOne+ ? getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountIn, true)+ : getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountIn, true);+ }++ /// @notice Gets the next sqrt price given an output amount of currency0 or currency1+ /// @dev Throws if price or liquidity are 0 or the next price is out of bounds+ /// @param sqrtPX96 The starting price before accounting for the output amount+ /// @param liquidity The amount of usable liquidity+ /// @param amountOut How much of currency0, or currency1, is being swapped out+ /// @param zeroForOne Whether the amount out is currency1 or currency0+ /// @return uint160 The price after removing the output amount of currency0 or currency1+ function getNextSqrtPriceFromOutput(uint160 sqrtPX96, uint128 liquidity, uint256 amountOut, bool zeroForOne)+ internal+ pure+ returns (uint160)+ {+ // equivalent: if (sqrtPX96 == 0 || liquidity == 0) revert InvalidPriceOrLiquidity();+ assembly ("memory-safe") {+ if or(+ iszero(and(sqrtPX96, 0xffffffffffffffffffffffffffffffffffffffff)),+ iszero(and(liquidity, 0xffffffffffffffffffffffffffffffff))+ ) {+ mstore(0, 0x4f2461b8) // selector for InvalidPriceOrLiquidity()+ revert(0x1c, 0x04)+ }+ }++ // round to make sure that we pass the target price+ return zeroForOne+ ? getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountOut, false)+ : getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountOut, false);+ }++ /// @notice Gets the amount0 delta between two prices+ /// @dev Calculates liquidity / sqrt(lower) - liquidity / sqrt(upper),+ /// i.e. liquidity * (sqrt(upper) - sqrt(lower)) / (sqrt(upper) * sqrt(lower))+ /// @param sqrtPriceAX96 A sqrt price+ /// @param sqrtPriceBX96 Another sqrt price+ /// @param liquidity The amount of usable liquidity+ /// @param roundUp Whether to round the amount up or down+ /// @return uint256 Amount of currency0 required to cover a position of size liquidity between the two passed prices+ function getAmount0Delta(uint160 sqrtPriceAX96, uint160 sqrtPriceBX96, uint128 liquidity, bool roundUp)+ internal+ pure+ returns (uint256)+ {+ unchecked {+ if (sqrtPriceAX96 > sqrtPriceBX96) (sqrtPriceAX96, sqrtPriceBX96) = (sqrtPriceBX96, sqrtPriceAX96);++ // equivalent: if (sqrtPriceAX96 == 0) revert InvalidPrice();+ assembly ("memory-safe") {+ if iszero(and(sqrtPriceAX96, 0xffffffffffffffffffffffffffffffffffffffff)) {+ mstore(0, 0x00bfc921) // selector for InvalidPrice()+ revert(0x1c, 0x04)+ }+ }++ uint256 numerator1 = uint256(liquidity) << FixedPoint96.RESOLUTION;+ uint256 numerator2 = sqrtPriceBX96 - sqrtPriceAX96;++ return roundUp+ ? UnsafeMath.divRoundingUp(FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtPriceBX96), sqrtPriceAX96)+ : FullMath.mulDiv(numerator1, numerator2, sqrtPriceBX96) / sqrtPriceAX96;+ }+ }++ /// @notice Equivalent to: `a >= b ? a - b : b - a`+ function absDiff(uint160 a, uint160 b) internal pure returns (uint256 res) {+ assembly ("memory-safe") {+ let diff :=+ sub(and(a, 0xffffffffffffffffffffffffffffffffffffffff), and(b, 0xffffffffffffffffffffffffffffffffffffffff))+ // mask = 0 if a >= b else -1 (all 1s)+ let mask := sar(255, diff)+ // if a >= b, res = a - b = 0 ^ (a - b)+ // if a < b, res = b - a = ~~(b - a) = ~(-(b - a) - 1) = ~(a - b - 1) = (-1) ^ (a - b - 1)+ // either way, res = mask ^ (a - b + mask)+ res := xor(mask, add(mask, diff))+ }+ }++ /// @notice Gets the amount1 delta between two prices+ /// @dev Calculates liquidity * (sqrt(upper) - sqrt(lower))+ /// @param sqrtPriceAX96 A sqrt price+ /// @param sqrtPriceBX96 Another sqrt price+ /// @param liquidity The amount of usable liquidity+ /// @param roundUp Whether to round the amount up, or down+ /// @return amount1 Amount of currency1 required to cover a position of size liquidity between the two passed prices+ function getAmount1Delta(uint160 sqrtPriceAX96, uint160 sqrtPriceBX96, uint128 liquidity, bool roundUp)+ internal+ pure+ returns (uint256 amount1)+ {+ uint256 numerator = absDiff(sqrtPriceAX96, sqrtPriceBX96);+ uint256 denominator = FixedPoint96.Q96;+ uint256 _liquidity = uint256(liquidity);++ /**+ * Equivalent to:+ * amount1 = roundUp+ * ? FullMath.mulDivRoundingUp(liquidity, sqrtPriceBX96 - sqrtPriceAX96, FixedPoint96.Q96)+ * : FullMath.mulDiv(liquidity, sqrtPriceBX96 - sqrtPriceAX96, FixedPoint96.Q96);+ * Cannot overflow because `type(uint128).max * type(uint160).max >> 96 < (1 << 192)`.+ */+ amount1 = FullMath.mulDiv(_liquidity, numerator, denominator);+ assembly ("memory-safe") {+ amount1 := add(amount1, and(gt(mulmod(_liquidity, numerator, denominator), 0), roundUp))+ }+ }++ /// @notice Helper that gets signed currency0 delta+ /// @param sqrtPriceAX96 A sqrt price+ /// @param sqrtPriceBX96 Another sqrt price+ /// @param liquidity The change in liquidity for which to compute the amount0 delta+ /// @return int256 Amount of currency0 corresponding to the passed liquidityDelta between the two prices+ function getAmount0Delta(uint160 sqrtPriceAX96, uint160 sqrtPriceBX96, int128 liquidity)+ internal+ pure+ returns (int256)+ {+ unchecked {+ return liquidity < 0+ ? getAmount0Delta(sqrtPriceAX96, sqrtPriceBX96, uint128(-liquidity), false).toInt256()+ : -getAmount0Delta(sqrtPriceAX96, sqrtPriceBX96, uint128(liquidity), true).toInt256();+ }+ }++ /// @notice Helper that gets signed currency1 delta+ /// @param sqrtPriceAX96 A sqrt price+ /// @param sqrtPriceBX96 Another sqrt price+ /// @param liquidity The change in liquidity for which to compute the amount1 delta+ /// @return int256 Amount of currency1 corresponding to the passed liquidityDelta between the two prices+ function getAmount1Delta(uint160 sqrtPriceAX96, uint160 sqrtPriceBX96, int128 liquidity)+ internal+ pure+ returns (int256)+ {+ unchecked {+ return liquidity < 0+ ? getAmount1Delta(sqrtPriceAX96, sqrtPriceBX96, uint128(-liquidity), false).toInt256()+ : -getAmount1Delta(sqrtPriceAX96, sqrtPriceBX96, uint128(liquidity), true).toInt256();+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/StateLibrary.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/StateLibrary.solnew file mode 100644index 000000000..a8cd62137--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/StateLibrary.sol@@ -0,0 +1,349 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {PoolId} from "../types/PoolId.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {Position} from "./Position.sol";++/// @notice A helper library to provide state getters that use extsload+library StateLibrary {+ /// @notice index of pools mapping in the PoolManager+ bytes32 public constant POOLS_SLOT = bytes32(uint256(6));++ /// @notice index of feeGrowthGlobal0X128 in Pool.State+ uint256 public constant FEE_GROWTH_GLOBAL0_OFFSET = 1;++ // feeGrowthGlobal1X128 offset in Pool.State = 2++ /// @notice index of liquidity in Pool.State+ uint256 public constant LIQUIDITY_OFFSET = 3;++ /// @notice index of TicksInfo mapping in Pool.State: mapping(int24 => TickInfo) ticks;+ uint256 public constant TICKS_OFFSET = 4;++ /// @notice index of tickBitmap mapping in Pool.State+ uint256 public constant TICK_BITMAP_OFFSET = 5;++ /// @notice index of Position.State mapping in Pool.State: mapping(bytes32 => Position.State) positions;+ uint256 public constant POSITIONS_OFFSET = 6;++ /**+ * @notice Get Slot0 of the pool: sqrtPriceX96, tick, protocolFee, lpFee+ * @dev Corresponds to pools[poolId].slot0+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @return sqrtPriceX96 The square root of the price of the pool, in Q96 precision.+ * @return tick The current tick of the pool.+ * @return protocolFee The protocol fee of the pool.+ * @return lpFee The swap fee of the pool.+ */+ function getSlot0(IPoolManager manager, PoolId poolId)+ internal+ view+ returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee)+ {+ // slot key of Pool.State value: `pools[poolId]`+ bytes32 stateSlot = _getPoolStateSlot(poolId);++ bytes32 data = manager.extsload(stateSlot);++ // 24 bits |24bits|24bits |24 bits|160 bits+ // 0x000000 |000bb8|000000 |ffff75 |0000000000000000fe3aa841ba359daa0ea9eff7+ // ---------- | fee |protocolfee | tick | sqrtPriceX96+ assembly ("memory-safe") {+ // bottom 160 bits of data+ sqrtPriceX96 := and(data, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)+ // next 24 bits of data+ tick := signextend(2, shr(160, data))+ // next 24 bits of data+ protocolFee := and(shr(184, data), 0xFFFFFF)+ // last 24 bits of data+ lpFee := and(shr(208, data), 0xFFFFFF)+ }+ }++ /**+ * @notice Retrieves the tick information of a pool at a specific tick.+ * @dev Corresponds to pools[poolId].ticks[tick]+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @param tick The tick to retrieve information for.+ * @return liquidityGross The total position liquidity that references this tick+ * @return liquidityNet The amount of net liquidity added (subtracted) when tick is crossed from left to right (right to left)+ * @return feeGrowthOutside0X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick)+ * @return feeGrowthOutside1X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick)+ */+ function getTickInfo(IPoolManager manager, PoolId poolId, int24 tick)+ internal+ view+ returns (+ uint128 liquidityGross,+ int128 liquidityNet,+ uint256 feeGrowthOutside0X128,+ uint256 feeGrowthOutside1X128+ )+ {+ bytes32 slot = _getTickInfoSlot(poolId, tick);++ // read all 3 words of the TickInfo struct+ bytes32[] memory data = manager.extsload(slot, 3);+ assembly ("memory-safe") {+ let firstWord := mload(add(data, 32))+ liquidityNet := sar(128, firstWord)+ liquidityGross := and(firstWord, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)+ feeGrowthOutside0X128 := mload(add(data, 64))+ feeGrowthOutside1X128 := mload(add(data, 96))+ }+ }++ /**+ * @notice Retrieves the liquidity information of a pool at a specific tick.+ * @dev Corresponds to pools[poolId].ticks[tick].liquidityGross and pools[poolId].ticks[tick].liquidityNet. A more gas efficient version of getTickInfo+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @param tick The tick to retrieve liquidity for.+ * @return liquidityGross The total position liquidity that references this tick+ * @return liquidityNet The amount of net liquidity added (subtracted) when tick is crossed from left to right (right to left)+ */+ function getTickLiquidity(IPoolManager manager, PoolId poolId, int24 tick)+ internal+ view+ returns (uint128 liquidityGross, int128 liquidityNet)+ {+ bytes32 slot = _getTickInfoSlot(poolId, tick);++ bytes32 value = manager.extsload(slot);+ assembly ("memory-safe") {+ liquidityNet := sar(128, value)+ liquidityGross := and(value, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)+ }+ }++ /**+ * @notice Retrieves the fee growth outside a tick range of a pool+ * @dev Corresponds to pools[poolId].ticks[tick].feeGrowthOutside0X128 and pools[poolId].ticks[tick].feeGrowthOutside1X128. A more gas efficient version of getTickInfo+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @param tick The tick to retrieve fee growth for.+ * @return feeGrowthOutside0X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick)+ * @return feeGrowthOutside1X128 fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick)+ */+ function getTickFeeGrowthOutside(IPoolManager manager, PoolId poolId, int24 tick)+ internal+ view+ returns (uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128)+ {+ bytes32 slot = _getTickInfoSlot(poolId, tick);++ // offset by 1 word, since the first word is liquidityGross + liquidityNet+ bytes32[] memory data = manager.extsload(bytes32(uint256(slot) + 1), 2);+ assembly ("memory-safe") {+ feeGrowthOutside0X128 := mload(add(data, 32))+ feeGrowthOutside1X128 := mload(add(data, 64))+ }+ }++ /**+ * @notice Retrieves the global fee growth of a pool.+ * @dev Corresponds to pools[poolId].feeGrowthGlobal0X128 and pools[poolId].feeGrowthGlobal1X128+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @return feeGrowthGlobal0 The global fee growth for token0.+ * @return feeGrowthGlobal1 The global fee growth for token1.+ * @dev Note that feeGrowthGlobal can be artificially inflated+ * For pools with a single liquidity position, actors can donate to themselves to freely inflate feeGrowthGlobal+ * atomically donating and collecting fees in the same unlockCallback may make the inflated value more extreme+ */+ function getFeeGrowthGlobals(IPoolManager manager, PoolId poolId)+ internal+ view+ returns (uint256 feeGrowthGlobal0, uint256 feeGrowthGlobal1)+ {+ // slot key of Pool.State value: `pools[poolId]`+ bytes32 stateSlot = _getPoolStateSlot(poolId);++ // Pool.State, `uint256 feeGrowthGlobal0X128`+ bytes32 slot_feeGrowthGlobal0X128 = bytes32(uint256(stateSlot) + FEE_GROWTH_GLOBAL0_OFFSET);++ // read the 2 words of feeGrowthGlobal+ bytes32[] memory data = manager.extsload(slot_feeGrowthGlobal0X128, 2);+ assembly ("memory-safe") {+ feeGrowthGlobal0 := mload(add(data, 32))+ feeGrowthGlobal1 := mload(add(data, 64))+ }+ }++ /**+ * @notice Retrieves total the liquidity of a pool.+ * @dev Corresponds to pools[poolId].liquidity+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @return liquidity The liquidity of the pool.+ */+ function getLiquidity(IPoolManager manager, PoolId poolId) internal view returns (uint128 liquidity) {+ // slot key of Pool.State value: `pools[poolId]`+ bytes32 stateSlot = _getPoolStateSlot(poolId);++ // Pool.State: `uint128 liquidity`+ bytes32 slot = bytes32(uint256(stateSlot) + LIQUIDITY_OFFSET);++ liquidity = uint128(uint256(manager.extsload(slot)));+ }++ /**+ * @notice Retrieves the tick bitmap of a pool at a specific tick.+ * @dev Corresponds to pools[poolId].tickBitmap[tick]+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @param tick The tick to retrieve the bitmap for.+ * @return tickBitmap The bitmap of the tick.+ */+ function getTickBitmap(IPoolManager manager, PoolId poolId, int16 tick)+ internal+ view+ returns (uint256 tickBitmap)+ {+ // slot key of Pool.State value: `pools[poolId]`+ bytes32 stateSlot = _getPoolStateSlot(poolId);++ // Pool.State: `mapping(int16 => uint256) tickBitmap;`+ bytes32 tickBitmapMapping = bytes32(uint256(stateSlot) + TICK_BITMAP_OFFSET);++ // slot id of the mapping key: `pools[poolId].tickBitmap[tick]+ bytes32 slot = keccak256(abi.encodePacked(int256(tick), tickBitmapMapping));++ tickBitmap = uint256(manager.extsload(slot));+ }++ /**+ * @notice Retrieves the position information of a pool without needing to calculate the `positionId`.+ * @dev Corresponds to pools[poolId].positions[positionId]+ * @param poolId The ID of the pool.+ * @param owner The owner of the liquidity position.+ * @param tickLower The lower tick of the liquidity range.+ * @param tickUpper The upper tick of the liquidity range.+ * @param salt The bytes32 randomness to further distinguish position state.+ * @return liquidity The liquidity of the position.+ * @return feeGrowthInside0LastX128 The fee growth inside the position for token0.+ * @return feeGrowthInside1LastX128 The fee growth inside the position for token1.+ */+ function getPositionInfo(+ IPoolManager manager,+ PoolId poolId,+ address owner,+ int24 tickLower,+ int24 tickUpper,+ bytes32 salt+ ) internal view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128) {+ // positionKey = keccak256(abi.encodePacked(owner, tickLower, tickUpper, salt))+ bytes32 positionKey = Position.calculatePositionKey(owner, tickLower, tickUpper, salt);++ (liquidity, feeGrowthInside0LastX128, feeGrowthInside1LastX128) = getPositionInfo(manager, poolId, positionKey);+ }++ /**+ * @notice Retrieves the position information of a pool at a specific position ID.+ * @dev Corresponds to pools[poolId].positions[positionId]+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @param positionId The ID of the position.+ * @return liquidity The liquidity of the position.+ * @return feeGrowthInside0LastX128 The fee growth inside the position for token0.+ * @return feeGrowthInside1LastX128 The fee growth inside the position for token1.+ */+ function getPositionInfo(IPoolManager manager, PoolId poolId, bytes32 positionId)+ internal+ view+ returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128)+ {+ bytes32 slot = _getPositionInfoSlot(poolId, positionId);++ // read all 3 words of the Position.State struct+ bytes32[] memory data = manager.extsload(slot, 3);++ assembly ("memory-safe") {+ liquidity := mload(add(data, 32))+ feeGrowthInside0LastX128 := mload(add(data, 64))+ feeGrowthInside1LastX128 := mload(add(data, 96))+ }+ }++ /**+ * @notice Retrieves the liquidity of a position.+ * @dev Corresponds to pools[poolId].positions[positionId].liquidity. More gas efficient for just retrieiving liquidity as compared to getPositionInfo+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @param positionId The ID of the position.+ * @return liquidity The liquidity of the position.+ */+ function getPositionLiquidity(IPoolManager manager, PoolId poolId, bytes32 positionId)+ internal+ view+ returns (uint128 liquidity)+ {+ bytes32 slot = _getPositionInfoSlot(poolId, positionId);+ liquidity = uint128(uint256(manager.extsload(slot)));+ }++ /**+ * @notice Calculate the fee growth inside a tick range of a pool+ * @dev pools[poolId].feeGrowthInside0LastX128 in Position.State is cached and can become stale. This function will calculate the up to date feeGrowthInside+ * @param manager The pool manager contract.+ * @param poolId The ID of the pool.+ * @param tickLower The lower tick of the range.+ * @param tickUpper The upper tick of the range.+ * @return feeGrowthInside0X128 The fee growth inside the tick range for token0.+ * @return feeGrowthInside1X128 The fee growth inside the tick range for token1.+ */+ function getFeeGrowthInside(IPoolManager manager, PoolId poolId, int24 tickLower, int24 tickUpper)+ internal+ view+ returns (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128)+ {+ (uint256 feeGrowthGlobal0X128, uint256 feeGrowthGlobal1X128) = getFeeGrowthGlobals(manager, poolId);++ (uint256 lowerFeeGrowthOutside0X128, uint256 lowerFeeGrowthOutside1X128) =+ getTickFeeGrowthOutside(manager, poolId, tickLower);+ (uint256 upperFeeGrowthOutside0X128, uint256 upperFeeGrowthOutside1X128) =+ getTickFeeGrowthOutside(manager, poolId, tickUpper);+ (, int24 tickCurrent,,) = getSlot0(manager, poolId);+ unchecked {+ if (tickCurrent < tickLower) {+ feeGrowthInside0X128 = lowerFeeGrowthOutside0X128 - upperFeeGrowthOutside0X128;+ feeGrowthInside1X128 = lowerFeeGrowthOutside1X128 - upperFeeGrowthOutside1X128;+ } else if (tickCurrent >= tickUpper) {+ feeGrowthInside0X128 = upperFeeGrowthOutside0X128 - lowerFeeGrowthOutside0X128;+ feeGrowthInside1X128 = upperFeeGrowthOutside1X128 - lowerFeeGrowthOutside1X128;+ } else {+ feeGrowthInside0X128 = feeGrowthGlobal0X128 - lowerFeeGrowthOutside0X128 - upperFeeGrowthOutside0X128;+ feeGrowthInside1X128 = feeGrowthGlobal1X128 - lowerFeeGrowthOutside1X128 - upperFeeGrowthOutside1X128;+ }+ }+ }++ function _getPoolStateSlot(PoolId poolId) internal pure returns (bytes32) {+ return keccak256(abi.encodePacked(PoolId.unwrap(poolId), POOLS_SLOT));+ }++ function _getTickInfoSlot(PoolId poolId, int24 tick) internal pure returns (bytes32) {+ // slot key of Pool.State value: `pools[poolId]`+ bytes32 stateSlot = _getPoolStateSlot(poolId);++ // Pool.State: `mapping(int24 => TickInfo) ticks`+ bytes32 ticksMappingSlot = bytes32(uint256(stateSlot) + TICKS_OFFSET);++ // slot key of the tick key: `pools[poolId].ticks[tick]+ return keccak256(abi.encodePacked(int256(tick), ticksMappingSlot));+ }++ function _getPositionInfoSlot(PoolId poolId, bytes32 positionId) internal pure returns (bytes32) {+ // slot key of Pool.State value: `pools[poolId]`+ bytes32 stateSlot = _getPoolStateSlot(poolId);++ // Pool.State: `mapping(bytes32 => Position.State) positions;`+ bytes32 positionMapping = bytes32(uint256(stateSlot) + POSITIONS_OFFSET);++ // slot of the mapping key: `pools[poolId].positions[positionId]+ return keccak256(abi.encodePacked(positionId, positionMapping));+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/SwapMath.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/SwapMath.solnew file mode 100644index 000000000..92599e5d3--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/SwapMath.sol@@ -0,0 +1,108 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {FullMath} from "./FullMath.sol";+import {SqrtPriceMath} from "./SqrtPriceMath.sol";++/// @title Computes the result of a swap within ticks+/// @notice Contains methods for computing the result of a swap within a single tick price range, i.e., a single tick.+library SwapMath {+ /// @notice the swap fee is represented in hundredths of a bip, so the max is 100%+ /// @dev the swap fee is the total fee on a swap, including both LP and Protocol fee+ uint256 internal constant MAX_SWAP_FEE = 1e6;++ /// @notice Computes the sqrt price target for the next swap step+ /// @param zeroForOne The direction of the swap, true for currency0 to currency1, false for currency1 to currency0+ /// @param sqrtPriceNextX96 The Q64.96 sqrt price for the next initialized tick+ /// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value+ /// after the swap. If one for zero, the price cannot be greater than this value after the swap+ /// @return sqrtPriceTargetX96 The price target for the next swap step+ function getSqrtPriceTarget(bool zeroForOne, uint160 sqrtPriceNextX96, uint160 sqrtPriceLimitX96)+ internal+ pure+ returns (uint160 sqrtPriceTargetX96)+ {+ assembly ("memory-safe") {+ // a flag to toggle between sqrtPriceNextX96 and sqrtPriceLimitX96+ // when zeroForOne == true, nextOrLimit reduces to sqrtPriceNextX96 >= sqrtPriceLimitX96+ // sqrtPriceTargetX96 = max(sqrtPriceNextX96, sqrtPriceLimitX96)+ // when zeroForOne == false, nextOrLimit reduces to sqrtPriceNextX96 < sqrtPriceLimitX96+ // sqrtPriceTargetX96 = min(sqrtPriceNextX96, sqrtPriceLimitX96)+ sqrtPriceNextX96 := and(sqrtPriceNextX96, 0xffffffffffffffffffffffffffffffffffffffff)+ sqrtPriceLimitX96 := and(sqrtPriceLimitX96, 0xffffffffffffffffffffffffffffffffffffffff)+ let nextOrLimit := xor(lt(sqrtPriceNextX96, sqrtPriceLimitX96), and(zeroForOne, 0x1))+ let symDiff := xor(sqrtPriceNextX96, sqrtPriceLimitX96)+ sqrtPriceTargetX96 := xor(sqrtPriceLimitX96, mul(symDiff, nextOrLimit))+ }+ }++ /// @notice Computes the result of swapping some amount in, or amount out, given the parameters of the swap+ /// @dev If the swap's amountSpecified is negative, the combined fee and input amount will never exceed the absolute value of the remaining amount.+ /// @param sqrtPriceCurrentX96 The current sqrt price of the pool+ /// @param sqrtPriceTargetX96 The price that cannot be exceeded, from which the direction of the swap is inferred+ /// @param liquidity The usable liquidity+ /// @param amountRemaining How much input or output amount is remaining to be swapped in/out+ /// @param feePips The fee taken from the input amount, expressed in hundredths of a bip+ /// @return sqrtPriceNextX96 The price after swapping the amount in/out, not to exceed the price target+ /// @return amountIn The amount to be swapped in, of either currency0 or currency1, based on the direction of the swap+ /// @return amountOut The amount to be received, of either currency0 or currency1, based on the direction of the swap+ /// @return feeAmount The amount of input that will be taken as a fee+ /// @dev feePips must be no larger than MAX_SWAP_FEE for this function. We ensure that before setting a fee using LPFeeLibrary.isValid.+ function computeSwapStep(+ uint160 sqrtPriceCurrentX96,+ uint160 sqrtPriceTargetX96,+ uint128 liquidity,+ int256 amountRemaining,+ uint24 feePips+ ) internal pure returns (uint160 sqrtPriceNextX96, uint256 amountIn, uint256 amountOut, uint256 feeAmount) {+ unchecked {+ uint256 _feePips = feePips; // upcast once and cache+ bool zeroForOne = sqrtPriceCurrentX96 >= sqrtPriceTargetX96;+ bool exactIn = amountRemaining < 0;++ if (exactIn) {+ uint256 amountRemainingLessFee =+ FullMath.mulDiv(uint256(-amountRemaining), MAX_SWAP_FEE - _feePips, MAX_SWAP_FEE);+ amountIn = zeroForOne+ ? SqrtPriceMath.getAmount0Delta(sqrtPriceTargetX96, sqrtPriceCurrentX96, liquidity, true)+ : SqrtPriceMath.getAmount1Delta(sqrtPriceCurrentX96, sqrtPriceTargetX96, liquidity, true);+ if (amountRemainingLessFee >= amountIn) {+ // `amountIn` is capped by the target price+ sqrtPriceNextX96 = sqrtPriceTargetX96;+ feeAmount = _feePips == MAX_SWAP_FEE+ ? amountIn // amountIn is always 0 here, as amountRemainingLessFee == 0 and amountRemainingLessFee >= amountIn+ : FullMath.mulDivRoundingUp(amountIn, _feePips, MAX_SWAP_FEE - _feePips);+ } else {+ // exhaust the remaining amount+ amountIn = amountRemainingLessFee;+ sqrtPriceNextX96 = SqrtPriceMath.getNextSqrtPriceFromInput(+ sqrtPriceCurrentX96, liquidity, amountRemainingLessFee, zeroForOne+ );+ // we didn't reach the target, so take the remainder of the maximum input as fee+ feeAmount = uint256(-amountRemaining) - amountIn;+ }+ amountOut = zeroForOne+ ? SqrtPriceMath.getAmount1Delta(sqrtPriceNextX96, sqrtPriceCurrentX96, liquidity, false)+ : SqrtPriceMath.getAmount0Delta(sqrtPriceCurrentX96, sqrtPriceNextX96, liquidity, false);+ } else {+ amountOut = zeroForOne+ ? SqrtPriceMath.getAmount1Delta(sqrtPriceTargetX96, sqrtPriceCurrentX96, liquidity, false)+ : SqrtPriceMath.getAmount0Delta(sqrtPriceCurrentX96, sqrtPriceTargetX96, liquidity, false);+ if (uint256(amountRemaining) >= amountOut) {+ // `amountOut` is capped by the target price+ sqrtPriceNextX96 = sqrtPriceTargetX96;+ } else {+ // cap the output amount to not exceed the remaining output amount+ amountOut = uint256(amountRemaining);+ sqrtPriceNextX96 =+ SqrtPriceMath.getNextSqrtPriceFromOutput(sqrtPriceCurrentX96, liquidity, amountOut, zeroForOne);+ }+ amountIn = zeroForOne+ ? SqrtPriceMath.getAmount0Delta(sqrtPriceNextX96, sqrtPriceCurrentX96, liquidity, true)+ : SqrtPriceMath.getAmount1Delta(sqrtPriceCurrentX96, sqrtPriceNextX96, liquidity, true);+ // `feePips` cannot be `MAX_SWAP_FEE` for exact out+ feeAmount = FullMath.mulDivRoundingUp(amountIn, _feePips, MAX_SWAP_FEE - _feePips);+ }+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/TickBitmap.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/TickBitmap.solnew file mode 100644index 000000000..15104a199--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/TickBitmap.sol@@ -0,0 +1,122 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {BitMath} from "./BitMath.sol";++/// @title Packed tick initialized state library+/// @notice Stores a packed mapping of tick index to its initialized state+/// @dev The mapping uses int16 for keys since ticks are represented as int24 and there are 256 (2^8) values per word.+library TickBitmap {+ /// @notice Thrown when the tick is not enumerated by the tick spacing+ /// @param tick the invalid tick+ /// @param tickSpacing The tick spacing of the pool+ error TickMisaligned(int24 tick, int24 tickSpacing);++ /// @dev round towards negative infinity+ function compress(int24 tick, int24 tickSpacing) internal pure returns (int24 compressed) {+ // compressed = tick / tickSpacing;+ // if (tick < 0 && tick % tickSpacing != 0) compressed--;+ assembly ("memory-safe") {+ tick := signextend(2, tick)+ tickSpacing := signextend(2, tickSpacing)+ compressed :=+ sub(+ sdiv(tick, tickSpacing),+ // if (tick < 0 && tick % tickSpacing != 0) then tick % tickSpacing < 0, vice versa+ slt(smod(tick, tickSpacing), 0)+ )+ }+ }++ /// @notice Computes the position in the mapping where the initialized bit for a tick lives+ /// @param tick The tick for which to compute the position+ /// @return wordPos The key in the mapping containing the word in which the bit is stored+ /// @return bitPos The bit position in the word where the flag is stored+ function position(int24 tick) internal pure returns (int16 wordPos, uint8 bitPos) {+ assembly ("memory-safe") {+ // signed arithmetic shift right+ wordPos := sar(8, signextend(2, tick))+ bitPos := and(tick, 0xff)+ }+ }++ /// @notice Flips the initialized state for a given tick from false to true, or vice versa+ /// @param self The mapping in which to flip the tick+ /// @param tick The tick to flip+ /// @param tickSpacing The spacing between usable ticks+ function flipTick(mapping(int16 => uint256) storage self, int24 tick, int24 tickSpacing) internal {+ // Equivalent to the following Solidity:+ // if (tick % tickSpacing != 0) revert TickMisaligned(tick, tickSpacing);+ // (int16 wordPos, uint8 bitPos) = position(tick / tickSpacing);+ // uint256 mask = 1 << bitPos;+ // self[wordPos] ^= mask;+ assembly ("memory-safe") {+ tick := signextend(2, tick)+ tickSpacing := signextend(2, tickSpacing)+ // ensure that the tick is spaced+ if smod(tick, tickSpacing) {+ let fmp := mload(0x40)+ mstore(fmp, 0xd4d8f3e6) // selector for TickMisaligned(int24,int24)+ mstore(add(fmp, 0x20), tick)+ mstore(add(fmp, 0x40), tickSpacing)+ revert(add(fmp, 0x1c), 0x44)+ }+ tick := sdiv(tick, tickSpacing)+ // calculate the storage slot corresponding to the tick+ // wordPos = tick >> 8+ mstore(0, sar(8, tick))+ mstore(0x20, self.slot)+ // the slot of self[wordPos] is keccak256(abi.encode(wordPos, self.slot))+ let slot := keccak256(0, 0x40)+ // mask = 1 << bitPos = 1 << (tick % 256)+ // self[wordPos] ^= mask+ sstore(slot, xor(sload(slot), shl(and(tick, 0xff), 1)))+ }+ }++ /// @notice Returns the next initialized tick contained in the same word (or adjacent word) as the tick that is either+ /// to the left (less than or equal to) or right (greater than) of the given tick+ /// @param self The mapping in which to compute the next initialized tick+ /// @param tick The starting tick+ /// @param tickSpacing The spacing between usable ticks+ /// @param lte Whether to search for the next initialized tick to the left (less than or equal to the starting tick)+ /// @return next The next initialized or uninitialized tick up to 256 ticks away from the current tick+ /// @return initialized Whether the next tick is initialized, as the function only searches within up to 256 ticks+ function nextInitializedTickWithinOneWord(+ mapping(int16 => uint256) storage self,+ int24 tick,+ int24 tickSpacing,+ bool lte+ ) internal view returns (int24 next, bool initialized) {+ unchecked {+ int24 compressed = compress(tick, tickSpacing);++ if (lte) {+ (int16 wordPos, uint8 bitPos) = position(compressed);+ // all the 1s at or to the right of the current bitPos+ uint256 mask = type(uint256).max >> (uint256(type(uint8).max) - bitPos);+ uint256 masked = self[wordPos] & mask;++ // if there are no initialized ticks to the right of or at the current tick, return rightmost in the word+ initialized = masked != 0;+ // overflow/underflow is possible, but prevented externally by limiting both tickSpacing and tick+ next = initialized+ ? (compressed - int24(uint24(bitPos - BitMath.mostSignificantBit(masked)))) * tickSpacing+ : (compressed - int24(uint24(bitPos))) * tickSpacing;+ } else {+ // start from the word of the next tick, since the current tick state doesn't matter+ (int16 wordPos, uint8 bitPos) = position(++compressed);+ // all the 1s at or to the left of the bitPos+ uint256 mask = ~((1 << bitPos) - 1);+ uint256 masked = self[wordPos] & mask;++ // if there are no initialized ticks to the left of the current tick, return leftmost in the word+ initialized = masked != 0;+ // overflow/underflow is possible, but prevented externally by limiting both tickSpacing and tick+ next = initialized+ ? (compressed + int24(uint24(BitMath.leastSignificantBit(masked) - bitPos))) * tickSpacing+ : (compressed + int24(uint24(type(uint8).max - bitPos))) * tickSpacing;+ }+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/TickMath.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/TickMath.solnew file mode 100644index 000000000..e5dc4adca--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/TickMath.sol@@ -0,0 +1,238 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {BitMath} from "./BitMath.sol";+import {CustomRevert} from "./CustomRevert.sol";++/// @title Math library for computing sqrt prices from ticks and vice versa+/// @notice Computes sqrt price for ticks of size 1.0001, i.e. sqrt(1.0001^tick) as fixed point Q64.96 numbers. Supports+/// prices between 2**-128 and 2**128+library TickMath {+ using CustomRevert for bytes4;++ /// @notice Thrown when the tick passed to #getSqrtPriceAtTick is not between MIN_TICK and MAX_TICK+ error InvalidTick(int24 tick);+ /// @notice Thrown when the price passed to #getTickAtSqrtPrice does not correspond to a price between MIN_TICK and MAX_TICK+ error InvalidSqrtPrice(uint160 sqrtPriceX96);++ /// @dev The minimum tick that may be passed to #getSqrtPriceAtTick computed from log base 1.0001 of 2**-128+ /// @dev If ever MIN_TICK and MAX_TICK are not centered around 0, the absTick logic in getSqrtPriceAtTick cannot be used+ int24 internal constant MIN_TICK = -887272;+ /// @dev The maximum tick that may be passed to #getSqrtPriceAtTick computed from log base 1.0001 of 2**128+ /// @dev If ever MIN_TICK and MAX_TICK are not centered around 0, the absTick logic in getSqrtPriceAtTick cannot be used+ int24 internal constant MAX_TICK = 887272;++ /// @dev The minimum tick spacing value drawn from the range of type int16 that is greater than 0, i.e. min from the range [1, 32767]+ int24 internal constant MIN_TICK_SPACING = 1;+ /// @dev The maximum tick spacing value drawn from the range of type int16, i.e. max from the range [1, 32767]+ int24 internal constant MAX_TICK_SPACING = type(int16).max;++ /// @dev The minimum value that can be returned from #getSqrtPriceAtTick. Equivalent to getSqrtPriceAtTick(MIN_TICK)+ uint160 internal constant MIN_SQRT_PRICE = 4295128739;+ /// @dev The maximum value that can be returned from #getSqrtPriceAtTick. Equivalent to getSqrtPriceAtTick(MAX_TICK)+ uint160 internal constant MAX_SQRT_PRICE = 1461446703485210103287273052203988822378723970342;+ /// @dev A threshold used for optimized bounds check, equals `MAX_SQRT_PRICE - MIN_SQRT_PRICE - 1`+ uint160 internal constant MAX_SQRT_PRICE_MINUS_MIN_SQRT_PRICE_MINUS_ONE =+ 1461446703485210103287273052203988822378723970342 - 4295128739 - 1;++ /// @notice Given a tickSpacing, compute the maximum usable tick+ function maxUsableTick(int24 tickSpacing) internal pure returns (int24) {+ unchecked {+ return (MAX_TICK / tickSpacing) * tickSpacing;+ }+ }++ /// @notice Given a tickSpacing, compute the minimum usable tick+ function minUsableTick(int24 tickSpacing) internal pure returns (int24) {+ unchecked {+ return (MIN_TICK / tickSpacing) * tickSpacing;+ }+ }++ /// @notice Calculates sqrt(1.0001^tick) * 2^96+ /// @dev Throws if |tick| > max tick+ /// @param tick The input tick for the above formula+ /// @return sqrtPriceX96 A Fixed point Q64.96 number representing the sqrt of the price of the two assets (currency1/currency0)+ /// at the given tick+ function getSqrtPriceAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {+ unchecked {+ uint256 absTick;+ assembly ("memory-safe") {+ tick := signextend(2, tick)+ // mask = 0 if tick >= 0 else -1 (all 1s)+ let mask := sar(255, tick)+ // if tick >= 0, |tick| = tick = 0 ^ tick+ // if tick < 0, |tick| = ~~|tick| = ~(-|tick| - 1) = ~(tick - 1) = (-1) ^ (tick - 1)+ // either way, |tick| = mask ^ (tick + mask)+ absTick := xor(mask, add(mask, tick))+ }++ if (absTick > uint256(int256(MAX_TICK))) InvalidTick.selector.revertWith(tick);++ // The tick is decomposed into bits, and for each bit with index i that is set, the product of 1/sqrt(1.0001^(2^i))+ // is calculated (using Q128.128). The constants used for this calculation are rounded to the nearest integer++ // Equivalent to:+ // price = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;+ // or price = int(2**128 / sqrt(1.0001)) if (absTick & 0x1) else 1 << 128+ uint256 price;+ assembly ("memory-safe") {+ price := xor(shl(128, 1), mul(xor(shl(128, 1), 0xfffcb933bd6fad37aa2d162d1a594001), and(absTick, 0x1)))+ }+ if (absTick & 0x2 != 0) price = (price * 0xfff97272373d413259a46990580e213a) >> 128;+ if (absTick & 0x4 != 0) price = (price * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;+ if (absTick & 0x8 != 0) price = (price * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;+ if (absTick & 0x10 != 0) price = (price * 0xffcb9843d60f6159c9db58835c926644) >> 128;+ if (absTick & 0x20 != 0) price = (price * 0xff973b41fa98c081472e6896dfb254c0) >> 128;+ if (absTick & 0x40 != 0) price = (price * 0xff2ea16466c96a3843ec78b326b52861) >> 128;+ if (absTick & 0x80 != 0) price = (price * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;+ if (absTick & 0x100 != 0) price = (price * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;+ if (absTick & 0x200 != 0) price = (price * 0xf987a7253ac413176f2b074cf7815e54) >> 128;+ if (absTick & 0x400 != 0) price = (price * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;+ if (absTick & 0x800 != 0) price = (price * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;+ if (absTick & 0x1000 != 0) price = (price * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;+ if (absTick & 0x2000 != 0) price = (price * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;+ if (absTick & 0x4000 != 0) price = (price * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;+ if (absTick & 0x8000 != 0) price = (price * 0x31be135f97d08fd981231505542fcfa6) >> 128;+ if (absTick & 0x10000 != 0) price = (price * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;+ if (absTick & 0x20000 != 0) price = (price * 0x5d6af8dedb81196699c329225ee604) >> 128;+ if (absTick & 0x40000 != 0) price = (price * 0x2216e584f5fa1ea926041bedfe98) >> 128;+ if (absTick & 0x80000 != 0) price = (price * 0x48a170391f7dc42444e8fa2) >> 128;++ assembly ("memory-safe") {+ // if (tick > 0) price = type(uint256).max / price;+ if sgt(tick, 0) { price := div(not(0), price) }++ // this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.+ // we then downcast because we know the result always fits within 160 bits due to our tick input constraint+ // we round up in the division so getTickAtSqrtPrice of the output price is always consistent+ // `sub(shl(32, 1), 1)` is `type(uint32).max`+ // `price + type(uint32).max` will not overflow because `price` fits in 192 bits+ sqrtPriceX96 := shr(32, add(price, sub(shl(32, 1), 1)))+ }+ }+ }++ /// @notice Calculates the greatest tick value such that getSqrtPriceAtTick(tick) <= sqrtPriceX96+ /// @dev Throws in case sqrtPriceX96 < MIN_SQRT_PRICE, as MIN_SQRT_PRICE is the lowest value getSqrtPriceAtTick may+ /// ever return.+ /// @param sqrtPriceX96 The sqrt price for which to compute the tick as a Q64.96+ /// @return tick The greatest tick for which the getSqrtPriceAtTick(tick) is less than or equal to the input sqrtPriceX96+ function getTickAtSqrtPrice(uint160 sqrtPriceX96) internal pure returns (int24 tick) {+ unchecked {+ // Equivalent: if (sqrtPriceX96 < MIN_SQRT_PRICE || sqrtPriceX96 >= MAX_SQRT_PRICE) revert InvalidSqrtPrice();+ // second inequality must be >= because the price can never reach the price at the max tick+ // if sqrtPriceX96 < MIN_SQRT_PRICE, the `sub` underflows and `gt` is true+ // if sqrtPriceX96 >= MAX_SQRT_PRICE, sqrtPriceX96 - MIN_SQRT_PRICE > MAX_SQRT_PRICE - MIN_SQRT_PRICE - 1+ if ((sqrtPriceX96 - MIN_SQRT_PRICE) > MAX_SQRT_PRICE_MINUS_MIN_SQRT_PRICE_MINUS_ONE) {+ InvalidSqrtPrice.selector.revertWith(sqrtPriceX96);+ }++ uint256 price = uint256(sqrtPriceX96) << 32;++ uint256 r = price;+ uint256 msb = BitMath.mostSignificantBit(r);++ if (msb >= 128) r = price >> (msb - 127);+ else r = price << (127 - msb);++ int256 log_2 = (int256(msb) - 128) << 64;++ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(63, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(62, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(61, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(60, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(59, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(58, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(57, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(56, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(55, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(54, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(53, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(52, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(51, f))+ r := shr(f, r)+ }+ assembly ("memory-safe") {+ r := shr(127, mul(r, r))+ let f := shr(128, r)+ log_2 := or(log_2, shl(50, f))+ }++ int256 log_sqrt10001 = log_2 * 255738958999603826347141; // Q22.128 number++ // Magic number represents the ceiling of the maximum value of the error when approximating log_sqrt10001(x)+ int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);++ // Magic number represents the minimum value of the error when approximating log_sqrt10001(x), when+ // sqrtPrice is from the range (2^-64, 2^64). This is safe as MIN_SQRT_PRICE is more than 2^-64. If MIN_SQRT_PRICE+ // is changed, this may need to be changed too+ int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);++ tick = tickLow == tickHi ? tickLow : getSqrtPriceAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/TransientStateLibrary.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/TransientStateLibrary.solnew file mode 100644index 000000000..0544716b1--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/TransientStateLibrary.sol@@ -0,0 +1,49 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.24;++import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {Currency} from "../types/Currency.sol";+import {CurrencyReserves} from "./CurrencyReserves.sol";+import {NonzeroDeltaCount} from "./NonzeroDeltaCount.sol";+import {Lock} from "./Lock.sol";++/// @notice A helper library to provide state getters that use exttload+library TransientStateLibrary {+ /// @notice returns the reserves for the synced currency+ /// @param manager The pool manager contract.++ /// @return uint256 The reserves of the currency.+ /// @dev returns 0 if the reserves are not synced or value is 0.+ /// Checks the synced currency to only return valid reserve values (after a sync and before a settle).+ function getSyncedReserves(IPoolManager manager) internal view returns (uint256) {+ if (getSyncedCurrency(manager).isAddressZero()) return 0;+ return uint256(manager.exttload(CurrencyReserves.RESERVES_OF_SLOT));+ }++ function getSyncedCurrency(IPoolManager manager) internal view returns (Currency) {+ return Currency.wrap(address(uint160(uint256(manager.exttload(CurrencyReserves.CURRENCY_SLOT)))));+ }++ /// @notice Returns the number of nonzero deltas open on the PoolManager that must be zeroed out before the contract is locked+ function getNonzeroDeltaCount(IPoolManager manager) internal view returns (uint256) {+ return uint256(manager.exttload(NonzeroDeltaCount.NONZERO_DELTA_COUNT_SLOT));+ }++ /// @notice Get the current delta for a caller in the given currency+ /// @param target The credited account address+ /// @param currency The currency for which to lookup the delta+ function currencyDelta(IPoolManager manager, address target, Currency currency) internal view returns (int256) {+ bytes32 key;+ assembly ("memory-safe") {+ mstore(0, and(target, 0xffffffffffffffffffffffffffffffffffffffff))+ mstore(32, and(currency, 0xffffffffffffffffffffffffffffffffffffffff))+ key := keccak256(0, 64)+ }+ return int256(uint256(manager.exttload(key)));+ }++ /// @notice Returns whether the contract is unlocked or not+ function isUnlocked(IPoolManager manager) internal view returns (bool) {+ return manager.exttload(Lock.IS_UNLOCKED_SLOT) != 0x0;+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/libraries/UnsafeMath.sol b/contracts/v4-hooks/lib/v4-core/src/libraries/UnsafeMath.solnew file mode 100644index 000000000..ed88beca3--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/libraries/UnsafeMath.sol@@ -0,0 +1,29 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/// @title Math functions that do not check inputs or outputs+/// @notice Contains methods that perform common math functions but do not do any overflow or underflow checks+library UnsafeMath {+ /// @notice Returns ceil(x / y)+ /// @dev division by 0 will return 0, and should be checked externally+ /// @param x The dividend+ /// @param y The divisor+ /// @return z The quotient, ceil(x / y)+ function divRoundingUp(uint256 x, uint256 y) internal pure returns (uint256 z) {+ assembly ("memory-safe") {+ z := add(div(x, y), gt(mod(x, y), 0))+ }+ }++ /// @notice Calculates floor(a×b÷denominator)+ /// @dev division by 0 will return 0, and should be checked externally+ /// @param a The multiplicand+ /// @param b The multiplier+ /// @param denominator The divisor+ /// @return result The 256-bit result, floor(a×b÷denominator)+ function simpleMulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {+ assembly ("memory-safe") {+ result := div(mul(a, b), denominator)+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/ActionsRouter.sol b/contracts/v4-hooks/lib/v4-core/src/test/ActionsRouter.solnew file mode 100644index 000000000..b1e2bed51--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/ActionsRouter.sol@@ -0,0 +1,170 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import "forge-std/Test.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {IUnlockCallback} from "../interfaces/callback/IUnlockCallback.sol";+import {Currency} from "../types/Currency.sol";+import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";+import {StateLibrary} from "../libraries/StateLibrary.sol";+import {TransientStateLibrary} from "../libraries/TransientStateLibrary.sol";++// Supported Actions.+enum Actions {+ SETTLE,+ SETTLE_NATIVE,+ SETTLE_FOR,+ TAKE,+ PRANK_TAKE_FROM,+ SYNC,+ MINT,+ CLEAR,+ ASSERT_BALANCE_EQUALS,+ ASSERT_RESERVES_EQUALS,+ ASSERT_DELTA_EQUALS,+ ASSERT_NONZERO_DELTA_COUNT_EQUALS,+ TRANSFER_FROM,+ COLLECT_PROTOCOL_FEES+}+// TODO: Add other actions as needed.+// BURN,+// MODIFY_POSITION,+// INITIALIZE,+// DONATE++/// @notice A router that handles an arbitrary input of actions.+/// TODO: Can continue to add functions per action.+contract ActionsRouter is IUnlockCallback, Test {+ using StateLibrary for IPoolManager;+ using TransientStateLibrary for IPoolManager;++ error ActionNotSupported();++ // error thrown so that incorrectly formatted tests don't pass silently+ error CheckParameters();++ IPoolManager manager;++ constructor(IPoolManager _manager) {+ manager = _manager;+ }++ function unlockCallback(bytes calldata data) external returns (bytes memory) {+ (Actions[] memory actions, bytes[] memory params) = abi.decode(data, (Actions[], bytes[]));+ if (actions.length != params.length || actions.length == 0) revert CheckParameters();+ for (uint256 i = 0; i < actions.length; i++) {+ Actions action = actions[i];+ bytes memory param = params[i];+ if (action == Actions.SETTLE) {+ _settle();+ } else if (action == Actions.SETTLE_NATIVE) {+ _settleNative(param);+ } else if (action == Actions.SETTLE_FOR) {+ _settleFor(param);+ } else if (action == Actions.TAKE) {+ _take(param);+ } else if (action == Actions.PRANK_TAKE_FROM) {+ _prankTakeFrom(param);+ } else if (action == Actions.SYNC) {+ _sync(param);+ } else if (action == Actions.MINT) {+ _mint(param);+ } else if (action == Actions.CLEAR) {+ _clear(param);+ } else if (action == Actions.ASSERT_BALANCE_EQUALS) {+ _assertBalanceEquals(param);+ } else if (action == Actions.ASSERT_RESERVES_EQUALS) {+ _assertReservesEquals(param);+ } else if (action == Actions.ASSERT_DELTA_EQUALS) {+ _assertDeltaEquals(param);+ } else if (action == Actions.ASSERT_NONZERO_DELTA_COUNT_EQUALS) {+ _assertNonzeroDeltaCountEquals(param);+ } else if (action == Actions.TRANSFER_FROM) {+ _transferFrom(param);+ } else if (action == Actions.COLLECT_PROTOCOL_FEES) {+ _collectProtocolFees(param);+ }+ }+ return "";+ }++ function executeActions(Actions[] memory actions, bytes[] memory params) external payable {+ manager.unlock(abi.encode(actions, params));+ }++ function _settle() internal {+ manager.settle();+ }++ function _settleNative(bytes memory params) internal {+ uint256 amount = abi.decode(params, (uint256));+ manager.settle{value: amount}();+ }++ function _settleFor(bytes memory params) internal {+ address recipient = abi.decode(params, (address));+ manager.settleFor(recipient);+ }++ function _take(bytes memory params) internal {+ (Currency currency, address recipient, int128 amount) = abi.decode(params, (Currency, address, int128));+ manager.take(currency, recipient, uint128(amount));+ }++ function _prankTakeFrom(bytes memory params) internal {+ (Currency currency, address from, address recipient, uint256 amount) =+ abi.decode(params, (Currency, address, address, uint256));+ vm.prank(from);+ manager.take(currency, recipient, amount);+ }++ function _sync(bytes memory params) internal {+ Currency currency = Currency.wrap(abi.decode(params, (address)));+ manager.sync(currency);+ }++ function _mint(bytes memory params) internal {+ (address recipient, Currency currency, uint256 amount) = abi.decode(params, (address, Currency, uint256));+ manager.mint(recipient, currency.toId(), amount);+ }++ function _clear(bytes memory params) internal {+ (Currency currency, uint256 amount, bool measureGas, string memory gasSnapName) =+ abi.decode(params, (Currency, uint256, bool, string));++ manager.clear(currency, amount);+ if (measureGas) vm.snapshotGasLastCall(gasSnapName);+ }++ function _assertBalanceEquals(bytes memory params) internal view {+ (Currency currency, address user, uint256 expectedBalance) = abi.decode(params, (Currency, address, uint256));+ assertEq(currency.balanceOf(user), expectedBalance, "usertoken value incorrect");+ }++ function _assertReservesEquals(bytes memory params) internal view {+ uint256 expectedReserves = abi.decode(params, (uint256));+ assertEq(manager.getSyncedReserves(), expectedReserves, "reserves value incorrect");+ }++ function _assertDeltaEquals(bytes memory params) internal view {+ (Currency currency, address caller, int256 expectedDelta) = abi.decode(params, (Currency, address, int256));++ assertEq(manager.currencyDelta(caller, currency), expectedDelta, "delta value incorrect");+ }++ function _assertNonzeroDeltaCountEquals(bytes memory params) internal view {+ (uint256 expectedCount) = abi.decode(params, (uint256));+ assertEq(manager.getNonzeroDeltaCount(), expectedCount, "nonzero delta count incorrect");+ }++ function _transferFrom(bytes memory params) internal {+ (Currency currency, address from, address recipient, uint256 amount) =+ abi.decode(params, (Currency, address, address, uint256));+ MockERC20(Currency.unwrap(currency)).transferFrom(from, recipient, uint256(amount));+ }++ function _collectProtocolFees(bytes memory params) internal {+ (address to, Currency currency, uint256 amount) = abi.decode(params, (address, Currency, uint256));+ manager.collectProtocolFees(to, currency, amount);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/BaseTestHooks.sol b/contracts/v4-hooks/lib/v4-core/src/test/BaseTestHooks.solnew file mode 100644index 000000000..83c9f9af9--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/BaseTestHooks.sol@@ -0,0 +1,108 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {IHooks} from "../interfaces/IHooks.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {BeforeSwapDelta} from "../types/BeforeSwapDelta.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";++contract BaseTestHooks is IHooks {+ error HookNotImplemented();++ function beforeInitialize(address, /* sender **/ PoolKey calldata, /* key **/ uint160 /* sqrtPriceX96 **/ )+ external+ virtual+ returns (bytes4)+ {+ revert HookNotImplemented();+ }++ function afterInitialize(+ address, /* sender **/+ PoolKey calldata, /* key **/+ uint160, /* sqrtPriceX96 **/+ int24 /* tick **/+ ) external virtual returns (bytes4) {+ revert HookNotImplemented();+ }++ function beforeAddLiquidity(+ address, /* sender **/+ PoolKey calldata, /* key **/+ IPoolManager.ModifyLiquidityParams calldata, /* params **/+ bytes calldata /* hookData **/+ ) external virtual returns (bytes4) {+ revert HookNotImplemented();+ }++ function afterAddLiquidity(+ address, /* sender **/+ PoolKey calldata, /* key **/+ IPoolManager.ModifyLiquidityParams calldata, /* params **/+ BalanceDelta, /* delta **/+ BalanceDelta, /* feeDelta **/+ bytes calldata /* hookData **/+ ) external virtual returns (bytes4, BalanceDelta) {+ revert HookNotImplemented();+ }++ function beforeRemoveLiquidity(+ address, /* sender **/+ PoolKey calldata, /* key **/+ IPoolManager.ModifyLiquidityParams calldata, /* params **/+ bytes calldata /* hookData **/+ ) external virtual returns (bytes4) {+ revert HookNotImplemented();+ }++ function afterRemoveLiquidity(+ address, /* sender **/+ PoolKey calldata, /* key **/+ IPoolManager.ModifyLiquidityParams calldata, /* params **/+ BalanceDelta, /* delta **/+ BalanceDelta, /* feeDelta **/+ bytes calldata /* hookData **/+ ) external virtual returns (bytes4, BalanceDelta) {+ revert HookNotImplemented();+ }++ function beforeSwap(+ address, /* sender **/+ PoolKey calldata, /* key **/+ IPoolManager.SwapParams calldata, /* params **/+ bytes calldata /* hookData **/+ ) external virtual returns (bytes4, BeforeSwapDelta, uint24) {+ revert HookNotImplemented();+ }++ function afterSwap(+ address, /* sender **/+ PoolKey calldata, /* key **/+ IPoolManager.SwapParams calldata, /* params **/+ BalanceDelta, /* delta **/+ bytes calldata /* hookData **/+ ) external virtual returns (bytes4, int128) {+ revert HookNotImplemented();+ }++ function beforeDonate(+ address, /* sender **/+ PoolKey calldata, /* key **/+ uint256, /* amount0 **/+ uint256, /* amount1 **/+ bytes calldata /* hookData **/+ ) external virtual returns (bytes4) {+ revert HookNotImplemented();+ }++ function afterDonate(+ address, /* sender **/+ PoolKey calldata, /* key **/+ uint256, /* amount0 **/+ uint256, /* amount1 **/+ bytes calldata /* hookData **/+ ) external virtual returns (bytes4) {+ revert HookNotImplemented();+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/CurrencyTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/CurrencyTest.solnew file mode 100644index 000000000..d0f73de60--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/CurrencyTest.sol@@ -0,0 +1,30 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {Currency, CurrencyLibrary} from "../types/Currency.sol";++contract CurrencyTest {+ function transfer(Currency currency, address to, uint256 amount) external {+ currency.transfer(to, amount);+ }++ function balanceOfSelf(Currency currency) external view returns (uint256) {+ return currency.balanceOfSelf();+ }++ function balanceOf(Currency currency, address owner) external view returns (uint256) {+ return currency.balanceOf(owner);+ }++ function isAddressZero(Currency currency) external pure returns (bool) {+ return currency.isAddressZero();+ }++ function toId(Currency currency) external pure returns (uint256) {+ return currency.toId();+ }++ function fromId(uint256 id) external pure returns (Currency) {+ return CurrencyLibrary.fromId(id);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/CustomCurveHook.sol b/contracts/v4-hooks/lib/v4-core/src/test/CustomCurveHook.solnew file mode 100644index 000000000..65559e988--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/CustomCurveHook.sol@@ -0,0 +1,70 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {Hooks} from "../libraries/Hooks.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BeforeSwapDelta, toBeforeSwapDelta} from "../types/BeforeSwapDelta.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {Currency} from "../types/Currency.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";+import {BaseTestHooks} from "./BaseTestHooks.sol";+import {Currency} from "../types/Currency.sol";++contract CustomCurveHook is BaseTestHooks {+ using Hooks for IHooks;+ using CurrencySettler for Currency;++ error AddLiquidityDirectToHook();++ IPoolManager immutable manager;++ constructor(IPoolManager _manager) {+ manager = _manager;+ }++ modifier onlyPoolManager() {+ require(msg.sender == address(manager));+ _;+ }++ function beforeSwap(+ address, /* sender **/+ PoolKey calldata key,+ IPoolManager.SwapParams calldata params,+ bytes calldata /* hookData **/+ ) external override onlyPoolManager returns (bytes4, BeforeSwapDelta, uint24) {+ (Currency inputCurrency, Currency outputCurrency, uint256 amount) = _getInputOutputAndAmount(key, params);++ // this "custom curve" is a line, 1-1+ // take the full input amount, and give the full output amount+ manager.take(inputCurrency, address(this), amount);+ outputCurrency.settle(manager, address(this), amount, false);++ // return -amountSpecified as specified to no-op the concentrated liquidity swap+ BeforeSwapDelta hookDelta = toBeforeSwapDelta(int128(-params.amountSpecified), int128(params.amountSpecified));+ return (IHooks.beforeSwap.selector, hookDelta, 0);+ }++ function afterAddLiquidity(+ address, /* sender **/+ PoolKey calldata, /* key **/+ IPoolManager.ModifyLiquidityParams calldata, /* params **/+ BalanceDelta, /* delta **/+ BalanceDelta, /* feeDelta **/+ bytes calldata /* hookData **/+ ) external view override onlyPoolManager returns (bytes4, BalanceDelta) {+ revert AddLiquidityDirectToHook();+ }++ function _getInputOutputAndAmount(PoolKey calldata key, IPoolManager.SwapParams calldata params)+ internal+ pure+ returns (Currency input, Currency output, uint256 amount)+ {+ (input, output) = params.zeroForOne ? (key.currency0, key.currency1) : (key.currency1, key.currency0);++ amount = params.amountSpecified < 0 ? uint256(-params.amountSpecified) : uint256(params.amountSpecified);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/DeltaReturningHook.sol b/contracts/v4-hooks/lib/v4-core/src/test/DeltaReturningHook.solnew file mode 100644index 000000000..d285193d6--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/DeltaReturningHook.sol@@ -0,0 +1,99 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {Hooks} from "../libraries/Hooks.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {Currency} from "../types/Currency.sol";+import {BaseTestHooks} from "./BaseTestHooks.sol";+import {Currency} from "../types/Currency.sol";+import {BeforeSwapDelta, toBeforeSwapDelta} from "../types/BeforeSwapDelta.sol";++contract DeltaReturningHook is BaseTestHooks {+ using Hooks for IHooks;+ using CurrencySettler for Currency;++ IPoolManager immutable manager;++ int128 deltaSpecified;+ int128 deltaUnspecifiedBeforeSwap;+ int128 deltaUnspecifiedAfterSwap;++ constructor(IPoolManager _manager) {+ manager = _manager;+ }++ modifier onlyPoolManager() {+ require(msg.sender == address(manager));+ _;+ }++ function setDeltaSpecified(int128 delta) external {+ deltaSpecified = delta;+ }++ function setDeltaUnspecifiedBeforeSwap(int128 delta) external {+ deltaUnspecifiedBeforeSwap = delta;+ }++ function setDeltaUnspecifiedAfterSwap(int128 delta) external {+ deltaUnspecifiedAfterSwap = delta;+ }++ function beforeSwap(+ address, /* sender **/+ PoolKey calldata key,+ IPoolManager.SwapParams calldata params,+ bytes calldata /* hookData **/+ ) external override onlyPoolManager returns (bytes4, BeforeSwapDelta, uint24) {+ (Currency specifiedCurrency, Currency unspecifiedCurrency) = _sortCurrencies(key, params);++ if (deltaSpecified != 0) _settleOrTake(specifiedCurrency, deltaSpecified);+ if (deltaUnspecifiedBeforeSwap != 0) _settleOrTake(unspecifiedCurrency, deltaUnspecifiedBeforeSwap);++ BeforeSwapDelta beforeSwapDelta = toBeforeSwapDelta(deltaSpecified, deltaUnspecifiedBeforeSwap);++ return (IHooks.beforeSwap.selector, beforeSwapDelta, 0);+ }++ function afterSwap(+ address, /* sender **/+ PoolKey calldata key,+ IPoolManager.SwapParams calldata params,+ BalanceDelta, /* delta **/+ bytes calldata /* hookData **/+ ) external override onlyPoolManager returns (bytes4, int128) {+ (, Currency unspecifiedCurrency) = _sortCurrencies(key, params);+ _settleOrTake(unspecifiedCurrency, deltaUnspecifiedAfterSwap);++ return (IHooks.afterSwap.selector, deltaUnspecifiedAfterSwap);+ }++ function _sortCurrencies(PoolKey calldata key, IPoolManager.SwapParams calldata params)+ internal+ pure+ returns (Currency specified, Currency unspecified)+ {+ (specified, unspecified) = (params.zeroForOne == (params.amountSpecified < 0))+ ? (key.currency0, key.currency1)+ : (key.currency1, key.currency0);+ }++ function _settleOrTake(Currency currency, int128 delta) internal {+ // positive amount means positive delta for the hook, so it can take+ // negative it should settle+ if (delta > 0) {+ currency.take(manager, address(this), uint128(delta), false);+ } else {+ uint256 amount = uint256(-int256(delta));+ if (currency.isAddressZero()) {+ manager.settle{value: amount}();+ } else {+ currency.settle(manager, address(this), amount, false);+ }+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/DynamicFeesTestHook.sol b/contracts/v4-hooks/lib/v4-core/src/test/DynamicFeesTestHook.solnew file mode 100644index 000000000..8b546d09a--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/DynamicFeesTestHook.sol@@ -0,0 +1,39 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {BaseTestHooks} from "./BaseTestHooks.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {BeforeSwapDelta, BeforeSwapDeltaLibrary} from "../types/BeforeSwapDelta.sol";++contract DynamicFeesTestHook is BaseTestHooks {+ uint24 internal fee;+ IPoolManager manager;++ function setManager(IPoolManager _manager) external {+ manager = _manager;+ }++ function setFee(uint24 _fee) external {+ fee = _fee;+ }++ function afterInitialize(address, PoolKey calldata key, uint160, int24) external override returns (bytes4) {+ manager.updateDynamicLPFee(key, fee);+ return IHooks.afterInitialize.selector;+ }++ function beforeSwap(address, PoolKey calldata key, IPoolManager.SwapParams calldata, bytes calldata)+ external+ override+ returns (bytes4, BeforeSwapDelta, uint24)+ {+ manager.updateDynamicLPFee(key, fee);+ return (IHooks.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, 0);+ }++ function forcePoolFeeUpdate(PoolKey calldata _key, uint24 _fee) external {+ manager.updateDynamicLPFee(_key, _fee);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/DynamicReturnFeeTestHook.sol b/contracts/v4-hooks/lib/v4-core/src/test/DynamicReturnFeeTestHook.solnew file mode 100644index 000000000..f5dee1c6f--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/DynamicReturnFeeTestHook.sol@@ -0,0 +1,38 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {BaseTestHooks} from "./BaseTestHooks.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {BeforeSwapDelta, BeforeSwapDeltaLibrary} from "../types/BeforeSwapDelta.sol";+import {LPFeeLibrary} from "../libraries/LPFeeLibrary.sol";++contract DynamicReturnFeeTestHook is BaseTestHooks {+ using LPFeeLibrary for uint24;++ uint24 internal fee;+ IPoolManager manager;++ function setManager(IPoolManager _manager) external {+ manager = _manager;+ }++ function setFee(uint24 _fee) external {+ fee = _fee;+ }++ function beforeSwap(address, PoolKey calldata, IPoolManager.SwapParams calldata, bytes calldata)+ external+ view+ override+ returns (bytes4, BeforeSwapDelta, uint24)+ {+ // attach the fee flag to `fee` to enable overriding the pool's stored fee+ return (IHooks.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, fee | LPFeeLibrary.OVERRIDE_FEE_FLAG);+ }++ function forcePoolFeeUpdate(PoolKey calldata _key, uint24 _fee) external {+ manager.updateDynamicLPFee(_key, _fee);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/EmptyRevertContract.sol b/contracts/v4-hooks/lib/v4-core/src/test/EmptyRevertContract.solnew file mode 100644index 000000000..1acf833c4--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/EmptyRevertContract.sol@@ -0,0 +1,9 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++contract EmptyRevertContract {+ // a contract to simulate reverting with no returndata, to test that our error catching works+ fallback() external {+ revert();+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/EmptyTestHooks.sol b/contracts/v4-hooks/lib/v4-core/src/test/EmptyTestHooks.solnew file mode 100644index 000000000..43544cf90--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/EmptyTestHooks.sol@@ -0,0 +1,118 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {Hooks} from "../libraries/Hooks.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta, BalanceDeltaLibrary} from "../types/BalanceDelta.sol";+import {BeforeSwapDelta, BeforeSwapDeltaLibrary} from "../types/BeforeSwapDelta.sol";++contract EmptyTestHooks is IHooks {+ using Hooks for IHooks;++ constructor() {+ IHooks(this).validateHookPermissions(+ Hooks.Permissions({+ beforeInitialize: true,+ afterInitialize: true,+ beforeAddLiquidity: true,+ afterAddLiquidity: true,+ beforeRemoveLiquidity: true,+ afterRemoveLiquidity: true,+ beforeSwap: true,+ afterSwap: true,+ beforeDonate: true,+ afterDonate: true,+ beforeSwapReturnDelta: true,+ afterSwapReturnDelta: true,+ afterAddLiquidityReturnDelta: true,+ afterRemoveLiquidityReturnDelta: true+ })+ );+ }++ function beforeInitialize(address, PoolKey calldata, uint160) external pure override returns (bytes4) {+ return IHooks.beforeInitialize.selector;+ }++ function afterInitialize(address, PoolKey calldata, uint160, int24) external pure override returns (bytes4) {+ return IHooks.afterInitialize.selector;+ }++ function beforeAddLiquidity(address, PoolKey calldata, IPoolManager.ModifyLiquidityParams calldata, bytes calldata)+ external+ pure+ override+ returns (bytes4)+ {+ return IHooks.beforeAddLiquidity.selector;+ }++ function afterAddLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ BalanceDelta,+ BalanceDelta,+ bytes calldata+ ) external pure override returns (bytes4, BalanceDelta) {+ return (IHooks.afterAddLiquidity.selector, BalanceDeltaLibrary.ZERO_DELTA);+ }++ function beforeRemoveLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ bytes calldata+ ) external pure override returns (bytes4) {+ return IHooks.beforeRemoveLiquidity.selector;+ }++ function afterRemoveLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ BalanceDelta,+ BalanceDelta,+ bytes calldata+ ) external pure override returns (bytes4, BalanceDelta) {+ return (IHooks.afterRemoveLiquidity.selector, BalanceDeltaLibrary.ZERO_DELTA);+ }++ function beforeSwap(address, PoolKey calldata, IPoolManager.SwapParams calldata, bytes calldata)+ external+ pure+ override+ returns (bytes4, BeforeSwapDelta, uint24)+ {+ return (IHooks.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, 0);+ }++ function afterSwap(address, PoolKey calldata, IPoolManager.SwapParams calldata, BalanceDelta, bytes calldata)+ external+ pure+ override+ returns (bytes4, int128)+ {+ return (IHooks.afterSwap.selector, 0);+ }++ function beforeDonate(address, PoolKey calldata, uint256, uint256, bytes calldata)+ external+ pure+ override+ returns (bytes4)+ {+ return IHooks.beforeDonate.selector;+ }++ function afterDonate(address, PoolKey calldata, uint256, uint256, bytes calldata)+ external+ pure+ override+ returns (bytes4)+ {+ return IHooks.afterDonate.selector;+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/FeeTakingHook.sol b/contracts/v4-hooks/lib/v4-core/src/test/FeeTakingHook.solnew file mode 100644index 000000000..bdbe27eb3--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/FeeTakingHook.sol@@ -0,0 +1,90 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {Hooks} from "../libraries/Hooks.sol";+import {SafeCast} from "../libraries/SafeCast.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta, toBalanceDelta} from "../types/BalanceDelta.sol";+import {Currency} from "../types/Currency.sol";+import {BaseTestHooks} from "./BaseTestHooks.sol";++contract FeeTakingHook is BaseTestHooks {+ using Hooks for IHooks;+ using SafeCast for uint256;+ using SafeCast for int128;++ IPoolManager immutable manager;++ constructor(IPoolManager _manager) {+ manager = _manager;+ }++ modifier onlyPoolManager() {+ require(msg.sender == address(manager));+ _;+ }++ uint128 public constant LIQUIDITY_FEE = 543; // 543/10000 = 5.43%+ uint128 public constant SWAP_FEE_BIPS = 123; // 123/10000 = 1.23%+ uint128 public constant TOTAL_BIPS = 10000;++ function afterSwap(+ address, /* sender **/+ PoolKey calldata key,+ IPoolManager.SwapParams calldata params,+ BalanceDelta delta,+ bytes calldata /* hookData **/+ ) external override onlyPoolManager returns (bytes4, int128) {+ // fee will be in the unspecified token of the swap+ bool specifiedTokenIs0 = (params.amountSpecified < 0 == params.zeroForOne);+ (Currency feeCurrency, int128 swapAmount) =+ (specifiedTokenIs0) ? (key.currency1, delta.amount1()) : (key.currency0, delta.amount0());+ // if fee is on output, get the absolute output amount+ if (swapAmount < 0) swapAmount = -swapAmount;++ uint256 feeAmount = uint128(swapAmount) * SWAP_FEE_BIPS / TOTAL_BIPS;+ manager.take(feeCurrency, address(this), feeAmount);++ return (IHooks.afterSwap.selector, feeAmount.toInt128());+ }++ function afterRemoveLiquidity(+ address, /* sender **/+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata, /* params **/+ BalanceDelta delta,+ BalanceDelta,+ bytes calldata /* hookData **/+ ) external override onlyPoolManager returns (bytes4, BalanceDelta) {+ assert(delta.amount0() >= 0 && delta.amount1() >= 0);++ uint128 feeAmount0 = uint128(delta.amount0()) * LIQUIDITY_FEE / TOTAL_BIPS;+ uint128 feeAmount1 = uint128(delta.amount1()) * LIQUIDITY_FEE / TOTAL_BIPS;++ manager.take(key.currency0, address(this), feeAmount0);+ manager.take(key.currency1, address(this), feeAmount1);++ return (IHooks.afterRemoveLiquidity.selector, toBalanceDelta(int128(feeAmount0), int128(feeAmount1)));+ }++ function afterAddLiquidity(+ address, /* sender **/+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata, /* params **/+ BalanceDelta delta,+ BalanceDelta,+ bytes calldata /* hookData **/+ ) external override onlyPoolManager returns (bytes4, BalanceDelta) {+ assert(delta.amount0() <= 0 && delta.amount1() <= 0);++ uint128 feeAmount0 = uint128(-delta.amount0()) * LIQUIDITY_FEE / TOTAL_BIPS;+ uint128 feeAmount1 = uint128(-delta.amount1()) * LIQUIDITY_FEE / TOTAL_BIPS;++ manager.take(key.currency0, address(this), feeAmount0);+ manager.take(key.currency1, address(this), feeAmount1);++ return (IHooks.afterAddLiquidity.selector, toBalanceDelta(int128(feeAmount0), int128(feeAmount1)));+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/Fuzzers.sol b/contracts/v4-hooks/lib/v4-core/src/test/Fuzzers.solnew file mode 100644index 000000000..04c2c11bf--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/Fuzzers.sol@@ -0,0 +1,183 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.24;++import {Vm} from "forge-std/Vm.sol";+import {StdUtils} from "forge-std/StdUtils.sol";++import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {TickMath} from "../libraries/TickMath.sol";+import {Pool} from "../libraries/Pool.sol";+import {PoolModifyLiquidityTest} from "./PoolModifyLiquidityTest.sol";+import {LiquidityAmounts} from "../../test/utils/LiquidityAmounts.sol";+import {SafeCast} from "../../src/libraries/SafeCast.sol";++contract Fuzzers is StdUtils {+ using SafeCast for uint256;++ Vm internal constant _vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));++ function boundLiquidityDelta(PoolKey memory key, int256 liquidityDeltaUnbounded, int256 liquidityMaxByAmount)+ internal+ pure+ returns (int256)+ {+ int256 liquidityMaxPerTick = int256(uint256(Pool.tickSpacingToMaxLiquidityPerTick(key.tickSpacing)));++ // Finally bound the seeded liquidity by either the max per tick, or by the amount allowed in the position range.+ int256 liquidityMax = liquidityMaxByAmount > liquidityMaxPerTick ? liquidityMaxPerTick : liquidityMaxByAmount;+ _vm.assume(liquidityMax != 0);+ return bound(liquidityDeltaUnbounded, 1, liquidityMax);+ }++ // Uses tickSpacingToMaxLiquidityPerTick/2 as one of the possible bounds.+ // Potentially adjust this value to be more strict for positions that touch the same tick.+ function boundLiquidityDeltaTightly(+ PoolKey memory key,+ int256 liquidityDeltaUnbounded,+ int256 liquidityMaxByAmount,+ uint256 maxPositions+ ) internal pure returns (int256) {+ // Divide by half to bound liquidity more. TODO: Probably a better way to do this.+ int256 liquidityMaxTightBound =+ int256(uint256(Pool.tickSpacingToMaxLiquidityPerTick(key.tickSpacing)) / maxPositions);++ // Finally bound the seeded liquidity by either the max per tick, or by the amount allowed in the position range.+ int256 liquidityMax =+ liquidityMaxByAmount > liquidityMaxTightBound ? liquidityMaxTightBound : liquidityMaxByAmount;+ _vm.assume(liquidityMax != 0);+ return bound(liquidityDeltaUnbounded, 1, liquidityMax);+ }++ function getLiquidityDeltaFromAmounts(int24 tickLower, int24 tickUpper, uint160 sqrtPriceX96)+ internal+ pure+ returns (int256)+ {+ // First get the maximum amount0 and maximum amount1 that can be deposited at this range.+ (uint256 maxAmount0, uint256 maxAmount1) = LiquidityAmounts.getAmountsForLiquidity(+ sqrtPriceX96,+ TickMath.getSqrtPriceAtTick(tickLower),+ TickMath.getSqrtPriceAtTick(tickUpper),+ uint128(type(int128).max)+ );++ // Compare the max amounts (defined by the range of the position) to the max amount constrained by the type container.+ // The true maximum should be the minimum of the two.+ // (ie If the position range allows a deposit of more then int128.max in any token, then here we cap it at int128.max.)++ uint256 amount0 = uint256(type(uint128).max / 2);+ uint256 amount1 = uint256(type(uint128).max / 2);++ maxAmount0 = maxAmount0 > amount0 ? amount0 : maxAmount0;+ maxAmount1 = maxAmount1 > amount1 ? amount1 : maxAmount1;++ int256 liquidityMaxByAmount = uint256(+ LiquidityAmounts.getLiquidityForAmounts(+ sqrtPriceX96,+ TickMath.getSqrtPriceAtTick(tickLower),+ TickMath.getSqrtPriceAtTick(tickUpper),+ maxAmount0,+ maxAmount1+ )+ ).toInt256();++ return liquidityMaxByAmount;+ }++ function boundTicks(int24 tickLower, int24 tickUpper, int24 tickSpacing) internal pure returns (int24, int24) {+ tickLower = int24(+ bound(+ int256(tickLower),+ int256(TickMath.minUsableTick(tickSpacing)),+ int256(TickMath.maxUsableTick(tickSpacing))+ )+ );+ tickUpper = int24(+ bound(+ int256(tickUpper),+ int256(TickMath.minUsableTick(tickSpacing)),+ int256(TickMath.maxUsableTick(tickSpacing))+ )+ );++ // round down ticks+ tickLower = (tickLower / tickSpacing) * tickSpacing;+ tickUpper = (tickUpper / tickSpacing) * tickSpacing;++ (tickLower, tickUpper) = tickLower < tickUpper ? (tickLower, tickUpper) : (tickUpper, tickLower);++ if (tickLower == tickUpper) {+ if (tickLower != TickMath.minUsableTick(tickSpacing)) tickLower = tickLower - tickSpacing;+ else tickUpper = tickUpper + tickSpacing;+ }++ return (tickLower, tickUpper);+ }++ function boundTicks(PoolKey memory key, int24 tickLower, int24 tickUpper) internal pure returns (int24, int24) {+ return boundTicks(tickLower, tickUpper, key.tickSpacing);+ }++ function createRandomSqrtPriceX96(int24 tickSpacing, int256 seed) internal pure returns (uint160) {+ int256 min = int256(TickMath.minUsableTick(tickSpacing));+ int256 max = int256(TickMath.maxUsableTick(tickSpacing));+ int256 randomTick = bound(seed, min + 1, max - 1);+ return TickMath.getSqrtPriceAtTick(int24(randomTick));+ }++ /// @dev Obtain fuzzed and bounded parameters for creating liquidity+ /// @param key The pool key+ /// @param params IPoolManager.ModifyLiquidityParams Note that these parameters are unbounded+ /// @param sqrtPriceX96 The current sqrt price+ function createFuzzyLiquidityParams(+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ uint160 sqrtPriceX96+ ) internal pure returns (IPoolManager.ModifyLiquidityParams memory result) {+ (result.tickLower, result.tickUpper) = boundTicks(key, params.tickLower, params.tickUpper);+ int256 liquidityDeltaFromAmounts =+ getLiquidityDeltaFromAmounts(result.tickLower, result.tickUpper, sqrtPriceX96);+ result.liquidityDelta = boundLiquidityDelta(key, params.liquidityDelta, liquidityDeltaFromAmounts);+ }++ // Creates liquidity parameters with a stricter bound. Should be used if multiple positions being initialized on the pool, with potential for tick overlap.+ function createFuzzyLiquidityParamsWithTightBound(+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ uint160 sqrtPriceX96,+ uint256 maxPositions+ ) internal pure returns (IPoolManager.ModifyLiquidityParams memory result) {+ (result.tickLower, result.tickUpper) = boundTicks(key, params.tickLower, params.tickUpper);+ int256 liquidityDeltaFromAmounts =+ getLiquidityDeltaFromAmounts(result.tickLower, result.tickUpper, sqrtPriceX96);++ result.liquidityDelta =+ boundLiquidityDeltaTightly(key, params.liquidityDelta, liquidityDeltaFromAmounts, maxPositions);+ }++ function createFuzzyLiquidity(+ PoolModifyLiquidityTest modifyLiquidityRouter,+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ uint160 sqrtPriceX96,+ bytes memory hookData+ ) internal returns (IPoolManager.ModifyLiquidityParams memory result, BalanceDelta delta) {+ result = createFuzzyLiquidityParams(key, params, sqrtPriceX96);+ delta = modifyLiquidityRouter.modifyLiquidity(key, result, hookData);+ }++ // There exists possible positions in the pool, so we tighten the boundaries of liquidity.+ function createFuzzyLiquidityWithTightBound(+ PoolModifyLiquidityTest modifyLiquidityRouter,+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ uint160 sqrtPriceX96,+ bytes memory hookData,+ uint256 maxPositions+ ) internal returns (IPoolManager.ModifyLiquidityParams memory result, BalanceDelta delta) {+ result = createFuzzyLiquidityParamsWithTightBound(key, params, sqrtPriceX96, maxPositions);+ delta = modifyLiquidityRouter.modifyLiquidity(key, result, hookData);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/HooksTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/HooksTest.solnew file mode 100644index 000000000..1da6edf80--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/HooksTest.sol@@ -0,0 +1,73 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {Hooks} from "../libraries/Hooks.sol";+import {IHooks} from "../interfaces/IHooks.sol";++contract HooksTest {+ using Hooks for IHooks;++ function validateHookPermissions(address hookAddress, Hooks.Permissions calldata params) external pure {+ IHooks(hookAddress).validateHookPermissions(params);+ }++ function isValidHookAddress(address hookAddress, uint24 fee) external pure returns (bool) {+ return IHooks(hookAddress).isValidHookAddress(fee);+ }++ function shouldCallBeforeInitialize(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.BEFORE_INITIALIZE_FLAG);+ }++ function shouldCallAfterInitialize(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.AFTER_INITIALIZE_FLAG);+ }++ function shouldCallBeforeSwap(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.BEFORE_SWAP_FLAG);+ }++ function shouldCallAfterSwap(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.AFTER_SWAP_FLAG);+ }++ function shouldCallBeforeAddLiquidity(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.BEFORE_ADD_LIQUIDITY_FLAG);+ }++ function shouldCallAfterAddLiquidity(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.AFTER_ADD_LIQUIDITY_FLAG);+ }++ function shouldCallBeforeRemoveLiquidity(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.BEFORE_REMOVE_LIQUIDITY_FLAG);+ }++ function shouldCallAfterRemoveLiquidity(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.AFTER_REMOVE_LIQUIDITY_FLAG);+ }++ function shouldCallBeforeDonate(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.BEFORE_DONATE_FLAG);+ }++ function shouldCallAfterDonate(address hookAddress) external pure returns (bool) {+ return IHooks(hookAddress).hasPermission(Hooks.AFTER_DONATE_FLAG);+ }++ function getGasCostOfShouldCall(address hookAddress) external view returns (uint256) {+ uint256 gasBefore = gasleft();+ IHooks(hookAddress).hasPermission(Hooks.BEFORE_SWAP_FLAG);+ return gasBefore - gasleft();+ }++ function getGasCostOfValidateHookAddress(address hookAddress, Hooks.Permissions calldata params)+ external+ view+ returns (uint256)+ {+ uint256 gasBefore = gasleft();+ IHooks(hookAddress).validateHookPermissions(params);+ return gasBefore - gasleft();+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/LPFeeTakingHook.sol b/contracts/v4-hooks/lib/v4-core/src/test/LPFeeTakingHook.solnew file mode 100644index 000000000..e255e0dcd--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/LPFeeTakingHook.sol@@ -0,0 +1,64 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {Hooks} from "../libraries/Hooks.sol";+import {SafeCast} from "../libraries/SafeCast.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta, toBalanceDelta} from "../types/BalanceDelta.sol";+import {Currency} from "../types/Currency.sol";+import {BaseTestHooks} from "./BaseTestHooks.sol";++/// @notice a hook that takes all of the LP fee revenue+/// @dev an example test hook to validate the data is provided correctly+contract LPFeeTakingHook is BaseTestHooks {+ using Hooks for IHooks;+ using SafeCast for uint256;+ using SafeCast for int128;++ IPoolManager immutable manager;++ constructor(IPoolManager _manager) {+ manager = _manager;+ }++ modifier onlyPoolManager() {+ require(msg.sender == address(manager));+ _;+ }++ function afterRemoveLiquidity(+ address, /* sender **/+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata, /* params **/+ BalanceDelta,+ BalanceDelta feeDelta,+ bytes calldata /* hookData **/+ ) external override onlyPoolManager returns (bytes4, BalanceDelta) {+ uint128 feeAmount0 = uint128(feeDelta.amount0());+ uint128 feeAmount1 = uint128(feeDelta.amount1());++ if (0 < feeAmount0) manager.take(key.currency0, address(this), feeAmount0);+ if (0 < feeAmount1) manager.take(key.currency1, address(this), feeAmount1);++ return (IHooks.afterRemoveLiquidity.selector, toBalanceDelta(int128(feeAmount0), int128(feeAmount1)));+ }++ function afterAddLiquidity(+ address, /* sender **/+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata, /* params **/+ BalanceDelta,+ BalanceDelta feeDelta,+ bytes calldata /* hookData **/+ ) external override onlyPoolManager returns (bytes4, BalanceDelta) {+ uint128 feeAmount0 = uint128(feeDelta.amount0());+ uint128 feeAmount1 = uint128(feeDelta.amount1());++ if (0 < feeAmount0) manager.take(key.currency0, address(this), feeAmount0);+ if (0 < feeAmount1) manager.take(key.currency1, address(this), feeAmount1);++ return (IHooks.afterAddLiquidity.selector, toBalanceDelta(int128(feeAmount0), int128(feeAmount1)));+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/LiquidityMathTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/LiquidityMathTest.solnew file mode 100644index 000000000..6893917ea--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/LiquidityMathTest.sol@@ -0,0 +1,10 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {LiquidityMath} from "../libraries/LiquidityMath.sol";++contract LiquidityMathTest {+ function addDelta(uint128 x, int128 y) external pure returns (uint128 z) {+ return LiquidityMath.addDelta(x, y);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/MockContract.sol b/contracts/v4-hooks/lib/v4-core/src/test/MockContract.solnew file mode 100644index 000000000..450b4a080--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/MockContract.sol@@ -0,0 +1,57 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {Proxy} from "@openzeppelin/contracts/proxy/Proxy.sol";++/// @notice Mock contract that tracks the number of calls to various functions by selector+/// @dev allows for proxying to an implementation contract+/// if real logic or return values are needed+contract MockContract is Proxy {+ mapping(bytes32 => uint256) public calls;+ mapping(bytes32 => mapping(bytes => uint256)) public callParams;++ /// @notice If set, delegatecall to implementation after tracking call+ address internal impl;++ function timesCalledSelector(bytes32 selector) public view returns (uint256) {+ return calls[selector];+ }++ function timesCalled(string calldata fnSig) public view returns (uint256) {+ bytes32 selector = bytes32(uint256(keccak256(bytes(fnSig))) & (type(uint256).max << 224));+ return calls[selector];+ }++ function calledWithSelector(bytes32 selector, bytes calldata params) public view returns (bool) {+ return callParams[selector][params[1:]] > 0; // Drop 0x byte string prefix+ }++ function calledWith(string calldata fnSig, bytes calldata params) public view returns (bool) {+ bytes32 selector = bytes32(uint256(keccak256(bytes(fnSig))) & (type(uint256).max << 224));+ return callParams[selector][params[1:]] > 0; // Drop 0x byte string prefix+ }++ /// @notice exposes implementation contract address+ function _implementation() internal view override returns (address) {+ return impl;+ }++ function setImplementation(address _impl) external {+ impl = _impl;+ }++ /// @notice Captures calls by selector+ function _beforeFallback() internal {+ bytes32 selector = bytes32(msg.data[:5]);+ bytes memory params = msg.data[5:];+ calls[selector]++;+ callParams[selector][params]++;+ }++ function _fallback() internal override {+ _beforeFallback();+ super._fallback();+ }++ receive() external payable {}+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/MockERC6909Claims.sol b/contracts/v4-hooks/lib/v4-core/src/test/MockERC6909Claims.solnew file mode 100644index 000000000..17e6499cf--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/MockERC6909Claims.sol@@ -0,0 +1,22 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {ERC6909Claims} from "../ERC6909Claims.sol";++/// @notice Mock contract for testing ERC6909Claims+contract MockERC6909Claims is ERC6909Claims {+ /// @notice mocked mint logic+ function mint(address to, uint256 id, uint256 amount) public {+ _mint(to, id, amount);+ }++ /// @notice mocked burn logic+ function burn(uint256 id, uint256 amount) public {+ _burn(msg.sender, id, amount);+ }++ /// @notice mocked burn logic without checking sender allowance+ function burnFrom(address from, uint256 id, uint256 amount) public {+ _burnFrom(from, id, amount);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/MockHooks.sol b/contracts/v4-hooks/lib/v4-core/src/test/MockHooks.solnew file mode 100644index 000000000..8299ddfc8--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/MockHooks.sol@@ -0,0 +1,143 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {Hooks} from "../libraries/Hooks.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta, BalanceDeltaLibrary} from "../types/BalanceDelta.sol";+import {PoolId} from "../types/PoolId.sol";+import {BeforeSwapDelta, BeforeSwapDeltaLibrary} from "../types/BeforeSwapDelta.sol";++contract MockHooks is IHooks {+ using Hooks for IHooks;++ bytes public beforeInitializeData;+ bytes public afterInitializeData;+ bytes public beforeAddLiquidityData;+ bytes public afterAddLiquidityData;+ bytes public beforeRemoveLiquidityData;+ bytes public afterRemoveLiquidityData;+ bytes public beforeSwapData;+ bytes public afterSwapData;+ bytes public beforeDonateData;+ bytes public afterDonateData;++ mapping(bytes4 => bytes4) public returnValues;++ mapping(PoolId => uint16) public lpFees;++ function beforeInitialize(address, PoolKey calldata, uint160) external override returns (bytes4) {+ beforeInitializeData = new bytes(123);+ bytes4 selector = MockHooks.beforeInitialize.selector;+ return returnValues[selector] == bytes4(0) ? selector : returnValues[selector];+ }++ function afterInitialize(address, PoolKey calldata, uint160, int24) external override returns (bytes4) {+ afterInitializeData = new bytes(123);+ bytes4 selector = MockHooks.afterInitialize.selector;+ return returnValues[selector] == bytes4(0) ? selector : returnValues[selector];+ }++ function beforeAddLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ bytes calldata hookData+ ) external override returns (bytes4) {+ beforeAddLiquidityData = hookData;+ bytes4 selector = MockHooks.beforeAddLiquidity.selector;+ return returnValues[selector] == bytes4(0) ? selector : returnValues[selector];+ }++ function afterAddLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ BalanceDelta,+ BalanceDelta,+ bytes calldata hookData+ ) external override returns (bytes4, BalanceDelta) {+ afterAddLiquidityData = hookData;+ bytes4 selector = MockHooks.afterAddLiquidity.selector;+ return (returnValues[selector] == bytes4(0) ? selector : returnValues[selector], BalanceDeltaLibrary.ZERO_DELTA);+ }++ function beforeRemoveLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ bytes calldata hookData+ ) external override returns (bytes4) {+ beforeRemoveLiquidityData = hookData;+ bytes4 selector = MockHooks.beforeRemoveLiquidity.selector;+ return returnValues[selector] == bytes4(0) ? selector : returnValues[selector];+ }++ function afterRemoveLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ BalanceDelta,+ BalanceDelta,+ bytes calldata hookData+ ) external override returns (bytes4, BalanceDelta) {+ afterRemoveLiquidityData = hookData;+ bytes4 selector = MockHooks.afterRemoveLiquidity.selector;+ return (returnValues[selector] == bytes4(0) ? selector : returnValues[selector], BalanceDeltaLibrary.ZERO_DELTA);+ }++ function beforeSwap(address, PoolKey calldata, IPoolManager.SwapParams calldata, bytes calldata hookData)+ external+ override+ returns (bytes4, BeforeSwapDelta, uint24)+ {+ beforeSwapData = hookData;+ bytes4 selector = MockHooks.beforeSwap.selector;+ return (+ returnValues[selector] == bytes4(0) ? selector : returnValues[selector],+ BeforeSwapDeltaLibrary.ZERO_DELTA,+ 0+ );+ }++ function afterSwap(+ address,+ PoolKey calldata,+ IPoolManager.SwapParams calldata,+ BalanceDelta,+ bytes calldata hookData+ ) external override returns (bytes4, int128) {+ afterSwapData = hookData;+ bytes4 selector = MockHooks.afterSwap.selector;+ return (returnValues[selector] == bytes4(0) ? selector : returnValues[selector], 0);+ }++ function beforeDonate(address, PoolKey calldata, uint256, uint256, bytes calldata hookData)+ external+ override+ returns (bytes4)+ {+ beforeDonateData = hookData;+ bytes4 selector = MockHooks.beforeDonate.selector;+ return returnValues[selector] == bytes4(0) ? selector : returnValues[selector];+ }++ function afterDonate(address, PoolKey calldata, uint256, uint256, bytes calldata hookData)+ external+ override+ returns (bytes4)+ {+ afterDonateData = hookData;+ bytes4 selector = MockHooks.afterDonate.selector;+ return returnValues[selector] == bytes4(0) ? selector : returnValues[selector];+ }++ function setReturnValue(bytes4 key, bytes4 value) external {+ returnValues[key] = value;+ }++ function setlpFee(PoolKey calldata key, uint16 value) external {+ lpFees[key.toId()] = value;+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/NativeERC20.sol b/contracts/v4-hooks/lib/v4-core/src/test/NativeERC20.solnew file mode 100644index 000000000..ce1d6d31f--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/NativeERC20.sol@@ -0,0 +1,50 @@+// SPDX-License-Identifier: GPL-3.0-or-later+pragma solidity ^0.8.0;++import {Test} from "forge-std/Test.sol";++/// @dev This token contract simulates the ERC20 representation of a native token where on `transfer` and `transferFrom` the native balances are modified using a precompile+contract NativeERC20 is Test {+ string public name = "NativeERC20";+ string public symbol = "NERC20";+ uint8 public decimals = 18;++ event Approval(address indexed src, address indexed guy, uint256 wad);+ event Transfer(address indexed src, address indexed dst, uint256 wad);++ mapping(address => mapping(address => uint256)) public allowance;++ function totalSupply() public view returns (uint256) {+ return address(this).balance;+ }++ function approve(address guy, uint256 wad) public returns (bool) {+ allowance[msg.sender][guy] = wad;+ emit Approval(msg.sender, guy, wad);+ return true;+ }++ function transfer(address dst, uint256 wad) public returns (bool) {+ return transferFrom(msg.sender, dst, wad);+ }++ function transferFrom(address src, address dst, uint256 wad) public returns (bool) {+ require(src.balance >= wad);++ if (src != msg.sender && allowance[src][msg.sender] != type(uint256).max) {+ require(allowance[src][msg.sender] >= wad, "");+ allowance[src][msg.sender] -= wad;+ }++ vm.deal(src, src.balance - wad);+ vm.deal(dst, dst.balance + wad);++ emit Transfer(src, dst, wad);++ return true;+ }++ function balanceOf(address account) external view returns (uint256) {+ return account.balance;+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/NoDelegateCallTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/NoDelegateCallTest.solnew file mode 100644index 000000000..059790821--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/NoDelegateCallTest.sol@@ -0,0 +1,32 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {NoDelegateCall} from "../NoDelegateCall.sol";++contract NoDelegateCallTest is NoDelegateCall {+ function canBeDelegateCalled() public view returns (uint256) {+ return block.timestamp / 5;+ }++ function cannotBeDelegateCalled() public view noDelegateCall returns (uint256) {+ return block.timestamp / 5;+ }++ function getGasCostOfCanBeDelegateCalled() external view returns (uint256) {+ uint256 gasBefore = gasleft();+ canBeDelegateCalled();+ return gasBefore - gasleft();+ }++ function getGasCostOfCannotBeDelegateCalled() external view returns (uint256) {+ uint256 gasBefore = gasleft();+ cannotBeDelegateCalled();+ return gasBefore - gasleft();+ }++ function callsIntoNoDelegateCallFunction() external view {+ noDelegateCallPrivate();+ }++ function noDelegateCallPrivate() private view noDelegateCall {}+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/PoolClaimsTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/PoolClaimsTest.solnew file mode 100644index 000000000..bb1e3f464--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/PoolClaimsTest.sol@@ -0,0 +1,50 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {Currency} from "../types/Currency.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolTestBase} from "./PoolTestBase.sol";+import {SafeCast} from "../libraries/SafeCast.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";++contract PoolClaimsTest is PoolTestBase {+ using CurrencySettler for Currency;+ using SafeCast for uint256;++ constructor(IPoolManager _manager) PoolTestBase(_manager) {}++ struct CallbackData {+ address sender;+ address user;+ Currency currency;+ uint256 amount;+ bool deposit;+ }++ /// @notice Convert ERC20 into a claimable 6909+ function deposit(Currency currency, address user, uint256 amount) external payable {+ manager.unlock(abi.encode(CallbackData(msg.sender, user, currency, amount, true)));+ }++ /// @notice Redeem claimable 6909 for ERC20+ function withdraw(Currency currency, address user, uint256 amount) external payable {+ manager.unlock(abi.encode(CallbackData(msg.sender, user, currency, amount, false)));+ }++ function unlockCallback(bytes calldata rawData) external returns (bytes memory) {+ require(msg.sender == address(manager));++ CallbackData memory data = abi.decode(rawData, (CallbackData));++ if (data.deposit) {+ data.currency.take(manager, data.user, data.amount, true); // mint 6909+ data.currency.settle(manager, data.user, data.amount, false); // transfer ERC20+ } else {+ data.currency.settle(manager, data.user, data.amount, true); // burn 6909+ data.currency.take(manager, data.user, data.amount, false); // claim ERC20+ }++ return abi.encode(0);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/PoolDonateTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/PoolDonateTest.solnew file mode 100644index 000000000..79d417e17--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/PoolDonateTest.sol@@ -0,0 +1,68 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {Currency, CurrencyLibrary} from "../types/Currency.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {PoolTestBase} from "./PoolTestBase.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {Hooks} from "../libraries/Hooks.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";++contract PoolDonateTest is PoolTestBase {+ using CurrencySettler for Currency;+ using Hooks for IHooks;++ constructor(IPoolManager _manager) PoolTestBase(_manager) {}++ struct CallbackData {+ address sender;+ PoolKey key;+ uint256 amount0;+ uint256 amount1;+ bytes hookData;+ }++ function donate(PoolKey memory key, uint256 amount0, uint256 amount1, bytes memory hookData)+ external+ payable+ returns (BalanceDelta delta)+ {+ delta = abi.decode(+ manager.unlock(abi.encode(CallbackData(msg.sender, key, amount0, amount1, hookData))), (BalanceDelta)+ );++ uint256 ethBalance = address(this).balance;+ if (ethBalance > 0) {+ CurrencyLibrary.ADDRESS_ZERO.transfer(msg.sender, ethBalance);+ }+ }++ function unlockCallback(bytes calldata rawData) external returns (bytes memory) {+ require(msg.sender == address(manager));++ CallbackData memory data = abi.decode(rawData, (CallbackData));++ (,, int256 deltaBefore0) = _fetchBalances(data.key.currency0, data.sender, address(this));+ (,, int256 deltaBefore1) = _fetchBalances(data.key.currency1, data.sender, address(this));++ require(deltaBefore0 == 0, "deltaBefore0 is not 0");+ require(deltaBefore1 == 0, "deltaBefore1 is not 0");++ BalanceDelta delta = manager.donate(data.key, data.amount0, data.amount1, data.hookData);++ (,, int256 deltaAfter0) = _fetchBalances(data.key.currency0, data.sender, address(this));+ (,, int256 deltaAfter1) = _fetchBalances(data.key.currency1, data.sender, address(this));++ require(deltaAfter0 == -int256(data.amount0), "deltaAfter0 is not equal to -int256(data.amount0)");+ require(deltaAfter1 == -int256(data.amount1), "deltaAfter1 is not equal to -int256(data.amount1)");++ if (deltaAfter0 < 0) data.key.currency0.settle(manager, data.sender, uint256(-deltaAfter0), false);+ if (deltaAfter1 < 0) data.key.currency1.settle(manager, data.sender, uint256(-deltaAfter1), false);+ if (deltaAfter0 > 0) data.key.currency0.take(manager, data.sender, uint256(deltaAfter0), false);+ if (deltaAfter1 > 0) data.key.currency1.take(manager, data.sender, uint256(deltaAfter1), false);++ return abi.encode(delta);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/PoolEmptyUnlockTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/PoolEmptyUnlockTest.solnew file mode 100644index 000000000..d0eca3b5b--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/PoolEmptyUnlockTest.sol@@ -0,0 +1,25 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {IUnlockCallback} from "../interfaces/callback/IUnlockCallback.sol";++contract PoolEmptyUnlockTest is IUnlockCallback {+ event UnlockCallback();++ IPoolManager manager;++ constructor(IPoolManager _manager) {+ manager = _manager;+ }++ function unlock() external {+ manager.unlock("");+ }++ /// @notice Called by the pool manager on `msg.sender` when the manager is unlocked+ function unlockCallback(bytes calldata) external override returns (bytes memory) {+ emit UnlockCallback();+ return "";+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/PoolModifyLiquidityTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/PoolModifyLiquidityTest.solnew file mode 100644index 000000000..d345edaf0--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/PoolModifyLiquidityTest.sol@@ -0,0 +1,95 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {CurrencyLibrary, Currency} from "../types/Currency.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {PoolTestBase} from "./PoolTestBase.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {Hooks} from "../libraries/Hooks.sol";+import {LPFeeLibrary} from "../libraries/LPFeeLibrary.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";+import {StateLibrary} from "../libraries/StateLibrary.sol";++contract PoolModifyLiquidityTest is PoolTestBase {+ using CurrencySettler for Currency;+ using Hooks for IHooks;+ using LPFeeLibrary for uint24;+ using StateLibrary for IPoolManager;++ constructor(IPoolManager _manager) PoolTestBase(_manager) {}++ struct CallbackData {+ address sender;+ PoolKey key;+ IPoolManager.ModifyLiquidityParams params;+ bytes hookData;+ bool settleUsingBurn;+ bool takeClaims;+ }++ function modifyLiquidity(+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ bytes memory hookData+ ) external payable returns (BalanceDelta delta) {+ delta = modifyLiquidity(key, params, hookData, false, false);+ }++ function modifyLiquidity(+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ bytes memory hookData,+ bool settleUsingBurn,+ bool takeClaims+ ) public payable returns (BalanceDelta delta) {+ delta = abi.decode(+ manager.unlock(abi.encode(CallbackData(msg.sender, key, params, hookData, settleUsingBurn, takeClaims))),+ (BalanceDelta)+ );++ uint256 ethBalance = address(this).balance;+ if (ethBalance > 0) {+ CurrencyLibrary.ADDRESS_ZERO.transfer(msg.sender, ethBalance);+ }+ }++ function unlockCallback(bytes calldata rawData) external returns (bytes memory) {+ require(msg.sender == address(manager));++ CallbackData memory data = abi.decode(rawData, (CallbackData));++ (uint128 liquidityBefore,,) = manager.getPositionInfo(+ data.key.toId(), address(this), data.params.tickLower, data.params.tickUpper, data.params.salt+ );++ (BalanceDelta delta,) = manager.modifyLiquidity(data.key, data.params, data.hookData);++ (uint128 liquidityAfter,,) = manager.getPositionInfo(+ data.key.toId(), address(this), data.params.tickLower, data.params.tickUpper, data.params.salt+ );++ (,, int256 delta0) = _fetchBalances(data.key.currency0, data.sender, address(this));+ (,, int256 delta1) = _fetchBalances(data.key.currency1, data.sender, address(this));++ require(+ int128(liquidityBefore) + data.params.liquidityDelta == int128(liquidityAfter), "liquidity change incorrect"+ );++ if (data.params.liquidityDelta < 0) {+ assert(delta0 > 0 || delta1 > 0);+ assert(!(delta0 < 0 || delta1 < 0));+ } else if (data.params.liquidityDelta > 0) {+ assert(delta0 < 0 || delta1 < 0);+ assert(!(delta0 > 0 || delta1 > 0));+ }++ if (delta0 < 0) data.key.currency0.settle(manager, data.sender, uint256(-delta0), data.settleUsingBurn);+ if (delta1 < 0) data.key.currency1.settle(manager, data.sender, uint256(-delta1), data.settleUsingBurn);+ if (delta0 > 0) data.key.currency0.take(manager, data.sender, uint256(delta0), data.takeClaims);+ if (delta1 > 0) data.key.currency1.take(manager, data.sender, uint256(delta1), data.takeClaims);++ return abi.encode(delta);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/PoolModifyLiquidityTestNoChecks.sol b/contracts/v4-hooks/lib/v4-core/src/test/PoolModifyLiquidityTestNoChecks.solnew file mode 100644index 000000000..ab099b896--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/PoolModifyLiquidityTestNoChecks.sol@@ -0,0 +1,73 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {CurrencyLibrary, Currency} from "../types/Currency.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {PoolTestBase} from "./PoolTestBase.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {Hooks} from "../libraries/Hooks.sol";+import {LPFeeLibrary} from "../libraries/LPFeeLibrary.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";++contract PoolModifyLiquidityTestNoChecks is PoolTestBase {+ using CurrencySettler for Currency;+ using Hooks for IHooks;+ using LPFeeLibrary for uint24;++ constructor(IPoolManager _manager) PoolTestBase(_manager) {}++ struct CallbackData {+ address sender;+ PoolKey key;+ IPoolManager.ModifyLiquidityParams params;+ bytes hookData;+ bool settleUsingBurn;+ bool takeClaims;+ }++ function modifyLiquidity(+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ bytes memory hookData+ ) external payable returns (BalanceDelta delta) {+ delta = modifyLiquidity(key, params, hookData, false, false);+ }++ function modifyLiquidity(+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ bytes memory hookData,+ bool settleUsingBurn,+ bool takeClaims+ ) public payable returns (BalanceDelta delta) {+ delta = abi.decode(+ manager.unlock(abi.encode(CallbackData(msg.sender, key, params, hookData, settleUsingBurn, takeClaims))),+ (BalanceDelta)+ );++ uint256 ethBalance = address(this).balance;+ if (ethBalance > 0) {+ CurrencyLibrary.ADDRESS_ZERO.transfer(msg.sender, ethBalance);+ }+ }++ function unlockCallback(bytes calldata rawData) external returns (bytes memory) {+ require(msg.sender == address(manager));++ CallbackData memory data = abi.decode(rawData, (CallbackData));++ (BalanceDelta delta,) = manager.modifyLiquidity(data.key, data.params, data.hookData);++ int256 delta0 = delta.amount0();+ int256 delta1 = delta.amount1();++ if (delta0 < 0) data.key.currency0.settle(manager, data.sender, uint256(-delta0), data.settleUsingBurn);+ if (delta1 < 0) data.key.currency1.settle(manager, data.sender, uint256(-delta1), data.settleUsingBurn);+ if (delta0 > 0) data.key.currency0.take(manager, data.sender, uint256(delta0), data.takeClaims);+ if (delta1 > 0) data.key.currency1.take(manager, data.sender, uint256(delta1), data.takeClaims);++ return abi.encode(delta);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/PoolNestedActionsTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/PoolNestedActionsTest.solnew file mode 100644index 000000000..044ca0b71--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/PoolNestedActionsTest.sol@@ -0,0 +1,235 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {IUnlockCallback} from "../interfaces/callback/IUnlockCallback.sol";+import {PoolTestBase} from "./PoolTestBase.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {Constants} from "../../test/utils/Constants.sol";+import {Test} from "forge-std/Test.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {Currency} from "../types/Currency.sol";+import {PoolId} from "../types/PoolId.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";+import {StateLibrary} from "../libraries/StateLibrary.sol";+import {TransientStateLibrary} from "../libraries/TransientStateLibrary.sol";++enum Action {+ NESTED_SELF_UNLOCK,+ NESTED_EXECUTOR_UNLOCK,+ SWAP_AND_SETTLE,+ DONATE_AND_SETTLE,+ ADD_LIQUIDITY_AND_SETTLE,+ REMOVE_LIQUIDITY_AND_SETTLE,+ INITIALIZE+}++contract PoolNestedActionsTest is Test, IUnlockCallback {+ using StateLibrary for IPoolManager;+ using TransientStateLibrary for IPoolManager;++ IPoolManager manager;+ NestedActionExecutor public executor;+ address user;++ constructor(IPoolManager _manager) {+ manager = _manager;+ user = msg.sender;+ executor = new NestedActionExecutor(manager, user);+ }++ function unlock(bytes calldata data) external {+ manager.unlock(data);+ }++ /// @notice Called by the pool manager on `msg.sender` when the manager is unlocked+ function unlockCallback(bytes calldata data) external override returns (bytes memory) {+ Action[] memory actions = abi.decode(data, (Action[]));+ if (actions.length == 1 && actions[0] == Action.NESTED_SELF_UNLOCK) {+ _nestedUnlock();+ } else {+ executor.execute(actions);+ }+ return "";+ }++ function _nestedUnlock() internal {+ bool unlocked = manager.isUnlocked();+ assertEq(unlocked, true);+ vm.expectRevert(abi.encodeWithSelector(IPoolManager.AlreadyUnlocked.selector));+ manager.unlock("");+ unlocked = manager.isUnlocked();+ assertEq(unlocked, true);+ }+}++contract NestedActionExecutor is Test, PoolTestBase {+ using StateLibrary for IPoolManager;+ using TransientStateLibrary for IPoolManager;+ using CurrencySettler for Currency;++ PoolKey internal key;+ address user;++ error KeyNotSet();++ IPoolManager.ModifyLiquidityParams internal ADD_LIQUIDITY_PARAMS =+ IPoolManager.ModifyLiquidityParams({tickLower: -120, tickUpper: 120, liquidityDelta: 1e18, salt: 0});++ IPoolManager.ModifyLiquidityParams internal REMOVE_LIQUIDITY_PARAMS =+ IPoolManager.ModifyLiquidityParams({tickLower: -120, tickUpper: 120, liquidityDelta: -1e18, salt: 0});++ IPoolManager.SwapParams internal SWAP_PARAMS =+ IPoolManager.SwapParams({zeroForOne: true, amountSpecified: -100, sqrtPriceLimitX96: Constants.SQRT_PRICE_1_2});++ uint256 internal DONATE_AMOUNT0 = 12345e6;+ uint256 internal DONATE_AMOUNT1 = 98765e4;++ constructor(IPoolManager _manager, address _user) PoolTestBase(_manager) {+ user = _user;+ }++ function setKey(PoolKey memory _key) external {+ key = _key;+ }++ function execute(Action[] memory actions) public {+ if (Currency.unwrap(key.currency0) == address(0)) revert KeyNotSet();+ for (uint256 i = 0; i < actions.length; i++) {+ Action action = actions[i];+ if (action == Action.NESTED_EXECUTOR_UNLOCK) _nestedUnlock();+ else if (action == Action.SWAP_AND_SETTLE) _swap(msg.sender);+ else if (action == Action.ADD_LIQUIDITY_AND_SETTLE) _addLiquidity(msg.sender);+ else if (action == Action.REMOVE_LIQUIDITY_AND_SETTLE) _removeLiquidity(msg.sender);+ else if (action == Action.DONATE_AND_SETTLE) _donate(msg.sender);+ else if (action == Action.INITIALIZE) _initialize();+ }+ }++ function _nestedUnlock() internal {+ bool unlocked = manager.isUnlocked();+ assertEq(unlocked, true);+ vm.expectRevert(abi.encodeWithSelector(IPoolManager.AlreadyUnlocked.selector));+ manager.unlock("");+ unlocked = manager.isUnlocked();+ assertEq(unlocked, true);+ }++ function _swap(address caller) internal {+ bool unlocked = manager.isUnlocked();+ assertEq(unlocked, true);+ (,, int256 deltaCallerBefore0) = _fetchBalances(key.currency0, user, caller);+ (,, int256 deltaCallerBefore1) = _fetchBalances(key.currency1, user, caller);+ (,, int256 deltaThisBefore0) = _fetchBalances(key.currency0, user, address(this));+ (,, int256 deltaThisBefore1) = _fetchBalances(key.currency1, user, address(this));++ BalanceDelta delta = manager.swap(key, SWAP_PARAMS, "");++ (,, int256 deltaCallerAfter0) = _fetchBalances(key.currency0, user, caller);+ (,, int256 deltaCallerAfter1) = _fetchBalances(key.currency1, user, caller);+ (,, int256 deltaThisAfter0) = _fetchBalances(key.currency0, user, address(this));+ (,, int256 deltaThisAfter1) = _fetchBalances(key.currency1, user, address(this));++ assertEq(deltaCallerBefore0, deltaCallerAfter0, "Caller delta 0");+ assertEq(deltaCallerBefore1, deltaCallerAfter1, "Caller delta 1");+ assertEq(deltaThisBefore0 + SWAP_PARAMS.amountSpecified, deltaThisAfter0, "Executor delta 0");+ assertEq(deltaThisBefore1 + 98, deltaThisAfter1, "Executor delta 1");+ assertEq(delta.amount0(), deltaThisAfter0, "Swap delta 0");+ assertEq(delta.amount1(), deltaThisAfter1, "Swap delta 1");++ key.currency0.settle(manager, user, uint256(-deltaThisAfter0), false);+ key.currency1.take(manager, user, uint256(deltaThisAfter1), false);+ }++ function _addLiquidity(address caller) internal {+ bool unlocked = manager.isUnlocked();+ assertEq(unlocked, true);+ (,, int256 deltaCallerBefore0) = _fetchBalances(key.currency0, user, caller);+ (,, int256 deltaCallerBefore1) = _fetchBalances(key.currency1, user, caller);+ (,, int256 deltaThisBefore0) = _fetchBalances(key.currency0, user, address(this));+ (,, int256 deltaThisBefore1) = _fetchBalances(key.currency1, user, address(this));++ (BalanceDelta delta,) = manager.modifyLiquidity(key, ADD_LIQUIDITY_PARAMS, "");++ (,, int256 deltaCallerAfter0) = _fetchBalances(key.currency0, user, caller);+ (,, int256 deltaCallerAfter1) = _fetchBalances(key.currency1, user, caller);+ (,, int256 deltaThisAfter0) = _fetchBalances(key.currency0, user, address(this));+ (,, int256 deltaThisAfter1) = _fetchBalances(key.currency1, user, address(this));++ assertEq(deltaCallerBefore0, deltaCallerAfter0, "Caller delta 0");+ assertEq(deltaCallerBefore1, deltaCallerAfter1, "Caller delta 1");+ assertEq(deltaThisBefore0 + delta.amount0(), deltaThisAfter0, "Executor delta 0");+ assertEq(deltaThisBefore1 + delta.amount1(), deltaThisAfter1, "Executor delta 1");++ key.currency0.settle(manager, user, uint256(-deltaThisAfter0), false);+ key.currency1.settle(manager, user, uint256(-deltaThisAfter1), false);+ }++ // cannot remove non-existent liquidity - need to perform an add before this removal+ function _removeLiquidity(address caller) internal {+ bool unlocked = manager.isUnlocked();+ assertEq(unlocked, true);+ (,, int256 deltaCallerBefore0) = _fetchBalances(key.currency0, user, caller);+ (,, int256 deltaCallerBefore1) = _fetchBalances(key.currency1, user, caller);+ (,, int256 deltaThisBefore0) = _fetchBalances(key.currency0, user, address(this));+ (,, int256 deltaThisBefore1) = _fetchBalances(key.currency1, user, address(this));++ (BalanceDelta delta,) = manager.modifyLiquidity(key, REMOVE_LIQUIDITY_PARAMS, "");++ (,, int256 deltaCallerAfter0) = _fetchBalances(key.currency0, user, caller);+ (,, int256 deltaCallerAfter1) = _fetchBalances(key.currency1, user, caller);+ (,, int256 deltaThisAfter0) = _fetchBalances(key.currency0, user, address(this));+ (,, int256 deltaThisAfter1) = _fetchBalances(key.currency1, user, address(this));++ assertEq(deltaCallerBefore0, deltaCallerAfter0, "Caller delta 0");+ assertEq(deltaCallerBefore1, deltaCallerAfter1, "Caller delta 1");+ assertEq(deltaThisBefore0 + delta.amount0(), deltaThisAfter0, "Executor delta 0");+ assertEq(deltaThisBefore1 + delta.amount1(), deltaThisAfter1, "Executor delta 1");++ key.currency0.take(manager, user, uint256(deltaThisAfter0), false);+ key.currency1.take(manager, user, uint256(deltaThisAfter1), false);+ }++ function _donate(address caller) internal {+ bool unlocked = manager.isUnlocked();+ assertEq(unlocked, true);+ (,, int256 deltaCallerBefore0) = _fetchBalances(key.currency0, user, caller);+ (,, int256 deltaCallerBefore1) = _fetchBalances(key.currency1, user, caller);+ (,, int256 deltaThisBefore0) = _fetchBalances(key.currency0, user, address(this));+ (,, int256 deltaThisBefore1) = _fetchBalances(key.currency1, user, address(this));++ BalanceDelta delta = manager.donate(key, DONATE_AMOUNT0, DONATE_AMOUNT1, "");++ (,, int256 deltaCallerAfter0) = _fetchBalances(key.currency0, user, caller);+ (,, int256 deltaCallerAfter1) = _fetchBalances(key.currency1, user, caller);+ (,, int256 deltaThisAfter0) = _fetchBalances(key.currency0, user, address(this));+ (,, int256 deltaThisAfter1) = _fetchBalances(key.currency1, user, address(this));++ assertEq(deltaCallerBefore0, deltaCallerAfter0, "Caller delta 0");+ assertEq(deltaCallerBefore1, deltaCallerAfter1, "Caller delta 1");+ assertEq(deltaThisBefore0 - int256(DONATE_AMOUNT0), deltaThisAfter0, "Executor delta 0");+ assertEq(deltaThisBefore1 - int256(DONATE_AMOUNT1), deltaThisAfter1, "Executor delta 1");+ assertEq(-delta.amount0(), int256(DONATE_AMOUNT0), "Donate delta 0");+ assertEq(-delta.amount1(), int256(DONATE_AMOUNT1), "Donate delta 1");++ key.currency0.settle(manager, user, uint256(-deltaThisAfter0), false);+ key.currency1.settle(manager, user, uint256(-deltaThisAfter1), false);+ }++ function _initialize() internal {+ bool unlocked = manager.isUnlocked();+ assertEq(unlocked, true);+ key.tickSpacing = 50;+ PoolId id = key.toId();+ (uint256 price,,,) = manager.getSlot0(id);+ assertEq(price, 0);+ manager.initialize(key, Constants.SQRT_PRICE_1_2);+ (price,,,) = manager.getSlot0(id);+ assertEq(price, Constants.SQRT_PRICE_1_2);+ }++ // This will never actually be used - its just to allow us to use the PoolTestBase helper contact+ function unlockCallback(bytes calldata) external pure override returns (bytes memory) {+ return "";+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/PoolSwapTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/PoolSwapTest.solnew file mode 100644index 000000000..14c926d65--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/PoolSwapTest.sol@@ -0,0 +1,117 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {CurrencyLibrary, Currency} from "../types/Currency.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {Hooks} from "../libraries/Hooks.sol";+import {PoolTestBase} from "./PoolTestBase.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";++contract PoolSwapTest is PoolTestBase {+ using CurrencySettler for Currency;+ using Hooks for IHooks;++ constructor(IPoolManager _manager) PoolTestBase(_manager) {}++ error NoSwapOccurred();++ struct CallbackData {+ address sender;+ TestSettings testSettings;+ PoolKey key;+ IPoolManager.SwapParams params;+ bytes hookData;+ }++ struct TestSettings {+ bool takeClaims;+ bool settleUsingBurn;+ }++ function swap(+ PoolKey memory key,+ IPoolManager.SwapParams memory params,+ TestSettings memory testSettings,+ bytes memory hookData+ ) external payable returns (BalanceDelta delta) {+ delta = abi.decode(+ manager.unlock(abi.encode(CallbackData(msg.sender, testSettings, key, params, hookData))), (BalanceDelta)+ );++ uint256 ethBalance = address(this).balance;+ if (ethBalance > 0) CurrencyLibrary.ADDRESS_ZERO.transfer(msg.sender, ethBalance);+ }++ function unlockCallback(bytes calldata rawData) external returns (bytes memory) {+ require(msg.sender == address(manager));++ CallbackData memory data = abi.decode(rawData, (CallbackData));++ (,, int256 deltaBefore0) = _fetchBalances(data.key.currency0, data.sender, address(this));+ (,, int256 deltaBefore1) = _fetchBalances(data.key.currency1, data.sender, address(this));++ require(deltaBefore0 == 0, "deltaBefore0 is not equal to 0");+ require(deltaBefore1 == 0, "deltaBefore1 is not equal to 0");++ BalanceDelta delta = manager.swap(data.key, data.params, data.hookData);++ (,, int256 deltaAfter0) = _fetchBalances(data.key.currency0, data.sender, address(this));+ (,, int256 deltaAfter1) = _fetchBalances(data.key.currency1, data.sender, address(this));++ if (data.params.zeroForOne) {+ if (data.params.amountSpecified < 0) {+ // exact input, 0 for 1+ require(+ deltaAfter0 >= data.params.amountSpecified,+ "deltaAfter0 is not greater than or equal to data.params.amountSpecified"+ );+ require(delta.amount0() == deltaAfter0, "delta.amount0() is not equal to deltaAfter0");+ require(deltaAfter1 >= 0, "deltaAfter1 is not greater than or equal to 0");+ } else {+ // exact output, 0 for 1+ require(deltaAfter0 <= 0, "deltaAfter0 is not less than or equal to zero");+ require(delta.amount1() == deltaAfter1, "delta.amount1() is not equal to deltaAfter1");+ require(+ deltaAfter1 <= data.params.amountSpecified,+ "deltaAfter1 is not less than or equal to data.params.amountSpecified"+ );+ }+ } else {+ if (data.params.amountSpecified < 0) {+ // exact input, 1 for 0+ require(+ deltaAfter1 >= data.params.amountSpecified,+ "deltaAfter1 is not greater than or equal to data.params.amountSpecified"+ );+ require(delta.amount1() == deltaAfter1, "delta.amount1() is not equal to deltaAfter1");+ require(deltaAfter0 >= 0, "deltaAfter0 is not greater than or equal to 0");+ } else {+ // exact output, 1 for 0+ require(deltaAfter1 <= 0, "deltaAfter1 is not less than or equal to 0");+ require(delta.amount0() == deltaAfter0, "delta.amount0() is not equal to deltaAfter0");+ require(+ deltaAfter0 <= data.params.amountSpecified,+ "deltaAfter0 is not less than or equal to data.params.amountSpecified"+ );+ }+ }++ if (deltaAfter0 < 0) {+ data.key.currency0.settle(manager, data.sender, uint256(-deltaAfter0), data.testSettings.settleUsingBurn);+ }+ if (deltaAfter1 < 0) {+ data.key.currency1.settle(manager, data.sender, uint256(-deltaAfter1), data.testSettings.settleUsingBurn);+ }+ if (deltaAfter0 > 0) {+ data.key.currency0.take(manager, data.sender, uint256(deltaAfter0), data.testSettings.takeClaims);+ }+ if (deltaAfter1 > 0) {+ data.key.currency1.take(manager, data.sender, uint256(deltaAfter1), data.testSettings.takeClaims);+ }++ return abi.encode(delta);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/PoolTakeTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/PoolTakeTest.solnew file mode 100644index 000000000..bf66e62c9--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/PoolTakeTest.sol@@ -0,0 +1,61 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {Currency} from "../types/Currency.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {PoolTestBase} from "./PoolTestBase.sol";+import {SafeCast} from "../libraries/SafeCast.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";++contract PoolTakeTest is PoolTestBase {+ using CurrencySettler for Currency;+ using SafeCast for uint256;++ constructor(IPoolManager _manager) PoolTestBase(_manager) {}++ struct CallbackData {+ address sender;+ PoolKey key;+ uint256 amount0;+ uint256 amount1;+ }++ function take(PoolKey memory key, uint256 amount0, uint256 amount1) external payable {+ manager.unlock(abi.encode(CallbackData(msg.sender, key, amount0, amount1)));+ }++ function unlockCallback(bytes calldata rawData) external returns (bytes memory) {+ require(msg.sender == address(manager));++ CallbackData memory data = abi.decode(rawData, (CallbackData));++ if (data.amount0 > 0) _testTake(data.key.currency0, data.sender, data.amount0);+ if (data.amount1 > 0) _testTake(data.key.currency1, data.sender, data.amount1);++ return abi.encode(0);+ }++ function _testTake(Currency currency, address sender, uint256 amount) internal {+ (uint256 userBalBefore, uint256 pmBalBefore, int256 deltaBefore) =+ _fetchBalances(currency, sender, address(this));+ require(deltaBefore == 0, "deltaBefore is not equal to 0");++ currency.take(manager, sender, amount, false);++ (uint256 userBalAfter, uint256 pmBalAfter, int256 deltaAfter) = _fetchBalances(currency, sender, address(this));++ require(deltaAfter == -amount.toInt128(), "deltaAfter is not equal to -amount.toInt128()");++ require(+ userBalAfter - userBalBefore == amount,+ "the difference between userBalAfter and userBalBefore is not equal to amount"+ );+ require(+ pmBalBefore - pmBalAfter == amount,+ "the difference between pmBalBefore and pmBalAfter is not equal to amount"+ );++ currency.settle(manager, sender, amount, false);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/PoolTestBase.sol b/contracts/v4-hooks/lib/v4-core/src/test/PoolTestBase.solnew file mode 100644index 000000000..f73bb6a1b--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/PoolTestBase.sol@@ -0,0 +1,31 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {Currency} from "../types/Currency.sol";++import {IUnlockCallback} from "../interfaces/callback/IUnlockCallback.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";++import {StateLibrary} from "../libraries/StateLibrary.sol";+import {TransientStateLibrary} from "../libraries/TransientStateLibrary.sol";++abstract contract PoolTestBase is IUnlockCallback {+ using StateLibrary for IPoolManager;+ using TransientStateLibrary for IPoolManager;++ IPoolManager public immutable manager;++ constructor(IPoolManager _manager) {+ manager = _manager;+ }++ function _fetchBalances(Currency currency, address user, address deltaHolder)+ internal+ view+ returns (uint256 userBalance, uint256 poolBalance, int256 delta)+ {+ userBalance = currency.balanceOf(user);+ poolBalance = currency.balanceOf(address(manager));+ delta = manager.currencyDelta(deltaHolder, currency);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/ProtocolFeesImplementation.sol b/contracts/v4-hooks/lib/v4-core/src/test/ProtocolFeesImplementation.solnew file mode 100644index 000000000..f26ac849e--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/ProtocolFeesImplementation.sol@@ -0,0 +1,38 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {ProtocolFees} from "../ProtocolFees.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {Currency} from "../types/Currency.sol";+import {PoolId} from "../types/PoolId.sol";+import {Pool} from "../libraries/Pool.sol";+import {Slot0} from "../types/Slot0.sol";++contract ProtocolFeesImplementation is ProtocolFees {+ mapping(PoolId id => Pool.State) internal _pools;+ bool internal isUnlocked;++ constructor() ProtocolFees(msg.sender) {}++ // Used to set the price of a pool to pretend that the pool has been initialized in order to successfully set a protocol fee+ function setPrice(PoolKey memory key, uint160 sqrtPriceX96) public {+ Pool.State storage pool = _getPool(key.toId());+ pool.slot0 = pool.slot0.setSqrtPriceX96(sqrtPriceX96);+ }++ function _getPool(PoolId id) internal view override returns (Pool.State storage) {+ return _pools[id];+ }++ function setIsUnlocked(bool newValue) public {+ isUnlocked = newValue;+ }++ function _isUnlocked() internal view override returns (bool) {+ return isUnlocked;+ }++ function updateProtocolFees(Currency currency, uint256 amount) public {+ ProtocolFees._updateProtocolFees(currency, amount);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/ProxyPoolManager.sol b/contracts/v4-hooks/lib/v4-core/src/test/ProxyPoolManager.solnew file mode 100644index 000000000..44a631ec5--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/ProxyPoolManager.sol@@ -0,0 +1,220 @@+// SPDX-License-Identifier: BUSL-1.1+pragma solidity ^0.8.24;++import {Hooks} from "../libraries/Hooks.sol";+import {Pool} from "../libraries/Pool.sol";+import {SafeCast} from "../libraries/SafeCast.sol";+import {Position} from "../libraries/Position.sol";+import {LPFeeLibrary} from "../libraries/LPFeeLibrary.sol";+import {Currency} from "../types/Currency.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {TickMath} from "../libraries/TickMath.sol";+import {NoDelegateCall} from "../NoDelegateCall.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {IUnlockCallback} from "../interfaces/callback/IUnlockCallback.sol";+import {ProtocolFees} from "../ProtocolFees.sol";+import {ERC6909Claims} from "../ERC6909Claims.sol";+import {PoolId} from "../types/PoolId.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {Lock} from "../libraries/Lock.sol";+import {CurrencyDelta} from "../libraries/CurrencyDelta.sol";+import {NonzeroDeltaCount} from "../libraries/NonzeroDeltaCount.sol";+import {CurrencyReserves} from "../libraries/CurrencyReserves.sol";+import {Extsload} from "../Extsload.sol";+import {Exttload} from "../Exttload.sol";+import {CustomRevert} from "../libraries/CustomRevert.sol";++/// @notice A proxy pool manager that delegates calls to the real/delegate pool manager+contract ProxyPoolManager is IPoolManager, ProtocolFees, NoDelegateCall, ERC6909Claims, Extsload, Exttload {+ using SafeCast for *;+ using Pool for *;+ using Hooks for IHooks;+ using CurrencyDelta for Currency;+ using LPFeeLibrary for uint24;+ using CurrencyReserves for Currency;+ using CustomRevert for bytes4;++ int24 private constant MAX_TICK_SPACING = TickMath.MAX_TICK_SPACING;++ int24 private constant MIN_TICK_SPACING = TickMath.MIN_TICK_SPACING;++ mapping(PoolId id => Pool.State) internal _pools;++ address internal immutable _delegateManager;++ constructor(address delegateManager) ProtocolFees(msg.sender) {+ _delegateManager = delegateManager;+ }++ /// @notice This will revert if the contract is locked+ modifier onlyWhenUnlocked() {+ if (!Lock.isUnlocked()) ManagerLocked.selector.revertWith();+ _;+ }++ /// @inheritdoc IPoolManager+ function unlock(bytes calldata data) external noDelegateCall returns (bytes memory result) {+ if (Lock.isUnlocked()) AlreadyUnlocked.selector.revertWith();++ Lock.unlock();++ // the caller does everything in this callback, including paying what they owe via calls to settle+ result = IUnlockCallback(msg.sender).unlockCallback(data);++ if (NonzeroDeltaCount.read() != 0) CurrencyNotSettled.selector.revertWith();+ Lock.lock();+ }++ /// @inheritdoc IPoolManager+ function initialize(PoolKey memory key, uint160 sqrtPriceX96) external noDelegateCall returns (int24 tick) {+ // see TickBitmap.sol for overflow conditions that can arise from tick spacing being too large+ if (key.tickSpacing > MAX_TICK_SPACING) TickSpacingTooLarge.selector.revertWith(key.tickSpacing);+ if (key.tickSpacing < MIN_TICK_SPACING) TickSpacingTooSmall.selector.revertWith(key.tickSpacing);+ if (key.currency0 >= key.currency1) {+ CurrenciesOutOfOrderOrEqual.selector.revertWith(+ Currency.unwrap(key.currency0), Currency.unwrap(key.currency1)+ );+ }+ if (!key.hooks.isValidHookAddress(key.fee)) Hooks.HookAddressNotValid.selector.revertWith(address(key.hooks));++ uint24 lpFee = key.fee.getInitialLPFee();++ key.hooks.beforeInitialize(key, sqrtPriceX96);++ PoolId id = key.toId();++ tick = _pools[id].initialize(sqrtPriceX96, lpFee);++ key.hooks.afterInitialize(key, sqrtPriceX96, tick);++ // emit all details of a pool key. poolkeys are not saved in storage and must always be provided by the caller+ // the key's fee may be a static fee or a sentinel to denote a dynamic fee.+ emit Initialize(id, key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks, sqrtPriceX96, tick);+ }++ /// @inheritdoc IPoolManager+ function modifyLiquidity(+ PoolKey memory key,+ IPoolManager.ModifyLiquidityParams memory params,+ bytes calldata hookData+ ) external onlyWhenUnlocked noDelegateCall returns (BalanceDelta callerDelta, BalanceDelta feesAccrued) {+ bytes memory result = _delegateCall(+ _delegateManager, abi.encodeWithSelector(this.modifyLiquidity.selector, key, params, hookData)+ );++ return abi.decode(result, (BalanceDelta, BalanceDelta));+ }++ /// @inheritdoc IPoolManager+ function swap(PoolKey memory key, IPoolManager.SwapParams memory params, bytes calldata hookData)+ external+ onlyWhenUnlocked+ noDelegateCall+ returns (BalanceDelta swapDelta)+ {+ bytes memory result =+ _delegateCall(_delegateManager, abi.encodeWithSelector(this.swap.selector, key, params, hookData));++ return abi.decode(result, (BalanceDelta));+ }++ /// @inheritdoc IPoolManager+ function donate(PoolKey memory key, uint256 amount0, uint256 amount1, bytes calldata hookData)+ external+ onlyWhenUnlocked+ noDelegateCall+ returns (BalanceDelta delta)+ {+ bytes memory result = _delegateCall(+ _delegateManager, abi.encodeWithSelector(this.donate.selector, key, amount0, amount1, hookData)+ );++ return abi.decode(result, (BalanceDelta));+ }++ /// @inheritdoc IPoolManager+ function sync(Currency currency) public {+ // address(0) is used for the native currency+ if (currency.isAddressZero()) {+ // The reserves balance is not used for native settling, so we only need to reset the currency.+ CurrencyReserves.resetCurrency();+ } else {+ uint256 balance = currency.balanceOfSelf();+ CurrencyReserves.syncCurrencyAndReserves(currency, balance);+ }+ }++ /// @inheritdoc IPoolManager+ function take(Currency currency, address to, uint256 amount) external onlyWhenUnlocked noDelegateCall {+ _delegateCall(_delegateManager, abi.encodeWithSelector(this.take.selector, currency, to, amount));+ }++ /// @inheritdoc IPoolManager+ function settle() external payable onlyWhenUnlocked noDelegateCall returns (uint256 paid) {+ bytes memory result = _delegateCall(_delegateManager, abi.encodeWithSelector(this.settle.selector));++ return abi.decode(result, (uint256));+ }++ /// @inheritdoc IPoolManager+ function settleFor(address recipient) external payable onlyWhenUnlocked noDelegateCall returns (uint256 paid) {+ bytes memory result =+ _delegateCall(_delegateManager, abi.encodeWithSelector(this.settleFor.selector, recipient));++ return abi.decode(result, (uint256));+ }++ /// @inheritdoc IPoolManager+ function clear(Currency currency, uint256 amount) external onlyWhenUnlocked {+ _delegateCall(_delegateManager, abi.encodeWithSelector(this.clear.selector, currency, amount));+ }++ /// @inheritdoc IPoolManager+ function mint(address to, uint256 id, uint256 amount) external onlyWhenUnlocked noDelegateCall {+ _delegateCall(_delegateManager, abi.encodeWithSelector(this.mint.selector, to, id, amount));+ }++ /// @inheritdoc IPoolManager+ function burn(address from, uint256 id, uint256 amount) external onlyWhenUnlocked noDelegateCall {+ _delegateCall(_delegateManager, abi.encodeWithSelector(this.burn.selector, from, id, amount));+ }++ /// @inheritdoc IPoolManager+ function updateDynamicLPFee(PoolKey memory key, uint24 newDynamicLPFee) external {+ if (!key.fee.isDynamicFee() || msg.sender != address(key.hooks)) {+ UnauthorizedDynamicLPFeeUpdate.selector.revertWith();+ }+ newDynamicLPFee.validate();+ PoolId id = key.toId();+ _pools[id].setLPFee(newDynamicLPFee);+ }++ /// @notice Make a delegate call, bubble up any error or return the result+ function _delegateCall(address target, bytes memory data) internal returns (bytes memory result) {+ (bool success, bytes memory returnData) = target.delegatecall(data);++ if (!success) {+ if (returnData.length == 0) {+ revert();+ } else {+ assembly {+ let size := mload(returnData)+ revert(add(32, returnData), size)+ }+ }+ }++ return returnData;+ }++ /// @notice Implementation of the _getPool function defined in ProtocolFees+ function _getPool(PoolId id) internal view override returns (Pool.State storage) {+ return _pools[id];+ }++ /// @notice Implementation of the _isUnlocked function defined in ProtocolFees+ function _isUnlocked() internal view override returns (bool) {+ return Lock.isUnlocked();+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/SkipCallsTestHook.sol b/contracts/v4-hooks/lib/v4-core/src/test/SkipCallsTestHook.solnew file mode 100644index 000000000..d6021bdf9--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/SkipCallsTestHook.sol@@ -0,0 +1,200 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {Hooks} from "../libraries/Hooks.sol";+import {BaseTestHooks} from "./BaseTestHooks.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {BalanceDelta, BalanceDeltaLibrary} from "../types/BalanceDelta.sol";+import {Currency} from "../types/Currency.sol";+import {Test} from "forge-std/Test.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";+import {StateLibrary} from "../libraries/StateLibrary.sol";+import {TransientStateLibrary} from "../libraries/TransientStateLibrary.sol";+import {BeforeSwapDelta, BeforeSwapDeltaLibrary} from "../types/BeforeSwapDelta.sol";++contract SkipCallsTestHook is BaseTestHooks, Test {+ using CurrencySettler for Currency;+ using Hooks for IHooks;+ using StateLibrary for IPoolManager;+ using TransientStateLibrary for IPoolManager;++ uint256 public counter;+ IPoolManager manager;++ function setManager(IPoolManager _manager) external {+ manager = _manager;+ }++ function beforeInitialize(address, PoolKey calldata key, uint160 sqrtPriceX96) external override returns (bytes4) {+ counter++;+ _initialize(key, sqrtPriceX96);+ return IHooks.beforeInitialize.selector;+ }++ function afterInitialize(address, PoolKey calldata key, uint160 sqrtPriceX96, int24)+ external+ override+ returns (bytes4)+ {+ counter++;+ _initialize(key, sqrtPriceX96);+ return IHooks.afterInitialize.selector;+ }++ function beforeAddLiquidity(+ address,+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata params,+ bytes calldata hookData+ ) external override returns (bytes4) {+ counter++;+ _addLiquidity(key, params, hookData);+ return IHooks.beforeAddLiquidity.selector;+ }++ function afterAddLiquidity(+ address,+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata params,+ BalanceDelta,+ BalanceDelta,+ bytes calldata hookData+ ) external override returns (bytes4, BalanceDelta) {+ counter++;+ _addLiquidity(key, params, hookData);+ return (IHooks.afterAddLiquidity.selector, BalanceDeltaLibrary.ZERO_DELTA);+ }++ function beforeRemoveLiquidity(+ address,+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata params,+ bytes calldata hookData+ ) external override returns (bytes4) {+ counter++;+ _removeLiquidity(key, params, hookData);+ return IHooks.beforeRemoveLiquidity.selector;+ }++ function afterRemoveLiquidity(+ address,+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams calldata params,+ BalanceDelta,+ BalanceDelta,+ bytes calldata hookData+ ) external override returns (bytes4, BalanceDelta) {+ counter++;+ _removeLiquidity(key, params, hookData);+ return (IHooks.afterRemoveLiquidity.selector, BalanceDeltaLibrary.ZERO_DELTA);+ }++ function beforeSwap(address, PoolKey calldata key, IPoolManager.SwapParams calldata params, bytes calldata hookData)+ external+ override+ returns (bytes4, BeforeSwapDelta, uint24)+ {+ counter++;+ _swap(key, params, hookData);+ return (IHooks.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, 0);+ }++ function afterSwap(+ address,+ PoolKey calldata key,+ IPoolManager.SwapParams calldata params,+ BalanceDelta,+ bytes calldata hookData+ ) external override returns (bytes4, int128) {+ counter++;+ _swap(key, params, hookData);+ return (IHooks.afterSwap.selector, 0);+ }++ function beforeDonate(address, PoolKey calldata key, uint256 amt0, uint256 amt1, bytes calldata hookData)+ external+ override+ returns (bytes4)+ {+ counter++;+ _donate(key, amt0, amt1, hookData);+ return IHooks.beforeDonate.selector;+ }++ function afterDonate(address, PoolKey calldata key, uint256 amt0, uint256 amt1, bytes calldata hookData)+ external+ override+ returns (bytes4)+ {+ counter++;+ _donate(key, amt0, amt1, hookData);+ return IHooks.afterDonate.selector;+ }++ function _initialize(PoolKey memory key, uint160 sqrtPriceX96) public {+ // initialize a new pool with different fee+ key.fee = 2000;+ IPoolManager(manager).initialize(key, sqrtPriceX96);+ }++ function _swap(PoolKey calldata key, IPoolManager.SwapParams memory params, bytes calldata hookData) public {+ IPoolManager(manager).swap(key, params, hookData);+ address payer = abi.decode(hookData, (address));+ int256 delta0 = IPoolManager(manager).currencyDelta(address(this), key.currency0);+ assertEq(delta0, params.amountSpecified);+ int256 delta1 = IPoolManager(manager).currencyDelta(address(this), key.currency1);+ assert(delta1 > 0);+ key.currency0.settle(manager, payer, uint256(-delta0), false);+ key.currency1.take(manager, payer, uint256(delta1), false);+ }++ function _addLiquidity(+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams memory params,+ bytes calldata hookData+ ) public {+ IPoolManager(manager).modifyLiquidity(key, params, hookData);+ address payer = abi.decode(hookData, (address));+ int256 delta0 = IPoolManager(manager).currencyDelta(address(this), key.currency0);+ int256 delta1 = IPoolManager(manager).currencyDelta(address(this), key.currency1);++ assert(delta0 < 0 || delta1 < 0);+ assert(!(delta0 > 0 || delta1 > 0));++ key.currency0.settle(manager, payer, uint256(-delta0), false);+ key.currency1.settle(manager, payer, uint256(-delta1), false);+ }++ function _removeLiquidity(+ PoolKey calldata key,+ IPoolManager.ModifyLiquidityParams memory params,+ bytes calldata hookData+ ) public {+ // first hook needs to add liquidity for itself+ IPoolManager.ModifyLiquidityParams memory newParams =+ IPoolManager.ModifyLiquidityParams({tickLower: -120, tickUpper: 120, liquidityDelta: 1e18, salt: 0});+ IPoolManager(manager).modifyLiquidity(key, newParams, hookData);+ // hook removes liquidity+ IPoolManager(manager).modifyLiquidity(key, params, hookData);+ address payer = abi.decode(hookData, (address));+ int256 delta0 = IPoolManager(manager).currencyDelta(address(this), key.currency0);+ int256 delta1 = IPoolManager(manager).currencyDelta(address(this), key.currency1);++ assert(delta0 < 0 || delta1 < 0);+ assert(!(delta0 > 0 || delta1 > 0));++ key.currency0.settle(manager, payer, uint256(-delta0), false);+ key.currency1.settle(manager, payer, uint256(-delta1), false);+ }++ function _donate(PoolKey calldata key, uint256 amt0, uint256 amt1, bytes calldata hookData) public {+ IPoolManager(manager).donate(key, amt0, amt1, hookData);+ address payer = abi.decode(hookData, (address));+ int256 delta0 = IPoolManager(manager).currencyDelta(address(this), key.currency0);+ int256 delta1 = IPoolManager(manager).currencyDelta(address(this), key.currency1);+ key.currency0.settle(manager, payer, uint256(-delta0), false);+ key.currency1.settle(manager, payer, uint256(-delta1), false);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/SqrtPriceMathEchidnaTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/SqrtPriceMathEchidnaTest.solnew file mode 100644index 000000000..8deb8d16c--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/SqrtPriceMathEchidnaTest.sol@@ -0,0 +1,198 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {FullMath} from "../libraries/FullMath.sol";+import {SqrtPriceMath} from "../libraries/SqrtPriceMath.sol";+import {FixedPoint96} from "../libraries/FixedPoint96.sol";++contract SqrtPriceMathEchidnaTest {+ function mulDivRoundingUpInvariants(uint256 x, uint256 y, uint256 z) external pure {+ unchecked {+ require(z > 0);+ uint256 notRoundedUp = FullMath.mulDiv(x, y, z);+ uint256 roundedUp = FullMath.mulDivRoundingUp(x, y, z);+ assert(roundedUp >= notRoundedUp);+ assert(roundedUp - notRoundedUp < 2);+ if (roundedUp - notRoundedUp == 1) {+ assert(mulmod(x, y, z) > 0);+ } else {+ assert(mulmod(x, y, z) == 0);+ }+ }+ }++ function getNextSqrtPriceFromInputInvariants(uint160 sqrtP, uint128 liquidity, uint256 amountIn, bool zeroForOne)+ external+ pure+ {+ uint160 sqrtQ = SqrtPriceMath.getNextSqrtPriceFromInput(sqrtP, liquidity, amountIn, zeroForOne);++ if (zeroForOne) {+ assert(sqrtQ <= sqrtP);+ assert(amountIn >= SqrtPriceMath.getAmount0Delta(sqrtQ, sqrtP, liquidity, true));+ } else {+ assert(sqrtQ >= sqrtP);+ assert(amountIn >= SqrtPriceMath.getAmount1Delta(sqrtP, sqrtQ, liquidity, true));+ }+ }++ function getNextSqrtPriceFromOutputInvariants(uint160 sqrtP, uint128 liquidity, uint256 amountOut, bool zeroForOne)+ external+ pure+ {+ uint160 sqrtQ = SqrtPriceMath.getNextSqrtPriceFromOutput(sqrtP, liquidity, amountOut, zeroForOne);++ if (zeroForOne) {+ assert(sqrtQ <= sqrtP);+ assert(amountOut <= SqrtPriceMath.getAmount1Delta(sqrtQ, sqrtP, liquidity, false));+ } else {+ assert(sqrtQ > 0); // this has to be true, otherwise we need another require+ assert(sqrtQ >= sqrtP);+ assert(amountOut <= SqrtPriceMath.getAmount0Delta(sqrtP, sqrtQ, liquidity, false));+ }+ }++ function getNextSqrtPriceFromAmount0RoundingUpInvariants(+ uint160 sqrtPX96,+ uint128 liquidity,+ uint256 amount,+ bool add+ ) external pure {+ require(sqrtPX96 > 0);+ require(liquidity > 0);+ uint160 sqrtQX96 = SqrtPriceMath.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amount, add);++ if (add) {+ assert(sqrtQX96 <= sqrtPX96);+ } else {+ assert(sqrtQX96 >= sqrtPX96);+ }++ if (amount == 0) {+ assert(sqrtPX96 == sqrtQX96);+ }+ }++ function getNextSqrtPriceFromAmount1RoundingDownInvariants(+ uint160 sqrtPX96,+ uint128 liquidity,+ uint256 amount,+ bool add+ ) external pure {+ require(sqrtPX96 > 0);+ require(liquidity > 0);+ uint160 sqrtQX96 = SqrtPriceMath.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amount, add);++ if (add) {+ assert(sqrtQX96 >= sqrtPX96);+ } else {+ assert(sqrtQX96 <= sqrtPX96);+ }++ if (amount == 0) {+ assert(sqrtPX96 == sqrtQX96);+ }+ }++ function getAmount0DeltaInvariants(uint160 sqrtP, uint160 sqrtQ, uint128 liquidity) external pure {+ require(sqrtP > 0 && sqrtQ > 0);++ uint256 amount0Down = SqrtPriceMath.getAmount0Delta(sqrtQ, sqrtP, liquidity, false);+ assert(amount0Down == SqrtPriceMath.getAmount0Delta(sqrtP, sqrtQ, liquidity, false));++ uint256 amount0Up = SqrtPriceMath.getAmount0Delta(sqrtQ, sqrtP, liquidity, true);+ assert(amount0Up == SqrtPriceMath.getAmount0Delta(sqrtP, sqrtQ, liquidity, true));++ assert(amount0Down <= amount0Up);+ // diff is 0 or 1+ assert(amount0Up - amount0Down < 2);+ }++ // ensure that chained division is always equal to the full-precision case for+ // liquidity * (sqrt(P) - sqrt(Q)) / (sqrt(P) * sqrt(Q))+ function getAmount0DeltaEquivalency(uint160 sqrtP, uint160 sqrtQ, uint128 liquidity, bool roundUp) external pure {+ require(sqrtP >= sqrtQ);+ require(sqrtP > 0 && sqrtQ > 0);+ require((sqrtP * sqrtQ) / sqrtP == sqrtQ);++ uint256 numerator1 = uint256(liquidity) << FixedPoint96.RESOLUTION;+ uint256 numerator2 = sqrtP - sqrtQ;+ uint256 denominator = uint256(sqrtP) * sqrtQ;++ uint256 safeResult = roundUp+ ? FullMath.mulDivRoundingUp(numerator1, numerator2, denominator)+ : FullMath.mulDiv(numerator1, numerator2, denominator);+ uint256 fullResult = SqrtPriceMath.getAmount0Delta(sqrtQ, sqrtP, liquidity, roundUp);++ assert(safeResult == fullResult);+ }++ function getAmount1DeltaInvariants(uint160 sqrtP, uint160 sqrtQ, uint128 liquidity) external pure {+ require(sqrtP > 0 && sqrtQ > 0);++ uint256 amount1Down = SqrtPriceMath.getAmount1Delta(sqrtP, sqrtQ, liquidity, false);+ assert(amount1Down == SqrtPriceMath.getAmount1Delta(sqrtQ, sqrtP, liquidity, false));++ uint256 amount1Up = SqrtPriceMath.getAmount1Delta(sqrtP, sqrtQ, liquidity, true);+ assert(amount1Up == SqrtPriceMath.getAmount1Delta(sqrtQ, sqrtP, liquidity, true));++ assert(amount1Down <= amount1Up);+ // diff is 0 or 1+ assert(amount1Up - amount1Down < 2);+ }++ function getAmount0DeltaSignedInvariants(uint160 sqrtP, uint160 sqrtQ, int128 liquidity) external pure {+ require(sqrtP > 0 && sqrtQ > 0);++ int256 amount0 = SqrtPriceMath.getAmount0Delta(sqrtQ, sqrtP, liquidity);+ if (liquidity < 0) assert(amount0 <= 0);+ if (liquidity > 0) {+ if (sqrtP == sqrtQ) assert(amount0 == 0);+ else assert(amount0 > 0);+ }+ if (liquidity == 0) assert(amount0 == 0);+ }++ function getAmount1DeltaSignedInvariants(uint160 sqrtP, uint160 sqrtQ, int128 liquidity) external pure {+ require(sqrtP > 0 && sqrtQ > 0);++ int256 amount1 = SqrtPriceMath.getAmount1Delta(sqrtP, sqrtQ, liquidity);+ if (liquidity < 0) assert(amount1 <= 0);+ if (liquidity > 0) {+ if (sqrtP == sqrtQ) assert(amount1 == 0);+ else assert(amount1 > 0);+ }+ if (liquidity == 0) assert(amount1 == 0);+ }++ function getOutOfRangeMintInvariants(uint160 sqrtA, uint160 sqrtB, int128 liquidity) external pure {+ require(sqrtA > 0 && sqrtB > 0);+ require(liquidity > 0);++ int256 amount0 = SqrtPriceMath.getAmount0Delta(sqrtA, sqrtB, liquidity);+ int256 amount1 = SqrtPriceMath.getAmount1Delta(sqrtA, sqrtB, liquidity);++ if (sqrtA == sqrtB) {+ assert(amount0 == 0);+ assert(amount1 == 0);+ } else {+ assert(amount0 > 0);+ assert(amount1 > 0);+ }+ }++ function getInRangeMintInvariants(uint160 sqrtLower, uint160 sqrtCurrent, uint160 sqrtUpper, int128 liquidity)+ external+ pure+ {+ require(sqrtLower > 0);+ require(sqrtLower < sqrtUpper);+ require(sqrtLower <= sqrtCurrent && sqrtCurrent <= sqrtUpper);+ require(liquidity > 0);++ int256 amount0 = SqrtPriceMath.getAmount0Delta(sqrtCurrent, sqrtUpper, liquidity);+ int256 amount1 = SqrtPriceMath.getAmount1Delta(sqrtLower, sqrtCurrent, liquidity);++ assert(amount0 > 0 || amount1 > 0);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/SwapRouterNoChecks.sol b/contracts/v4-hooks/lib/v4-core/src/test/SwapRouterNoChecks.solnew file mode 100644index 000000000..0b744acf8--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/SwapRouterNoChecks.sol@@ -0,0 +1,48 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.24;++import {Currency} from "../types/Currency.sol";+import {IPoolManager} from "../interfaces/IPoolManager.sol";+import {BalanceDelta} from "../types/BalanceDelta.sol";+import {PoolKey} from "../types/PoolKey.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {Hooks} from "../libraries/Hooks.sol";+import {PoolTestBase} from "./PoolTestBase.sol";+import {CurrencySettler} from "../../test/utils/CurrencySettler.sol";++contract SwapRouterNoChecks is PoolTestBase {+ using CurrencySettler for Currency;+ using Hooks for IHooks;++ constructor(IPoolManager _manager) PoolTestBase(_manager) {}++ error NoSwapOccurred();++ struct CallbackData {+ address sender;+ PoolKey key;+ IPoolManager.SwapParams params;+ }++ function swap(PoolKey memory key, IPoolManager.SwapParams memory params) external payable {+ manager.unlock(abi.encode(CallbackData(msg.sender, key, params)));+ }++ function unlockCallback(bytes calldata rawData) external returns (bytes memory) {+ require(msg.sender == address(manager));++ CallbackData memory data = abi.decode(rawData, (CallbackData));++ BalanceDelta delta = manager.swap(data.key, data.params, new bytes(0));++ if (data.params.zeroForOne) {+ data.key.currency0.settle(manager, data.sender, uint256(int256(-delta.amount0())), false);+ data.key.currency1.take(manager, data.sender, uint256(int256(delta.amount1())), false);+ } else {+ data.key.currency1.settle(manager, data.sender, uint256(int256(-delta.amount1())), false);+ data.key.currency0.take(manager, data.sender, uint256(int256(delta.amount0())), false);+ }++ return "";+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/TestERC20.sol b/contracts/v4-hooks/lib/v4-core/src/test/TestERC20.solnew file mode 100644index 000000000..7ceb32767--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/TestERC20.sol@@ -0,0 +1,55 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {IERC20Minimal} from "../interfaces/external/IERC20Minimal.sol";++contract TestERC20 is IERC20Minimal {+ mapping(address => uint256) public override balanceOf;+ mapping(address => mapping(address => uint256)) public override allowance;++ constructor(uint256 amountToMint) {+ mint(msg.sender, amountToMint);+ }++ function mint(address to, uint256 amount) public {+ uint256 balanceNext = balanceOf[to] + amount;+ require(balanceNext >= amount, "overflow balance");+ balanceOf[to] = balanceNext;+ }++ function transfer(address recipient, uint256 amount) external override returns (bool) {+ uint256 balanceBefore = balanceOf[msg.sender];+ require(balanceBefore >= amount, "insufficient balance");+ balanceOf[msg.sender] = balanceBefore - amount;++ uint256 balanceRecipient = balanceOf[recipient];+ require(balanceRecipient + amount >= balanceRecipient, "recipient balance overflow");+ balanceOf[recipient] = balanceRecipient + amount;++ emit Transfer(msg.sender, recipient, amount);+ return true;+ }++ function approve(address spender, uint256 amount) external override returns (bool) {+ allowance[msg.sender][spender] = amount;+ emit Approval(msg.sender, spender, amount);+ return true;+ }++ function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {+ uint256 allowanceBefore = allowance[sender][msg.sender];+ require(allowanceBefore >= amount, "allowance insufficient");++ allowance[sender][msg.sender] = allowanceBefore - amount;++ uint256 balanceRecipient = balanceOf[recipient];+ require(balanceRecipient + amount >= balanceRecipient, "overflow balance recipient");+ balanceOf[recipient] = balanceRecipient + amount;+ uint256 balanceSender = balanceOf[sender];+ require(balanceSender >= amount, "underflow balance sender");+ balanceOf[sender] = balanceSender - amount;++ emit Transfer(sender, recipient, amount);+ return true;+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/TestInvalidERC20.sol b/contracts/v4-hooks/lib/v4-core/src/test/TestInvalidERC20.solnew file mode 100644index 000000000..b0e549a9f--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/TestInvalidERC20.sol@@ -0,0 +1,56 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {IERC20Minimal} from "../interfaces/external/IERC20Minimal.sol";++// Regular ERC20 but it doesn't return true on transfer.+contract TestInvalidERC20 is IERC20Minimal {+ mapping(address => uint256) public override balanceOf;+ mapping(address => mapping(address => uint256)) public override allowance;++ constructor(uint256 amountToMint) {+ mint(msg.sender, amountToMint);+ }++ function mint(address to, uint256 amount) public {+ uint256 balanceNext = balanceOf[to] + amount;+ require(balanceNext >= amount, "overflow balance");+ balanceOf[to] = balanceNext;+ }++ function transfer(address recipient, uint256 amount) external override returns (bool) {+ uint256 balanceBefore = balanceOf[msg.sender];+ require(balanceBefore >= amount, "insufficient balance");+ balanceOf[msg.sender] = balanceBefore - amount;++ uint256 balanceRecipient = balanceOf[recipient];+ require(balanceRecipient + amount >= balanceRecipient, "recipient balance overflow");+ balanceOf[recipient] = balanceRecipient + amount;++ emit Transfer(msg.sender, recipient, amount);+ return false; // returns false even though it succeeded+ }++ function approve(address spender, uint256 amount) external override returns (bool) {+ allowance[msg.sender][spender] = amount;+ emit Approval(msg.sender, spender, amount);+ return false;+ }++ function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {+ uint256 allowanceBefore = allowance[sender][msg.sender];+ require(allowanceBefore >= amount, "allowance insufficient");++ allowance[sender][msg.sender] = allowanceBefore - amount;++ uint256 balanceRecipient = balanceOf[recipient];+ require(balanceRecipient + amount >= balanceRecipient, "overflow balance recipient");+ balanceOf[recipient] = balanceRecipient + amount;+ uint256 balanceSender = balanceOf[sender];+ require(balanceSender >= amount, "underflow balance sender");+ balanceOf[sender] = balanceSender - amount;++ emit Transfer(sender, recipient, amount);+ return false; // returns false even though it succeeded+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/TickMathEchidnaTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/TickMathEchidnaTest.solnew file mode 100644index 000000000..d224cf2a7--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/TickMathEchidnaTest.sol@@ -0,0 +1,22 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {TickMath} from "../libraries/TickMath.sol";++contract TickMathEchidnaTest {+ // uniqueness and increasing order+ function checkGetSqrtPriceAtTickInvariants(int24 tick) external pure {+ uint160 price = TickMath.getSqrtPriceAtTick(tick);+ assert(TickMath.getSqrtPriceAtTick(tick - 1) < price && price < TickMath.getSqrtPriceAtTick(tick + 1));+ assert(price >= TickMath.MIN_SQRT_PRICE);+ assert(price <= TickMath.MAX_SQRT_PRICE);+ }++ // the price is always between the returned tick and the returned tick+1+ function checkGetTickAtSqrtPriceInvariants(uint160 price) external pure {+ int24 tick = TickMath.getTickAtSqrtPrice(price);+ assert(price >= TickMath.getSqrtPriceAtTick(tick) && price < TickMath.getSqrtPriceAtTick(tick + 1));+ assert(tick >= TickMath.MIN_TICK);+ assert(tick < TickMath.MAX_TICK);+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/TickMathTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/TickMathTest.solnew file mode 100644index 000000000..ea0a42af4--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/TickMathTest.sol@@ -0,0 +1,42 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {TickMath} from "../libraries/TickMath.sol";++contract TickMathTest {+ function getSqrtPriceAtTick(int24 tick) external pure returns (uint160) {+ return TickMath.getSqrtPriceAtTick(tick);+ }++ function getGasCostOfGetSqrtPriceAtTick(int24 tick) external view returns (uint256) {+ uint256 gasBefore = gasleft();+ TickMath.getSqrtPriceAtTick(tick);+ return gasBefore - gasleft();+ }++ function getTickAtSqrtPrice(uint160 sqrtPriceX96) external pure returns (int24) {+ return TickMath.getTickAtSqrtPrice(sqrtPriceX96);+ }++ function getGasCostOfGetTickAtSqrtPrice(uint160 sqrtPriceX96) external view returns (uint256) {+ uint256 gasBefore = gasleft();+ TickMath.getTickAtSqrtPrice(sqrtPriceX96);+ return gasBefore - gasleft();+ }++ function MIN_SQRT_PRICE() external pure returns (uint160) {+ return TickMath.MIN_SQRT_PRICE;+ }++ function MAX_SQRT_PRICE() external pure returns (uint160) {+ return TickMath.MAX_SQRT_PRICE;+ }++ function MIN_TICK() external pure returns (int24) {+ return TickMath.MIN_TICK;+ }++ function MAX_TICK() external pure returns (int24) {+ return TickMath.MAX_TICK;+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/test/TickOverflowSafetyEchidnaTest.sol b/contracts/v4-hooks/lib/v4-core/src/test/TickOverflowSafetyEchidnaTest.solnew file mode 100644index 000000000..f7fdc95f7--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/test/TickOverflowSafetyEchidnaTest.sol@@ -0,0 +1,89 @@+// SPDX-License-Identifier: UNLICENSED+pragma solidity ^0.8.20;++import {Pool} from "../libraries/Pool.sol";++contract TickOverflowSafetyEchidnaTest {+ using Pool for Pool.State;++ int24 private constant MIN_TICK = -16;+ int24 private constant MAX_TICK = 16;++ Pool.State private pool;+ int24 private tick = 0;++ // half the cap of fee growth has happened, this can overflow+ uint256 feeGrowthGlobal0X128 = type(uint256).max / 2;+ uint256 feeGrowthGlobal1X128 = type(uint256).max / 2;++ // used to track how much total liquidity has been added. should never be negative+ int256 totalLiquidity = 0;+ // how much total growth has happened, this cannot overflow+ uint256 private totalGrowth0 = 0;+ uint256 private totalGrowth1 = 0;++ function increaseFeeGrowthGlobal0X128(uint256 amount) external {+ require(totalGrowth0 + amount > totalGrowth0); // overflow check+ feeGrowthGlobal0X128 += amount; // overflow desired+ totalGrowth0 += amount;+ }++ function increaseFeeGrowthGlobal1X128(uint256 amount) external {+ require(totalGrowth1 + amount > totalGrowth1); // overflow check+ feeGrowthGlobal1X128 += amount; // overflow desired+ totalGrowth1 += amount;+ }++ function setPosition(int24 tickLower, int24 tickUpper, int128 liquidityDelta) external {+ require(tickLower > MIN_TICK);+ require(tickUpper < MAX_TICK);+ require(tickLower < tickUpper);+ (bool flippedLower,) = pool.updateTick(tickLower, liquidityDelta, false);+ (bool flippedUpper,) = pool.updateTick(tickUpper, liquidityDelta, true);++ if (flippedLower) {+ if (liquidityDelta < 0) {+ assert(pool.ticks[tickLower].liquidityGross == 0);+ pool.clearTick(tickLower);+ } else {+ assert(pool.ticks[tickLower].liquidityGross > 0);+ }+ }++ if (flippedUpper) {+ if (liquidityDelta < 0) {+ assert(pool.ticks[tickUpper].liquidityGross == 0);+ pool.clearTick(tickUpper);+ } else {+ assert(pool.ticks[tickUpper].liquidityGross > 0);+ }+ }++ totalLiquidity += liquidityDelta;+ // requires should have prevented this+ assert(totalLiquidity >= 0);++ if (totalLiquidity == 0) {+ totalGrowth0 = 0;+ totalGrowth1 = 0;+ }+ }++ function moveToTick(int24 target) external {+ require(target > MIN_TICK);+ require(target < MAX_TICK);+ while (tick != target) {+ if (tick < target) {+ if (pool.ticks[tick + 1].liquidityGross > 0) {+ pool.crossTick(tick + 1, feeGrowthGlobal0X128, feeGrowthGlobal1X128);+ }+ tick++;+ } else {+ if (pool.ticks[tick].liquidityGross > 0) {+ pool.crossTick(tick, feeGrowthGlobal0X128, feeGrowthGlobal1X128);+ }+ tick--;+ }+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/types/BalanceDelta.sol b/contracts/v4-hooks/lib/v4-core/src/types/BalanceDelta.solnew file mode 100644index 000000000..4dca00e0b--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/types/BalanceDelta.sol@@ -0,0 +1,72 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {SafeCast} from "../libraries/SafeCast.sol";++/// @dev Two `int128` values packed into a single `int256` where the upper 128 bits represent the amount0+/// and the lower 128 bits represent the amount1.+type BalanceDelta is int256;++using {add as +, sub as -, eq as ==, neq as !=} for BalanceDelta global;+using BalanceDeltaLibrary for BalanceDelta global;+using SafeCast for int256;++function toBalanceDelta(int128 _amount0, int128 _amount1) pure returns (BalanceDelta balanceDelta) {+ assembly ("memory-safe") {+ balanceDelta := or(shl(128, _amount0), and(sub(shl(128, 1), 1), _amount1))+ }+}++function add(BalanceDelta a, BalanceDelta b) pure returns (BalanceDelta) {+ int256 res0;+ int256 res1;+ assembly ("memory-safe") {+ let a0 := sar(128, a)+ let a1 := signextend(15, a)+ let b0 := sar(128, b)+ let b1 := signextend(15, b)+ res0 := add(a0, b0)+ res1 := add(a1, b1)+ }+ return toBalanceDelta(res0.toInt128(), res1.toInt128());+}++function sub(BalanceDelta a, BalanceDelta b) pure returns (BalanceDelta) {+ int256 res0;+ int256 res1;+ assembly ("memory-safe") {+ let a0 := sar(128, a)+ let a1 := signextend(15, a)+ let b0 := sar(128, b)+ let b1 := signextend(15, b)+ res0 := sub(a0, b0)+ res1 := sub(a1, b1)+ }+ return toBalanceDelta(res0.toInt128(), res1.toInt128());+}++function eq(BalanceDelta a, BalanceDelta b) pure returns (bool) {+ return BalanceDelta.unwrap(a) == BalanceDelta.unwrap(b);+}++function neq(BalanceDelta a, BalanceDelta b) pure returns (bool) {+ return BalanceDelta.unwrap(a) != BalanceDelta.unwrap(b);+}++/// @notice Library for getting the amount0 and amount1 deltas from the BalanceDelta type+library BalanceDeltaLibrary {+ /// @notice A BalanceDelta of 0+ BalanceDelta public constant ZERO_DELTA = BalanceDelta.wrap(0);++ function amount0(BalanceDelta balanceDelta) internal pure returns (int128 _amount0) {+ assembly ("memory-safe") {+ _amount0 := sar(128, balanceDelta)+ }+ }++ function amount1(BalanceDelta balanceDelta) internal pure returns (int128 _amount1) {+ assembly ("memory-safe") {+ _amount1 := signextend(15, balanceDelta)+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/types/BeforeSwapDelta.sol b/contracts/v4-hooks/lib/v4-core/src/types/BeforeSwapDelta.solnew file mode 100644index 000000000..30fd9cef8--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/types/BeforeSwapDelta.sol@@ -0,0 +1,38 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++// Return type of the beforeSwap hook.+// Upper 128 bits is the delta in specified tokens. Lower 128 bits is delta in unspecified tokens (to match the afterSwap hook)+type BeforeSwapDelta is int256;++// Creates a BeforeSwapDelta from specified and unspecified+function toBeforeSwapDelta(int128 deltaSpecified, int128 deltaUnspecified)+ pure+ returns (BeforeSwapDelta beforeSwapDelta)+{+ assembly ("memory-safe") {+ beforeSwapDelta := or(shl(128, deltaSpecified), and(sub(shl(128, 1), 1), deltaUnspecified))+ }+}++/// @notice Library for getting the specified and unspecified deltas from the BeforeSwapDelta type+library BeforeSwapDeltaLibrary {+ /// @notice A BeforeSwapDelta of 0+ BeforeSwapDelta public constant ZERO_DELTA = BeforeSwapDelta.wrap(0);++ /// extracts int128 from the upper 128 bits of the BeforeSwapDelta+ /// returned by beforeSwap+ function getSpecifiedDelta(BeforeSwapDelta delta) internal pure returns (int128 deltaSpecified) {+ assembly ("memory-safe") {+ deltaSpecified := sar(128, delta)+ }+ }++ /// extracts int128 from the lower 128 bits of the BeforeSwapDelta+ /// returned by beforeSwap and afterSwap+ function getUnspecifiedDelta(BeforeSwapDelta delta) internal pure returns (int128 deltaUnspecified) {+ assembly ("memory-safe") {+ deltaUnspecified := signextend(15, delta)+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/types/Currency.sol b/contracts/v4-hooks/lib/v4-core/src/types/Currency.solnew file mode 100644index 000000000..771653400--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/types/Currency.sol@@ -0,0 +1,119 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {IERC20Minimal} from "../interfaces/external/IERC20Minimal.sol";+import {CustomRevert} from "../libraries/CustomRevert.sol";++type Currency is address;++using {greaterThan as >, lessThan as <, greaterThanOrEqualTo as >=, equals as ==} for Currency global;+using CurrencyLibrary for Currency global;++function equals(Currency currency, Currency other) pure returns (bool) {+ return Currency.unwrap(currency) == Currency.unwrap(other);+}++function greaterThan(Currency currency, Currency other) pure returns (bool) {+ return Currency.unwrap(currency) > Currency.unwrap(other);+}++function lessThan(Currency currency, Currency other) pure returns (bool) {+ return Currency.unwrap(currency) < Currency.unwrap(other);+}++function greaterThanOrEqualTo(Currency currency, Currency other) pure returns (bool) {+ return Currency.unwrap(currency) >= Currency.unwrap(other);+}++/// @title CurrencyLibrary+/// @dev This library allows for transferring and holding native tokens and ERC20 tokens+library CurrencyLibrary {+ /// @notice Additional context for ERC-7751 wrapped error when a native transfer fails+ error NativeTransferFailed();++ /// @notice Additional context for ERC-7751 wrapped error when an ERC20 transfer fails+ error ERC20TransferFailed();++ /// @notice A constant to represent the native currency+ Currency public constant ADDRESS_ZERO = Currency.wrap(address(0));++ function transfer(Currency currency, address to, uint256 amount) internal {+ // altered from https://github.com/transmissions11/solmate/blob/44a9963d4c78111f77caa0e65d677b8b46d6f2e6/src/utils/SafeTransferLib.sol+ // modified custom error selectors++ bool success;+ if (currency.isAddressZero()) {+ assembly ("memory-safe") {+ // Transfer the ETH and revert if it fails.+ success := call(gas(), to, amount, 0, 0, 0, 0)+ }+ // revert with NativeTransferFailed, containing the bubbled up error as an argument+ if (!success) {+ CustomRevert.bubbleUpAndRevertWith(to, bytes4(0), NativeTransferFailed.selector);+ }+ } else {+ assembly ("memory-safe") {+ // Get a pointer to some free memory.+ let fmp := mload(0x40)++ // Write the abi-encoded calldata into memory, beginning with the function selector.+ mstore(fmp, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)+ mstore(add(fmp, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument.+ mstore(add(fmp, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type.++ success :=+ and(+ // Set success to whether the call reverted, if not we check it either+ // returned exactly 1 (can't just be non-zero data), or had no return data.+ or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),+ // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.+ // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.+ // Counterintuitively, this call must be positioned second to the or() call in the+ // surrounding and() call or else returndatasize() will be zero during the computation.+ call(gas(), currency, 0, fmp, 68, 0, 32)+ )++ // Now clean the memory we used+ mstore(fmp, 0) // 4 byte `selector` and 28 bytes of `to` were stored here+ mstore(add(fmp, 0x20), 0) // 4 bytes of `to` and 28 bytes of `amount` were stored here+ mstore(add(fmp, 0x40), 0) // 4 bytes of `amount` were stored here+ }+ // revert with ERC20TransferFailed, containing the bubbled up error as an argument+ if (!success) {+ CustomRevert.bubbleUpAndRevertWith(+ Currency.unwrap(currency), IERC20Minimal.transfer.selector, ERC20TransferFailed.selector+ );+ }+ }+ }++ function balanceOfSelf(Currency currency) internal view returns (uint256) {+ if (currency.isAddressZero()) {+ return address(this).balance;+ } else {+ return IERC20Minimal(Currency.unwrap(currency)).balanceOf(address(this));+ }+ }++ function balanceOf(Currency currency, address owner) internal view returns (uint256) {+ if (currency.isAddressZero()) {+ return owner.balance;+ } else {+ return IERC20Minimal(Currency.unwrap(currency)).balanceOf(owner);+ }+ }++ function isAddressZero(Currency currency) internal pure returns (bool) {+ return Currency.unwrap(currency) == Currency.unwrap(ADDRESS_ZERO);+ }++ function toId(Currency currency) internal pure returns (uint256) {+ return uint160(Currency.unwrap(currency));+ }++ // If the upper 12 bytes are non-zero, they will be zero-ed out+ // Therefore, fromId() and toId() are not inverses of each other+ function fromId(uint256 id) internal pure returns (Currency) {+ return Currency.wrap(address(uint160(id)));+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/types/PoolId.sol b/contracts/v4-hooks/lib/v4-core/src/types/PoolId.solnew file mode 100644index 000000000..22a0b4f91--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/types/PoolId.sol@@ -0,0 +1,17 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {PoolKey} from "./PoolKey.sol";++type PoolId is bytes32;++/// @notice Library for computing the ID of a pool+library PoolIdLibrary {+ /// @notice Returns value equal to keccak256(abi.encode(poolKey))+ function toId(PoolKey memory poolKey) internal pure returns (PoolId poolId) {+ assembly ("memory-safe") {+ // 0xa0 represents the total size of the poolKey struct (5 slots of 32 bytes)+ poolId := keccak256(poolKey, 0xa0)+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/src/types/PoolKey.sol b/contracts/v4-hooks/lib/v4-core/src/types/PoolKey.solnew file mode 100644index 000000000..0fa66f937--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/types/PoolKey.sol@@ -0,0 +1,22 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++import {Currency} from "./Currency.sol";+import {IHooks} from "../interfaces/IHooks.sol";+import {PoolIdLibrary} from "./PoolId.sol";++using PoolIdLibrary for PoolKey global;++/// @notice Returns the key for identifying a pool+struct PoolKey {+ /// @notice The lower currency of the pool, sorted numerically+ Currency currency0;+ /// @notice The higher currency of the pool, sorted numerically+ Currency currency1;+ /// @notice The pool LP fee, capped at 1_000_000. If the highest bit is 1, the pool has a dynamic fee and must be exactly equal to 0x800000+ uint24 fee;+ /// @notice Ticks that involve positions must be a multiple of tick spacing+ int24 tickSpacing;+ /// @notice The hooks of the pool+ IHooks hooks;+}diff --git a/contracts/v4-hooks/lib/v4-core/src/types/Slot0.sol b/contracts/v4-hooks/lib/v4-core/src/types/Slot0.solnew file mode 100644index 000000000..bd440d586--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/src/types/Slot0.sol@@ -0,0 +1,94 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.0;++/**+ * @dev Slot0 is a packed version of solidity structure.+ * Using the packaged version saves gas by not storing the structure fields in memory slots.+ *+ * Layout:+ * 24 bits empty | 24 bits lpFee | 12 bits protocolFee 1->0 | 12 bits protocolFee 0->1 | 24 bits tick | 160 bits sqrtPriceX96+ *+ * Fields in the direction from the least significant bit:+ *+ * The current price+ * uint160 sqrtPriceX96;+ *+ * The current tick+ * int24 tick;+ *+ * Protocol fee, expressed in hundredths of a bip, upper 12 bits are for 1->0, and the lower 12 are for 0->1+ * the maximum is 1000 - meaning the maximum protocol fee is 0.1%+ * the protocolFee is taken from the input first, then the lpFee is taken from the remaining input+ * uint24 protocolFee;+ *+ * The current LP fee of the pool. If the pool is dynamic, this does not include the dynamic fee flag.+ * uint24 lpFee;+ */+type Slot0 is bytes32;++using Slot0Library for Slot0 global;++/// @notice Library for getting and setting values in the Slot0 type+library Slot0Library {+ uint160 internal constant MASK_160_BITS = 0x00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;+ uint24 internal constant MASK_24_BITS = 0xFFFFFF;++ uint8 internal constant TICK_OFFSET = 160;+ uint8 internal constant PROTOCOL_FEE_OFFSET = 184;+ uint8 internal constant LP_FEE_OFFSET = 208;++ // #### GETTERS ####+ function sqrtPriceX96(Slot0 _packed) internal pure returns (uint160 _sqrtPriceX96) {+ assembly ("memory-safe") {+ _sqrtPriceX96 := and(MASK_160_BITS, _packed)+ }+ }++ function tick(Slot0 _packed) internal pure returns (int24 _tick) {+ assembly ("memory-safe") {+ _tick := signextend(2, shr(TICK_OFFSET, _packed))+ }+ }++ function protocolFee(Slot0 _packed) internal pure returns (uint24 _protocolFee) {+ assembly ("memory-safe") {+ _protocolFee := and(MASK_24_BITS, shr(PROTOCOL_FEE_OFFSET, _packed))+ }+ }++ function lpFee(Slot0 _packed) internal pure returns (uint24 _lpFee) {+ assembly ("memory-safe") {+ _lpFee := and(MASK_24_BITS, shr(LP_FEE_OFFSET, _packed))+ }+ }++ // #### SETTERS ####+ function setSqrtPriceX96(Slot0 _packed, uint160 _sqrtPriceX96) internal pure returns (Slot0 _result) {+ assembly ("memory-safe") {+ _result := or(and(not(MASK_160_BITS), _packed), and(MASK_160_BITS, _sqrtPriceX96))+ }+ }++ function setTick(Slot0 _packed, int24 _tick) internal pure returns (Slot0 _result) {+ assembly ("memory-safe") {+ _result := or(and(not(shl(TICK_OFFSET, MASK_24_BITS)), _packed), shl(TICK_OFFSET, and(MASK_24_BITS, _tick)))+ }+ }++ function setProtocolFee(Slot0 _packed, uint24 _protocolFee) internal pure returns (Slot0 _result) {+ assembly ("memory-safe") {+ _result :=+ or(+ and(not(shl(PROTOCOL_FEE_OFFSET, MASK_24_BITS)), _packed),+ shl(PROTOCOL_FEE_OFFSET, and(MASK_24_BITS, _protocolFee))+ )+ }+ }++ function setLpFee(Slot0 _packed, uint24 _lpFee) internal pure returns (Slot0 _result) {+ assembly ("memory-safe") {+ _result :=+ or(and(not(shl(LP_FEE_OFFSET, MASK_24_BITS)), _packed), shl(LP_FEE_OFFSET, and(MASK_24_BITS, _lpFee)))+ }+ }+}diff --git a/contracts/v4-hooks/lib/v4-core/test/utils/CurrencySettler.sol b/contracts/v4-hooks/lib/v4-core/test/utils/CurrencySettler.solnew file mode 100644index 000000000..f2065770e--- /dev/null+++ b/contracts/v4-hooks/lib/v4-core/test/utils/CurrencySettler.sol@@ -0,0 +1,46 @@+// SPDX-License-Identifier: MIT+pragma solidity ^0.8.20;++import {Currency} from "../../src/types/Currency.sol";+import {IERC20Minimal} from "../../src/interfaces/external/IERC20Minimal.sol";+import {IPoolManager} from "../../src/interfaces/IPoolManager.sol";++/// @notice Library used to interact with PoolManager.sol to settle any open deltas.+/// To settle a positive delta (a credit to the user), a user may take or mint.+/// To settle a negative delta (a debt on the user), a user make transfer or burn to pay off a debt.+/// @dev Note that sync() is called before any erc-20 transfer in `settle`.+library CurrencySettler {+ /// @notice Settle (pay) a currency to the PoolManager+ /// @param currency Currency to settle+ /// @param manager IPoolManager to settle to+ /// @param payer Address of the payer, the token sender+ /// @param amount Amount to send+ /// @param burn If true, burn the ERC-6909 token, otherwise ERC20-transfer to the PoolManager+ function settle(Currency currency, IPoolManager manager, address payer, uint256 amount, bool burn) internal {+ // for native currencies or burns, calling sync is not required+ // short circuit for ERC-6909 burns to support ERC-6909-wrapped native tokens+ if (burn) {+ manager.burn(payer, currency.toId(), amount);+ } else if (currency.isAddressZero()) {+ manager.settle{value: amount}();+ } else {+ manager.sync(currency);+ if (payer != address(this)) {+ IERC20Minimal(Currency.unwrap(currency)).transferFrom(payer, address(manager), amount);+ } else {+ IERC20Minimal(Currency.unwrap(currency)).transfer(address(manager), amount);+ }+ manager.settle();+ }+ }++ /// @notice Take (receive) a currency from the PoolManager+ /// @param currency Currency to take+ /// @param manager IPoolManager to take from+ /// @param recipient Address of the recipient, the token receiver+ /// @param amount Amount to receive+ /// @param claims If true, mint the ERC-6909 token, otherwise ERC20-transfer from the PoolManager to recipient+ function take(Currency currency, IPoolManager manager, address recipient, uint256 amount, bool claims) internal {+ claims ? manager.mint(recipient, currency.toId(), amount) : manager.take(currency, recipient, amount);+ }+}diff --git a/contracts/v4-hooks/script/DeploySkinHook.s.sol b/contracts/v4-hooks/script/DeploySkinHook.s.solnew file mode 100644index 000000000..a80246a06--- /dev/null+++ b/contracts/v4-hooks/script/DeploySkinHook.s.sol@@ -0,0 +1,35 @@+// SPDX-License-Identifier: MIT+pragma solidity 0.8.26;++import {Script, console2} from "forge-std/Script.sol";+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";+import {SkinHook} from "../src/SkinHook.sol";+import {HookMiner} from "./HookMiner.sol";++/// Deploys SkinHook through the canonical CREATE2 deployer at a mined, flag-matching address.+///+/// POOL_MANAGER=0x498581ff718922c3f8e6a244956af099b2652b2b \+/// HOOK_OWNER=0x... HOOK_TREASURY=0x... \+/// forge script script/DeploySkinHook.s.sol --rpc-url base --broadcast --verify+///+/// Without --broadcast it is a dry run that prints the address the hook would land at.+contract DeploySkinHook is Script {+ address constant CREATE2_DEPLOYER = 0x4e59b44847b379578588920cA78FbF26c0B4956C;+ // beforeInitialize | beforeSwap | afterSwap | beforeSwapReturnsDelta | afterSwapReturnsDelta+ uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);++ function run() external returns (SkinHook hook) {+ IPoolManager poolManager = IPoolManager(vm.envAddress("POOL_MANAGER"));+ address owner = vm.envAddress("HOOK_OWNER");+ address treasury = vm.envAddress("HOOK_TREASURY");++ bytes memory initCode = abi.encodePacked(type(SkinHook).creationCode, abi.encode(poolManager, owner, treasury));+ (address expected, bytes32 salt) = HookMiner.find(CREATE2_DEPLOYER, FLAGS, initCode);+ console2.log("SkinHook will deploy at", expected);+ console2.logBytes32(salt);++ vm.broadcast();+ hook = new SkinHook{salt: salt}(poolManager, owner, treasury);+ require(address(hook) == expected, "mined address mismatch");+ }+}diff --git a/contracts/v4-hooks/script/HookMiner.sol b/contracts/v4-hooks/script/HookMiner.solnew file mode 100644index 000000000..91fbaa868--- /dev/null+++ b/contracts/v4-hooks/script/HookMiner.sol@@ -0,0 +1,26 @@+// SPDX-License-Identifier: MIT+pragma solidity 0.8.26;++/// @notice Finds a CREATE2 salt that puts a hook at an address whose low 14 bits equal the+/// permission flags the hook declares. Uniswap v4 reads a hook's permissions from+/// its address, so a hook deployed anywhere else is rejected by its own constructor.+library HookMiner {+ uint160 internal constant FLAG_MASK = (1 << 14) - 1;+ uint256 internal constant MAX_ITERATIONS = 500_000;++ error SaltNotFound();++ function find(address deployer, uint160 flags, bytes memory creationCodeWithArgs)+ internal+ view+ returns (address hook, bytes32 salt)+ {+ bytes32 initCodeHash = keccak256(creationCodeWithArgs);+ for (uint256 i; i < MAX_ITERATIONS; ++i) {+ salt = bytes32(i);+ hook = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, initCodeHash)))));+ if (uint160(hook) & FLAG_MASK == flags && hook.code.length == 0) return (hook, salt);+ }+ revert SaltNotFound();+ }+}diff --git a/contracts/v4-hooks/src/SkinHook.sol b/contracts/v4-hooks/src/SkinHook.solnew file mode 100644index 000000000..499a56cd7--- /dev/null+++ b/contracts/v4-hooks/src/SkinHook.sol@@ -0,0 +1,404 @@+// SPDX-License-Identifier: MIT+pragma solidity 0.8.26;++import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";+import {IUnlockCallback} from "@uniswap/v4-core/src/interfaces/callback/IUnlockCallback.sol";+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";+import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";+import {FixedPoint96} from "@uniswap/v4-core/src/libraries/FixedPoint96.sol";+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";+import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";+import {SafeCast} from "@uniswap/v4-core/src/libraries/SafeCast.sol";+import {BeforeSwapDelta, BeforeSwapDeltaLibrary, toBeforeSwapDelta} from "@uniswap/v4-core/src/types/BeforeSwapDelta.sol";+import {Ownable, Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";++import {SkinToken} from "./SkinToken.sol";++/// @title SkinHook+/// @notice Wearable 3D items as coins. Every item is a fixed-supply ERC-20 with its own+/// ETH pool, launched through this one hook. To wear an item you lock one whole+/// token here and get it back when you take it off, so every wearer removes a token+/// from the float. The creator's royalty is taken inside the swap, in ETH, and+/// cannot be routed around. A swap may name a referrer (the site whose embed sold+/// it) in `hookData`, and that referrer is paid a share of the fee.+/// @dev Singleton. The hook is its own factory: it deploys the token, initializes the pool+/// and seeds the whole supply as one permanent single-sided position. v4 skips hook+/// callbacks for calls the hook makes itself, so `beforeInitialize` only ever runs for+/// an outsider and always reverts: every pool that names this hook was launched here.+/// Fees are held as ERC-6909 claims on the PoolManager and paid out on `claim`, so a+/// swap never pushes ETH to anyone and cannot be blocked by a reverting recipient.+contract SkinHook is IHooks, IUnlockCallback, Ownable2Step {+ using PoolIdLibrary for PoolKey;+ using CurrencyLibrary for Currency;+ using SafeCast for uint256;++ // ------------------------------------------------------------------ constants++ /// @notice Total fee on the ETH side of every swap, in basis points.+ uint256 public constant FEE_BPS = 200;+ /// @notice Creator's share of the fee, in basis points of the fee.+ uint256 public constant CREATOR_SHARE_BPS = 5000;+ /// @notice Referrer's share of the fee. Paid to the creator when no referrer is named.+ uint256 public constant REFERRER_SHARE_BPS = 2500;+ uint256 internal constant BPS = 10_000;++ /// @notice Locking exactly one whole token is what wearing costs.+ uint256 public constant EQUIP_AMOUNT = 1e18;+ uint256 public constant MIN_SUPPLY = 100;+ uint256 public constant MAX_SUPPLY = 1_000_000;++ int24 public constant TICK_SPACING = 200;+ /// @dev Pool price is tokens per ETH. 46000 is about 100 tokens per ETH (0.01 ETH each),+ /// 161200 is about 10 million tokens per ETH. A launch starts cheap and climbs.+ int24 public constant MIN_START_TICK = 46_000;+ int24 public constant MAX_START_TICK = 161_200;+ int24 internal constant RANGE_LOWER_TICK = -887_200;++ address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;++ // ------------------------------------------------------------------ storage++ IPoolManager public immutable poolManager;++ struct Skin {+ SkinToken token;+ address creator;+ }++ mapping(PoolId => Skin) public skins;+ mapping(SkinToken => bool) public isSkin;+ mapping(SkinToken => mapping(address => bool)) public isWearing;+ mapping(SkinToken => uint256) public wearerCount;++ /// @notice ETH owed to creators, referrers and the treasury, withdrawn with `claim`.+ mapping(address => uint256) public owed;+ address public treasury;++ struct LaunchParams {+ string name;+ string symbol;+ uint256 supply; // whole tokens+ string modelURI;+ bytes32 modelHash;+ string slot;+ int24 startTick;+ address creator;+ }++ enum Action {+ Seed,+ Claim+ }++ // ------------------------------------------------------------------ events and errors++ event SkinLaunched(+ SkinToken indexed token,+ PoolId indexed poolId,+ address indexed creator,+ uint256 supply,+ int24 startTick,+ bytes32 modelHash,+ string modelURI,+ string slot+ );+ event Equipped(SkinToken indexed token, address indexed wearer, uint256 wearers);+ event Unequipped(SkinToken indexed token, address indexed wearer, uint256 wearers);+ event FeeAccrued(+ PoolId indexed poolId, address indexed referrer, uint256 creatorCut, uint256 referrerCut, uint256 treasuryCut+ );+ event Claimed(address indexed account, address indexed to, uint256 amount);+ event TreasuryChanged(address indexed previous, address indexed current);++ error NotPoolManager();+ error OnlyThisHookLaunchesPools();+ error HookNotImplemented();+ error InvalidSupply();+ error InvalidStartTick();+ error InvalidModel();+ error ZeroAddress();+ error NotASkin();+ error AlreadyWearing();+ error NotWearing();+ error NothingToClaim();++ modifier onlyPoolManager() {+ if (msg.sender != address(poolManager)) revert NotPoolManager();+ _;+ }++ constructor(IPoolManager poolManager_, address owner_, address treasury_) Ownable(owner_) {+ if (treasury_ == address(0)) revert ZeroAddress();+ poolManager = poolManager_;+ treasury = treasury_;+ Hooks.validateHookPermissions(+ IHooks(address(this)),+ Hooks.Permissions({+ beforeInitialize: true,+ afterInitialize: false,+ beforeAddLiquidity: false,+ afterAddLiquidity: false,+ beforeRemoveLiquidity: false,+ afterRemoveLiquidity: false,+ beforeSwap: true,+ afterSwap: true,+ beforeDonate: false,+ afterDonate: false,+ beforeSwapReturnDelta: true,+ afterSwapReturnDelta: true,+ afterAddLiquidityReturnDelta: false,+ afterRemoveLiquidityReturnDelta: false+ })+ );+ }++ // ------------------------------------------------------------------ launch++ /// @notice Launch a wearable: deploy its token, open its ETH pool and seed the entire+ /// supply as one permanent position that sells from `startTick` upward in price.+ /// Nothing is held back for the creator or the platform.+ function launch(LaunchParams calldata p) external returns (SkinToken token, PoolKey memory key) {+ if (p.supply < MIN_SUPPLY || p.supply > MAX_SUPPLY) revert InvalidSupply();+ if (p.startTick < MIN_START_TICK || p.startTick > MAX_START_TICK || p.startTick % TICK_SPACING != 0) {+ revert InvalidStartTick();+ }+ if (p.modelHash == bytes32(0) || bytes(p.modelURI).length == 0) revert InvalidModel();+ if (p.creator == address(0)) revert ZeroAddress();++ uint256 supplyWei = p.supply * 1e18;+ token = new SkinToken(p.name, p.symbol, supplyWei, p.modelURI, p.modelHash, p.slot, p.creator);++ // Native ETH is address(0), so it always sorts first and the item is always currency1.+ key = PoolKey({+ currency0: CurrencyLibrary.ADDRESS_ZERO,+ currency1: Currency.wrap(address(token)),+ fee: 0,+ tickSpacing: TICK_SPACING,+ hooks: IHooks(address(this))+ });+ PoolId poolId = key.toId();+ skins[poolId] = Skin({token: token, creator: p.creator});+ isSkin[token] = true;++ poolManager.initialize(key, TickMath.getSqrtPriceAtTick(p.startTick));+ poolManager.unlock(abi.encode(Action.Seed, abi.encode(key, p.startTick, supplyWei)));++ // Liquidity rounds down, so a few wei of the supply can be left over. Burn them+ // so that the hook's token balance is exactly the equipped tokens and nothing else.+ uint256 dust = token.balanceOf(address(this));+ if (dust != 0) token.transfer(DEAD, dust);++ emit SkinLaunched(token, poolId, p.creator, p.supply, p.startTick, p.modelHash, p.modelURI, p.slot);+ }++ // ------------------------------------------------------------------ wear-to-lock++ /// @notice Put the item on. Locks one whole token here until `unequip`.+ function equip(SkinToken token) external {+ if (!isSkin[token]) revert NotASkin();+ if (isWearing[token][msg.sender]) revert AlreadyWearing();+ isWearing[token][msg.sender] = true;+ uint256 wearers = ++wearerCount[token];+ token.transferFrom(msg.sender, address(this), EQUIP_AMOUNT);+ emit Equipped(token, msg.sender, wearers);+ }++ /// @notice Take the item off and get the locked token back.+ function unequip(SkinToken token) external {+ if (!isWearing[token][msg.sender]) revert NotWearing();+ isWearing[token][msg.sender] = false;+ uint256 wearers = --wearerCount[token];+ token.transfer(msg.sender, EQUIP_AMOUNT);+ emit Unequipped(token, msg.sender, wearers);+ }++ // ------------------------------------------------------------------ fees++ /// @notice Withdraw everything owed to the caller, to `to`.+ function claim(address to) external returns (uint256 amount) {+ if (to == address(0)) revert ZeroAddress();+ amount = owed[msg.sender];+ if (amount == 0) revert NothingToClaim();+ owed[msg.sender] = 0;+ poolManager.unlock(abi.encode(Action.Claim, abi.encode(to, amount)));+ emit Claimed(msg.sender, to, amount);+ }++ function setTreasury(address treasury_) external onlyOwner {+ if (treasury_ == address(0)) revert ZeroAddress();+ emit TreasuryChanged(treasury, treasury_);+ treasury = treasury_;+ }++ function unlockCallback(bytes calldata data) external onlyPoolManager returns (bytes memory) {+ (Action action, bytes memory payload) = abi.decode(data, (Action, bytes));+ if (action == Action.Seed) {+ (PoolKey memory key, int24 startTick, uint256 supplyWei) = abi.decode(payload, (PoolKey, int24, uint256));+ _seed(key, startTick, supplyWei);+ } else {+ (address to, uint256 amount) = abi.decode(payload, (address, uint256));+ poolManager.burn(address(this), CurrencyLibrary.ADDRESS_ZERO.toId(), amount);+ poolManager.take(CurrencyLibrary.ADDRESS_ZERO, to, amount);+ }+ return "";+ }++ /// @dev The pool starts at the top of the range, where a position is entirely currency1,+ /// so seeding costs only the item and no ETH.+ function _seed(PoolKey memory key, int24 startTick, uint256 supplyWei) internal {+ uint160 sqrtUpper = TickMath.getSqrtPriceAtTick(startTick);+ uint160 sqrtLower = TickMath.getSqrtPriceAtTick(RANGE_LOWER_TICK);+ uint256 liquidity = FullMath.mulDiv(supplyWei, FixedPoint96.Q96, sqrtUpper - sqrtLower);++ (BalanceDelta delta,) = poolManager.modifyLiquidity(+ key,+ IPoolManager.ModifyLiquidityParams({+ tickLower: RANGE_LOWER_TICK,+ tickUpper: startTick,+ liquidityDelta: int256(liquidity),+ salt: bytes32(0)+ }),+ ""+ );++ uint256 owedTokens = uint256(uint128(-delta.amount1()));+ poolManager.sync(key.currency1);+ SkinToken(Currency.unwrap(key.currency1)).transfer(address(poolManager), owedTokens);+ poolManager.settle();+ }++ // ------------------------------------------------------------------ swap callbacks++ /// @dev When ETH is the specified side of the swap, the fee is taken here, out of the+ /// specified amount. Otherwise `afterSwap` takes it from the ETH that moved.+ function beforeSwap(address, PoolKey calldata key, IPoolManager.SwapParams calldata params, bytes calldata hookData)+ external+ onlyPoolManager+ returns (bytes4, BeforeSwapDelta, uint24)+ {+ if (!_ethIsSpecified(params)) return (IHooks.beforeSwap.selector, BeforeSwapDeltaLibrary.ZERO_DELTA, 0);++ uint256 amount =+ params.amountSpecified < 0 ? uint256(-params.amountSpecified) : uint256(params.amountSpecified);+ uint256 fee = amount * FEE_BPS / BPS;+ _accrue(key, fee, hookData);+ return (IHooks.beforeSwap.selector, toBeforeSwapDelta(fee.toInt128(), 0), 0);+ }++ function afterSwap(+ address,+ PoolKey calldata key,+ IPoolManager.SwapParams calldata params,+ BalanceDelta delta,+ bytes calldata hookData+ ) external onlyPoolManager returns (bytes4, int128) {+ if (_ethIsSpecified(params)) return (IHooks.afterSwap.selector, 0);++ int128 ethMoved = delta.amount0();+ uint256 amount = uint256(uint128(ethMoved < 0 ? -ethMoved : ethMoved));+ uint256 fee = amount * FEE_BPS / BPS;+ _accrue(key, fee, hookData);+ return (IHooks.afterSwap.selector, fee.toInt128());+ }++ /// @dev ETH is currency0. The specified currency is currency0 exactly when an exact-input+ /// swap sells currency0, or an exact-output swap buys it.+ function _ethIsSpecified(IPoolManager.SwapParams calldata params) internal pure returns (bool) {+ return (params.amountSpecified < 0) == params.zeroForOne;+ }++ function _accrue(PoolKey calldata key, uint256 fee, bytes calldata hookData) internal {+ if (fee == 0) return;+ poolManager.mint(address(this), CurrencyLibrary.ADDRESS_ZERO.toId(), fee);++ PoolId poolId = key.toId();+ address creator = skins[poolId].creator;+ address referrer = _referrer(hookData);++ uint256 creatorCut = fee * CREATOR_SHARE_BPS / BPS;+ uint256 referrerCut = fee * REFERRER_SHARE_BPS / BPS;+ uint256 treasuryCut = fee - creatorCut - referrerCut;+ if (referrer == address(0)) {+ creatorCut += referrerCut;+ referrerCut = 0;+ } else {+ owed[referrer] += referrerCut;+ }+ owed[creator] += creatorCut;+ owed[treasury] += treasuryCut;+ emit FeeAccrued(poolId, referrer, creatorCut, referrerCut, treasuryCut);+ }++ /// @dev `hookData` is optional. Exactly 32 bytes holding a clean address names a referrer;+ /// anything else is ignored, so malformed data can never make a swap revert.+ function _referrer(bytes calldata hookData) internal pure returns (address) {+ if (hookData.length != 32) return address(0);+ uint256 raw = uint256(bytes32(hookData[:32]));+ if (raw >> 160 != 0) return address(0);+ // forge-lint: disable-next-line(unsafe-typecast)+ return address(uint160(raw)); // safe: the upper 96 bits were just checked to be zero++ }++ // ------------------------------------------------------------------ unused callbacks++ /// @dev Only reached when someone other than this hook initializes a pool that names it.+ function beforeInitialize(address, PoolKey calldata, uint160) external pure returns (bytes4) {+ revert OnlyThisHookLaunchesPools();+ }++ function afterInitialize(address, PoolKey calldata, uint160, int24) external pure returns (bytes4) {+ revert HookNotImplemented();+ }++ function beforeAddLiquidity(address, PoolKey calldata, IPoolManager.ModifyLiquidityParams calldata, bytes calldata)+ external+ pure+ returns (bytes4)+ {+ revert HookNotImplemented();+ }++ function afterAddLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ BalanceDelta,+ BalanceDelta,+ bytes calldata+ ) external pure returns (bytes4, BalanceDelta) {+ revert HookNotImplemented();+ }++ function beforeRemoveLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ bytes calldata+ ) external pure returns (bytes4) {+ revert HookNotImplemented();+ }++ function afterRemoveLiquidity(+ address,+ PoolKey calldata,+ IPoolManager.ModifyLiquidityParams calldata,+ BalanceDelta,+ BalanceDelta,+ bytes calldata+ ) external pure returns (bytes4, BalanceDelta) {+ revert HookNotImplemented();+ }++ function beforeDonate(address, PoolKey calldata, uint256, uint256, bytes calldata) external pure returns (bytes4) {+ revert HookNotImplemented();+ }++ function afterDonate(address, PoolKey calldata, uint256, uint256, bytes calldata) external pure returns (bytes4) {+ revert HookNotImplemented();+ }+}diff --git a/contracts/v4-hooks/src/SkinToken.sol b/contracts/v4-hooks/src/SkinToken.solnew file mode 100644index 000000000..31b3e8a0c--- /dev/null+++ b/contracts/v4-hooks/src/SkinToken.sol@@ -0,0 +1,37 @@+// SPDX-License-Identifier: MIT+pragma solidity 0.8.26;++import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";++/// @title SkinToken+/// @notice One wearable 3D item, as a fixed-supply ERC-20. Holding one whole token is the+/// right to wear the item; `SkinHook.equip` is what actually puts it on.+/// @dev No owner, no mint, no pause. The whole supply is minted once to the launching hook,+/// which seeds it into the pool. The model is pinned by hash at construction, so the+/// item people bought can never be swapped for a different mesh.+contract SkinToken is ERC20 {+ /// @notice Where the GLB lives (https, ipfs or ar URI).+ string public modelURI;+ /// @notice keccak256 of the GLB bytes. A renderer must refuse a file that does not match.+ bytes32 public immutable modelHash;+ /// @notice Avatar slot this item occupies, for example "head", "torso", "back".+ string public slot;+ /// @notice The address that launched the item and earns its royalty.+ address public immutable creator;++ constructor(+ string memory name_,+ string memory symbol_,+ uint256 supply,+ string memory modelURI_,+ bytes32 modelHash_,+ string memory slot_,+ address creator_+ ) ERC20(name_, symbol_) {+ modelURI = modelURI_;+ modelHash = modelHash_;+ slot = slot_;+ creator = creator_;+ _mint(msg.sender, supply);+ }+}diff --git a/contracts/v4-hooks/test/HookMiner.t.sol b/contracts/v4-hooks/test/HookMiner.t.solnew file mode 100644index 000000000..cbce8ed9b--- /dev/null+++ b/contracts/v4-hooks/test/HookMiner.t.sol@@ -0,0 +1,24 @@+// SPDX-License-Identifier: MIT+pragma solidity 0.8.26;++import {Test} from "forge-std/Test.sol";+import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";+import {SkinHook} from "../src/SkinHook.sol";+import {HookMiner} from "../script/HookMiner.sol";++/// Proves the deploy path itself: a mined salt really lands the hook at an address whose+/// flags pass the hook's own constructor check, with no `deployCodeTo` shortcut.+contract HookMinerTest is Test {+ uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);++ function test_minedSaltDeploysAValidHook() public {+ PoolManager manager = new PoolManager(address(this));+ bytes memory initCode =+ abi.encodePacked(type(SkinHook).creationCode, abi.encode(manager, address(this), address(0xBEEF)));+ (address expected, bytes32 salt) = HookMiner.find(address(this), FLAGS, initCode);++ SkinHook hook = new SkinHook{salt: salt}(manager, address(this), address(0xBEEF));+ assertEq(address(hook), expected);+ assertEq(uint160(address(hook)) & ((1 << 14) - 1), FLAGS);+ }+}diff --git a/contracts/v4-hooks/test/SkinHook.t.sol b/contracts/v4-hooks/test/SkinHook.t.solnew file mode 100644index 000000000..473f2e26e--- /dev/null+++ b/contracts/v4-hooks/test/SkinHook.t.sol@@ -0,0 +1,341 @@+// SPDX-License-Identifier: MIT+pragma solidity 0.8.26;++import {Test} from "forge-std/Test.sol";+import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";+import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";+import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";++import {SkinHook} from "../src/SkinHook.sol";+import {SkinToken} from "../src/SkinToken.sol";++contract NotASkinToken is ERC20 {+ constructor() ERC20("Other", "OTHER") {+ _mint(msg.sender, 10e18);+ }+}++/// Runs against the real v4-core PoolManager and its reference swap router.+contract SkinHookTest is Test {+ using PoolIdLibrary for PoolKey;+ using StateLibrary for IPoolManager;++ // beforeInitialize | beforeSwap | afterSwap | beforeSwapReturnsDelta | afterSwapReturnsDelta+ uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);+ int24 constant START_TICK = 92_200; // about 10,100 tokens per ETH++ PoolManager manager;+ PoolSwapTest router;+ SkinHook hook;+ SkinToken token;+ PoolKey key;++ address owner = makeAddr("owner");+ address treasury = makeAddr("treasury");+ address creator = makeAddr("creator");+ address referrer = makeAddr("referrer");+ address alice = makeAddr("alice");+ address bob = makeAddr("bob");++ function setUp() public {+ manager = new PoolManager(owner);+ router = new PoolSwapTest(manager);++ address hookAddr = address(uint160(uint256(0x3333) << 144) | FLAGS);+ deployCodeTo("SkinHook.sol:SkinHook", abi.encode(manager, owner, treasury), hookAddr);+ hook = SkinHook(payable(hookAddr));++ (token, key) = hook.launch(_params("Halo", "HALO", 10_000));++ vm.deal(alice, 100 ether);+ vm.deal(bob, 100 ether);+ }++ function _params(string memory name, string memory symbol, uint256 supply)+ internal+ view+ returns (SkinHook.LaunchParams memory)+ {+ return SkinHook.LaunchParams({+ name: name,+ symbol: symbol,+ supply: supply,+ modelURI: "https://three.ws/cdn/skins/halo.glb",+ modelHash: keccak256("halo-glb-bytes"),+ slot: "head",+ startTick: START_TICK,+ creator: creator+ });+ }++ // ------------------------------------------------------------------ helpers++ function _swap(address who, bool buy, int256 amountSpecified, uint256 value, bytes memory hookData)+ internal+ returns (BalanceDelta delta)+ {+ vm.prank(who);+ delta = router.swap{value: value}(+ key,+ IPoolManager.SwapParams({+ zeroForOne: buy,+ amountSpecified: amountSpecified,+ sqrtPriceLimitX96: buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1+ }),+ PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),+ hookData+ );+ }++ function _buy(address who, uint256 ethIn, bytes memory hookData) internal returns (BalanceDelta) {+ return _swap(who, true, -int256(ethIn), ethIn, hookData);+ }++ function _totalOwed() internal view returns (uint256) {+ return hook.owed(creator) + hook.owed(referrer) + hook.owed(treasury);+ }++ // ------------------------------------------------------------------ launch++ function test_launch_seedsEntireSupplyAndKeepsNothing() public view {+ assertEq(token.totalSupply(), 10_000e18);+ assertEq(token.balanceOf(address(hook)), 0, "hook holds only equipped tokens");+ assertEq(token.balanceOf(creator), 0, "no creator allocation");+ assertEq(token.balanceOf(treasury), 0, "no platform allocation");+ // Rounding dust is burned; everything else is in the pool.+ assertApproxEqAbs(token.balanceOf(address(manager)), 10_000e18, 1e6);+ assertTrue(hook.isSkin(token));+ assertEq(token.creator(), creator);+ assertEq(token.modelHash(), keccak256("halo-glb-bytes"));++ (, int24 tick,,) = IPoolManager(address(manager)).getSlot0(key.toId());+ assertEq(tick, START_TICK);+ }++ function test_launch_rejectsBadParams() public {+ SkinHook.LaunchParams memory p = _params("X", "X", 99);+ vm.expectRevert(SkinHook.InvalidSupply.selector);+ hook.launch(p);++ p = _params("X", "X", 1_000_001);+ vm.expectRevert(SkinHook.InvalidSupply.selector);+ hook.launch(p);++ p = _params("X", "X", 1000);+ p.startTick = 92_201;+ vm.expectRevert(SkinHook.InvalidStartTick.selector);+ hook.launch(p);++ p.startTick = 200;+ vm.expectRevert(SkinHook.InvalidStartTick.selector);+ hook.launch(p);++ p = _params("X", "X", 1000);+ p.modelHash = bytes32(0);+ vm.expectRevert(SkinHook.InvalidModel.selector);+ hook.launch(p);++ p = _params("X", "X", 1000);+ p.creator = address(0);+ vm.expectRevert(SkinHook.ZeroAddress.selector);+ hook.launch(p);+ }++ function test_outsiderCannotInitializeAPoolWithThisHook() public {+ NotASkinToken other = new NotASkinToken();+ PoolKey memory rogue = PoolKey({+ currency0: key.currency0,+ currency1: Currency.wrap(address(other)),+ fee: 0,+ tickSpacing: 200,+ hooks: IHooks(address(hook))+ });+ vm.expectRevert();+ manager.initialize(rogue, TickMath.getSqrtPriceAtTick(START_TICK));+ }++ // ------------------------------------------------------------------ fees++ /// The very first buy happens while the PoolManager holds no ETH at all. Fees are+ /// ERC-6909 claims, so this works; a hook that called `take` in beforeSwap would not.+ function test_buyExactInput_takesTwoPercentOfEthIn_noReferrer() public {+ assertEq(address(manager).balance, 0);+ _buy(alice, 1 ether, "");++ assertGt(token.balanceOf(alice), 0);+ assertEq(hook.owed(creator), 0.015 ether, "creator gets own share plus the unused referrer share");+ assertEq(hook.owed(treasury), 0.005 ether);+ assertEq(hook.owed(referrer), 0);+ }++ function test_buyExactInput_paysReferrer() public {+ _buy(alice, 1 ether, abi.encode(referrer));+ assertEq(hook.owed(creator), 0.01 ether);+ assertEq(hook.owed(referrer), 0.005 ether);+ assertEq(hook.owed(treasury), 0.005 ether);+ }++ function test_buyExactOutput_feeIsOnTopOfEthPaid() public {+ uint256 before = alice.balance;+ _swap(alice, true, int256(50e18), 1 ether, abi.encode(referrer));+ assertEq(token.balanceOf(alice), 50e18);++ uint256 paid = before - alice.balance;+ uint256 fee = _totalOwed();+ // paid = ethToPool + fee, and fee = 2% of ethToPool+ assertApproxEqAbs(fee, (paid - fee) * 200 / 10_000, 1);+ }++ function test_sellExactInput_feeComesOutOfEthReceived() public {+ _buy(alice, 1 ether, "");+ uint256 owedBefore = _totalOwed();+ uint256 tokens = token.balanceOf(alice);++ vm.prank(alice);+ token.approve(address(router), type(uint256).max);+ uint256 before = alice.balance;+ _swap(alice, false, -int256(tokens / 2), 0, "");++ uint256 received = alice.balance - before;+ uint256 fee = _totalOwed() - owedBefore;+ assertGt(received, 0);+ assertApproxEqAbs(fee, (received + fee) * 200 / 10_000, 1);+ }++ function test_sellExactOutput_ethIsSpecified() public {+ _buy(alice, 1 ether, "");+ uint256 owedBefore = _totalOwed();++ vm.prank(alice);+ token.approve(address(router), type(uint256).max);+ uint256 before = alice.balance;+ _swap(alice, false, int256(0.1 ether), 0, "");++ assertEq(alice.balance - before, 0.1 ether, "seller receives exactly what they asked for");+ assertEq(_totalOwed() - owedBefore, 0.002 ether);+ }++ function test_malformedHookDataNeverRevertsASwap() public {+ _buy(alice, 0.1 ether, hex"01");+ _buy(alice, 0.1 ether, abi.encode(referrer, uint256(7)));+ // 32 bytes, but with dirty upper bits: not an address, so no referrer.+ _buy(alice, 0.1 ether, abi.encode(uint256(type(uint256).max)));+ assertEq(hook.owed(referrer), 0);+ assertEq(hook.owed(creator), 0.0045 ether);+ }++ function test_claim_paysOutEthOnce() public {+ _buy(alice, 1 ether, abi.encode(referrer));++ address payout = makeAddr("payout");+ vm.prank(creator);+ uint256 amount = hook.claim(payout);+ assertEq(amount, 0.01 ether);+ assertEq(payout.balance, 0.01 ether);+ assertEq(hook.owed(creator), 0);++ vm.prank(creator);+ vm.expectRevert(SkinHook.NothingToClaim.selector);+ hook.claim(payout);++ vm.prank(referrer);+ hook.claim(referrer);+ assertEq(referrer.balance, 0.005 ether);+ }++ function test_treasuryIsOwnerControlled() public {+ address next = makeAddr("next");+ vm.prank(alice);+ vm.expectRevert();+ hook.setTreasury(next);++ vm.prank(owner);+ hook.setTreasury(next);+ _buy(alice, 1 ether, "");+ assertEq(hook.owed(next), 0.005 ether);+ assertEq(hook.owed(treasury), 0);+ }++ /// Every wei of fee the hook books is backed by a claim it holds on the PoolManager.+ function testFuzz_owedIsAlwaysBackedByClaims(uint96 ethIn, uint8 sellPct, bool withReferrer) public {+ ethIn = uint96(bound(ethIn, 1e12, 50 ether));+ bytes memory hookData = withReferrer ? abi.encode(referrer) : bytes("");+ _buy(alice, ethIn, hookData);++ uint256 tokens = token.balanceOf(alice) * (uint256(sellPct) % 101) / 100;+ if (tokens > 0) {+ vm.prank(alice);+ token.approve(address(router), type(uint256).max);+ _swap(alice, false, -int256(tokens), 0, hookData);+ }+ assertEq(manager.balanceOf(address(hook), 0), _totalOwed());+ }++ // ------------------------------------------------------------------ wear-to-lock++ function test_equipLocksOneTokenAndUnequipReturnsIt() public {+ _buy(alice, 1 ether, "");+ uint256 balance = token.balanceOf(alice);++ vm.startPrank(alice);+ token.approve(address(hook), type(uint256).max);+ hook.equip(token);+ vm.stopPrank();++ assertTrue(hook.isWearing(token, alice));+ assertEq(hook.wearerCount(token), 1);+ assertEq(token.balanceOf(alice), balance - 1e18);+ assertEq(token.balanceOf(address(hook)), 1e18, "the locked token is out of the float");++ vm.prank(alice);+ vm.expectRevert(SkinHook.AlreadyWearing.selector);+ hook.equip(token);++ vm.prank(alice);+ hook.unequip(token);+ assertFalse(hook.isWearing(token, alice));+ assertEq(hook.wearerCount(token), 0);+ assertEq(token.balanceOf(alice), balance);++ vm.prank(alice);+ vm.expectRevert(SkinHook.NotWearing.selector);+ hook.unequip(token);+ }++ function test_equipNeedsAWholeToken() public {+ _buy(bob, 0.00001 ether, "");+ assertLt(token.balanceOf(bob), 1e18);+ vm.startPrank(bob);+ token.approve(address(hook), type(uint256).max);+ vm.expectRevert();+ hook.equip(token);+ vm.stopPrank();+ }++ function test_equipRejectsTokensThisHookDidNotLaunch() public {+ NotASkinToken other = new NotASkinToken();+ other.approve(address(hook), type(uint256).max);+ vm.expectRevert(SkinHook.NotASkin.selector);+ hook.equip(SkinToken(address(other)));+ }++ function test_wearersOfOneSkinDoNotAffectAnother() public {+ (SkinToken cape,) = hook.launch(_params("Cape", "CAPE", 500));+ _buy(alice, 1 ether, "");+ vm.startPrank(alice);+ token.approve(address(hook), type(uint256).max);+ hook.equip(token);+ vm.stopPrank();+ assertEq(hook.wearerCount(token), 1);+ assertEq(hook.wearerCount(cape), 0);+ assertEq(cape.balanceOf(address(hook)), 0);+ }+}diff --git a/scripts/check-rules.mjs b/scripts/check-rules.mjsindex 5897722cf..8b36956b0 100644--- a/scripts/check-rules.mjs+++ b/scripts/check-rules.mjs@@ -93,6 +93,11 @@ const SKIP = [// scripts/check-secrets.mjs: a third party's leaked key is still a leaked key// in our history. Provenance and licences: third_party/README.md./^third_party\//,+ // Foundry dependencies vendored beside a contracts project (forge-std,+ // OpenZeppelin, Uniswap v4-core). Same reasoning as third_party/: the source+ // is upstream's, pinned to a commit, and never edited here. Our own contracts,+ // tests and scripts next to them are still scanned.+ /^contracts\/(.+\/)?lib\//,/\.min\.(js|css)$/,/package-lock\.json$/,/\.(png|jpg|jpeg|gif|webp|glb|gltf|bin|woff2?|ttf|mp4|wasm|ico|svg)$/i,