1 of 11

powered by

2 of 11

3 of 11

Uniswap V4�PoolManager

FlexFee�Hook

ETH/USDC�Pool

Uniswap V4�SwapRouter

FlexFee�App Service

Node/�Indexer

Brevis Service

Brevis Contract

Historical slot0s

Price data proof�Vol calc proof

Fulfill with proof

Store vol

Swap

beforeSwap()

override fee

On-chain

Off-chain

Here is our system data flow diagram.

Starting from the bottom of the diagram, historical slot0 storage values containing sqrtPricex96 updates are fed into our FlexFee app service which generated the released volatility of these prices along with a ZK proof of the the price data and the calculation.

These two proofs are submitted to the Brevis service which combines them into a single proof and commits this on-chain via the Brevis Request contract

This Brevis contract then executes a callback to our FlexFee hook contract which passed the verified volatility value to our hook contract.

These steps are ran every 20 minutes ensuring that our hook has the most recent volatility values.

With our hook being fed up-to-date volatility values, it is now able to calculate a dynamic fee based on this volatility together with the swap size.

This use of dynamic fees is implemented via the beforeSwap() function which returns a override fee to the PoolManager.

4 of 11

Calculating Volatility via. Brevis

get sqrtPricex96 from storage slot

calculate returns using ZipMap

calculate volatility using Sum, Div and Sqrt

Using Brevis’ feature rich SDK we are able to produce a circuit for generating realised volatility with its corresponding ZK proof.

We use the textbook realised vol formula based on the derivations of the price returns.

In these code snippets we can see how we:

Use the Brevis Map function to obtain the sqrtPricex96 from contract storage slots

Then use ZIpMap to calculate the returns between prices

And finally calculate the volatility using Sum, DIv, and Sqrt functions

@James to fill in

We go through historical block data and get the sqrtPriceX96 stored in slot0 of the pool’s storage. We compile this into a list of data which we pass onto our local server running the brevis prover with our custom volatility code implemented.

Using the in-depth and customisable Brevis SDK, we were able to use things like ZipMap and FromBinary to bitmask the storage value, calculate the prices from the sqrtPriceX96, compute the returns, and get the volatility from this data.

After this, we return the data to our TypeScript server which submits the ZK proof of our data to Brevis’ server and we then submit our given ID on-chain.

?? @James

Hook called with volatility for trades to occur

5 of 11

Fee Calculation

6 of 11

Code Walk-through

GitHub repo:

https://github.com/Decentralisedme/uhi_flexfee

This is our Brevis proof circuit written in Go using the Brevis SDK.

This circuit calculated released volatility from Uniswap pool prices obtained by reading the contract’s storage slots.

We have added added unit tests which can be seen here….

And the prover process is started, by running make start

Our application process is written in TypeScript and calculates the volatility along with a proof every 20 minutes.

This process can be started using npm run start

Here is our hook smart contract written in Solidity, in addition to implementing BaseHook it also implements BrevisApp so that this contract can also receive updated verified volatility values from Brevis.

We can see previous calculated values been written to our smart contract in Sepola Testnet here in Etherescan.

7 of 11

High Volatility

Low Volatility

8 of 11

Thank you!

Improve your pool with

powered by

9 of 11

Improve your pool with

10 of 11

Fee = sqrt(volume)*volatility/constant + min_fee

11 of 11

Top Level ETH/USDC Order Book Data Snapshot