feat: Add Maverick V2 adapter and substreams (#167)

Co-authored-by: Thales <thales@datarevenue.com>
Co-authored-by: zizou <111426680+flopell@users.noreply.github.com>

evm/src/maverick-v2/MaverickV2SwapAdapter.sol

@@ -0,0 +1,290 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+pragma solidity ^0.8.13;
+
+import {ISwapAdapter} from "src/interfaces/ISwapAdapter.sol";
+import {
+    IERC20,
+    SafeERC20
+} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/// @title MaverickV2SwapAdapter
+/// @notice Adapter for swapping tokens on MaverickV2 pools.
+contract MaverickV2SwapAdapter is ISwapAdapter {
+    using SafeERC20 for IERC20;
+
+    IMaverickV2Factory public immutable factory;
+    IMaverickV2Quoter public immutable quoter;
+
+    /// @notice Constructor to initialize the adapter with factory, quoter, and
+    /// WETH addresses.
+    /// @param factory_ The address of the MaverickV2 factory.
+    /// @param _quoter The address of the MaverickV2 quoter.
+    constructor(address factory_, address _quoter) {
+        factory = IMaverickV2Factory(factory_);
+        quoter = IMaverickV2Quoter(_quoter);
+    }
+
+    receive() external payable {}
+
+    /// @inheritdoc ISwapAdapter
+    function price(
+        bytes32 poolId,
+        address sellToken,
+        address,
+        uint256[] memory specifiedAmounts
+    ) external override returns (Fraction[] memory calculatedPrices) {
+        calculatedPrices = new Fraction[](specifiedAmounts.length);
+
+        IMaverickV2Pool pool = IMaverickV2Pool(address(bytes20(poolId)));
+
+        for (uint256 i = 0; i < specifiedAmounts.length; i++) {
+            calculatedPrices[i] = priceAt(pool, sellToken, specifiedAmounts[i]);
+        }
+        return calculatedPrices;
+    }
+
+    /// @notice Calculate the price of a token at a specified amount.
+    /// @param pool The pool to calculate the price for.
+    /// @param sellToken The token to calculate the price for.
+    /// @param sellAmount The amount of the token to calculate the price for.
+    /// @return calculatedPrice The calculated price of the token.
+    function priceAt(
+        IMaverickV2Pool pool,
+        address sellToken,
+        uint256 sellAmount
+    ) public returns (Fraction memory calculatedPrice) {
+        bool isTokenAIn = (sellToken == address(pool.tokenA()));
+        int32 tickLimit = isTokenAIn
+            ? pool.getState().activeTick + 100
+            : pool.getState().activeTick - 100;
+        (uint256 amountIn, uint256 amountOut,) = quoter.calculateSwap(
+            pool, uint128(sellAmount), isTokenAIn, false, tickLimit
+        );
+
+        calculatedPrice = Fraction(amountOut, amountIn);
+    }
+
+    /// @inheritdoc ISwapAdapter
+    function swap(
+        bytes32 poolId,
+        address sellToken,
+        address,
+        OrderSide side,
+        uint256 specifiedAmount
+    ) external override returns (Trade memory trade) {
+        if (specifiedAmount == 0) {
+            return trade;
+        }
+
+        IMaverickV2Pool pool = IMaverickV2Pool(address(bytes20(poolId)));
+        bool isTokenAIn = sellToken == address(pool.tokenA());
+        int32 tickLimit = isTokenAIn
+            ? pool.getState().activeTick + 100
+            : pool.getState().activeTick - 100;
+        uint256 gasBefore = gasleft();
+
+        if (side == OrderSide.Buy) {
+            trade.calculatedAmount =
+                buy(pool, isTokenAIn, tickLimit, specifiedAmount);
+            trade.price = priceAt(pool, sellToken, trade.calculatedAmount);
+        } else {
+            trade.calculatedAmount =
+                sell(pool, isTokenAIn, tickLimit, specifiedAmount);
+            trade.price = priceAt(pool, sellToken, specifiedAmount);
+        }
+
+        trade.gasUsed = gasBefore - gasleft();
+        return trade;
+    }
+
+    /// @notice Buy tokens from a pool.
+    /// @param pool The pool to buy from.
+    /// @param isTokenAIn Whether token A is the input token.
+    /// @param tickLimit The tick limit for the swap.
+    /// @param specifiedAmount The amount of the token to buy.
+    /// @return calculatedAmount The amount of the token bought.
+    function buy(
+        IMaverickV2Pool pool,
+        bool isTokenAIn,
+        int32 tickLimit,
+        uint256 specifiedAmount
+    ) internal returns (uint256 calculatedAmount) {
+        IMaverickV2Pool.SwapParams memory swapParams = IMaverickV2Pool
+            .SwapParams({
+            amount: specifiedAmount,
+            tokenAIn: isTokenAIn,
+            exactOutput: true,
+            tickLimit: tickLimit
+        });
+        // callback data is the sender address
+        bytes memory data = abi.encode(msg.sender);
+        (uint256 amountIn,) = pool.swap(msg.sender, swapParams, data);
+        return amountIn;
+    }
+
+    /// @notice Sell tokens to a pool.
+    /// @param pool The pool to sell to.
+    /// @param isTokenAIn Whether token A is the input token.
+    /// @param tickLimit The tick limit for the swap.
+    /// @param specifiedAmount The amount of the token to sell.
+    /// @return calculatedAmount The amount of the token sold.
+    function sell(
+        IMaverickV2Pool pool,
+        bool isTokenAIn,
+        int32 tickLimit,
+        uint256 specifiedAmount
+    ) internal returns (uint256 calculatedAmount) {
+        IMaverickV2Pool.SwapParams memory swapParams = IMaverickV2Pool
+            .SwapParams({
+            amount: specifiedAmount,
+            tokenAIn: isTokenAIn,
+            exactOutput: false,
+            tickLimit: tickLimit
+        });
+        // callback data is the sender address
+        bytes memory data = abi.encode(msg.sender);
+        (, uint256 amountOut) = pool.swap(msg.sender, swapParams, data);
+        return amountOut;
+    }
+
+    /// @notice MaverickV2SwapCallback is the callback function for MaverickV2
+    /// pools.
+    /// @param tokenIn The token being swapped.
+    /// @param amountIn The amount of the token being swapped.
+    /// @param data The data passed to the callback.
+    function maverickV2SwapCallback(
+        IERC20 tokenIn,
+        uint256 amountIn,
+        uint256,
+        bytes calldata data
+    ) external {
+        require(
+            factory.isFactoryPool(IMaverickV2Pool(msg.sender)), "NotFactoryPool"
+        );
+        address payer = abi.decode(data, (address));
+        tokenIn.safeTransferFrom(payer, msg.sender, amountIn);
+    }
+
+    /// @inheritdoc ISwapAdapter
+    function getLimits(bytes32 poolId, address sellToken, address buyToken)
+        external
+        view
+        override
+        returns (uint256[] memory limits)
+    {
+        IMaverickV2Pool pool = IMaverickV2Pool(address(bytes20(poolId)));
+        IMaverickV2Pool.State memory state = pool.getState();
+
+        limits = new uint256[](2);
+        uint256 r0 = state.reserveA;
+        uint256 r1 = state.reserveB;
+        if (sellToken < buyToken) {
+            limits[0] = r0;
+            limits[1] = r1;
+        } else {
+            limits[0] = r1;
+            limits[1] = r0;
+        }
+    }
+
+    /// @inheritdoc ISwapAdapter
+    function getCapabilities(bytes32, address, address)
+        external
+        pure
+        override
+        returns (Capability[] memory capabilities)
+    {
+        capabilities = new Capability[](3);
+        capabilities[0] = Capability.SellOrder;
+        capabilities[1] = Capability.BuyOrder;
+        capabilities[2] = Capability.PriceFunction;
+    }
+
+    /// @inheritdoc ISwapAdapter
+    function getTokens(bytes32 poolId)
+        external
+        view
+        override
+        returns (address[] memory tokens)
+    {
+        tokens = new address[](2);
+        IMaverickV2Pool pool = IMaverickV2Pool(address(bytes20(poolId)));
+        tokens[0] = address(pool.tokenA());
+        tokens[1] = address(pool.tokenB());
+    }
+
+    /// @inheritdoc ISwapAdapter
+    function getPoolIds(uint256 offset, uint256 limit)
+        external
+        view
+        override
+        returns (bytes32[] memory ids)
+    {
+        IMaverickV2Pool[] memory pools = factory.lookup(offset, offset + limit);
+        ids = new bytes32[](pools.length);
+        for (uint256 i = 0; i < pools.length; i++) {
+            ids[i] = bytes20((address(pools[i])));
+        }
+    }
+}
+
+interface IMaverickV2Pool {
+    struct SwapParams {
+        uint256 amount;
+        bool tokenAIn;
+        bool exactOutput;
+        int32 tickLimit;
+    }
+
+    struct State {
+        uint128 reserveA;
+        uint128 reserveB;
+        int64 lastTwaD8;
+        int64 lastLogPriceD8;
+        uint40 lastTimestamp;
+        int32 activeTick;
+        bool isLocked;
+        uint32 binCounter;
+        uint8 protocolFeeRatioD3;
+    }
+
+    function fee(bool tokenAIn) external view returns (uint256);
+    function tokenA() external view returns (IERC20);
+    function tokenB() external view returns (IERC20);
+    function factory() external view returns (IMaverickV2Factory);
+    function getState() external view returns (State memory);
+    function swap(
+        address recipient,
+        SwapParams memory params,
+        bytes calldata data
+    ) external returns (uint256 amountIn, uint256 amountOut);
+}
+
+interface IMaverickV2Factory {
+    function isFactoryPool(IMaverickV2Pool pool) external view returns (bool);
+
+    function lookup(uint256 startIndex, uint256 endIndex)
+        external
+        view
+        returns (IMaverickV2Pool[] memory pools);
+}
+
+interface IWETH9 is IERC20 {
+    /// @notice Deposit ether to get wrapped ether
+    function deposit() external payable;
+
+    /// @notice Withdraw wrapped ether to get ether
+    function withdraw(uint256) external;
+}
+
+interface IMaverickV2Quoter {
+    function calculateSwap(
+        IMaverickV2Pool pool,
+        uint128 amount,
+        bool tokenAIn,
+        bool exactOutput,
+        int32 tickLimit
+    )
+        external
+        returns (uint256 amountIn, uint256 amountOut, uint256 gasEstimate);
+}

evm/src/maverick-v2/manifest.yaml

@@ -0,0 +1,26 @@
+# information about the author helps us reach out in case of issues.
+author:
+  name: Zach
+  email: zachchou016@gmail.com
+
+# Protocol Constants
+constants:
+  # The expected average gas cost of a swap
+  protocol_gas: 30000
+  # Minimum capabilities we can expect, individual pools may extend these
+  capabilities:
+    - SellSide
+    - BuySide
+    - PriceFunction
+
+# The file containing the adapter contract
+contract: MaverickV2SwapAdapter.sol
+
+# Deployment instances used to generate chain specific bytecode.
+instances:
+  - chain:
+      name: mainnet
+      id: 1
+    arguments:
+      - "0x0A7e848Aca42d879EF06507Fca0E7b33A0a63c1e"
+      - "0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A"

evm/test/MaverickV2SwapAdapter.t.sol

@@ -0,0 +1,295 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+pragma solidity ^0.8.13;
+
+import "./AdapterTest.sol";
+import "forge-std/Test.sol";
+import "src/interfaces/ISwapAdapterTypes.sol";
+import "src/libraries/FractionMath.sol";
+import "src/maverick-v2/MaverickV2SwapAdapter.sol";
+
+contract MaverickV2SwapAdapterTest is AdapterTest {
+    using FractionMath for Fraction;
+
+    MaverickV2SwapAdapter adapter;
+    address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    address constant QUOTER = 0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A;
+    address constant FACTORY = 0x0A7e848Aca42d879EF06507Fca0E7b33A0a63c1e;
+    address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
+    address constant GHO = 0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f;
+    address constant GHO_USDC_POOL = 0x14Cf6D2Fe3E1B326114b07d22A6F6bb59e346c67;
+
+    uint256 constant TEST_ITERATIONS = 10;
+
+    uint256 constant GHO_BALANCE = 100_000 * 1e18;
+    uint256 constant USDC_BALANCE = 100_000 * 1e6;
+
+    function setUp() public {
+        uint256 forkBlock = 22096000;
+        vm.createSelectFork(vm.rpcUrl("mainnet"), forkBlock);
+        adapter = new MaverickV2SwapAdapter(FACTORY, QUOTER);
+
+        vm.label(address(adapter), "MaverickV2SwapAdapter");
+        vm.label(WETH, "WETH");
+        vm.label(QUOTER, "Quoter");
+        vm.label(FACTORY, "Factory");
+        vm.label(USDC, "USDC");
+        vm.label(GHO, "GHO");
+        vm.label(GHO_USDC_POOL, "GHO_USDC_POOL");
+    }
+
+    function testGetLimits() public view {
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+        uint256[] memory limits = adapter.getLimits(pair, GHO, USDC);
+
+        assertEq(limits.length, 2);
+        assertGt(limits[0], 0, "Limit for sell token should be greater than 0");
+        assertGt(limits[1], 0, "Limit for buy token should be greater than 0");
+    }
+
+    function testPriceFuzz(uint256 amount0, uint256 amount1) public {
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+        uint256[] memory limits = adapter.getLimits(pair, GHO, USDC);
+        vm.assume(amount0 < limits[0]);
+        vm.assume(amount1 < limits[0]);
+        vm.assume(amount0 > 1e16);
+        vm.assume(amount1 > 1e16);
+
+        uint256[] memory amounts = new uint256[](2);
+        amounts[0] = amount0;
+        amounts[1] = amount1;
+
+        Fraction[] memory prices = adapter.price(pair, GHO, USDC, amounts);
+
+        for (uint256 i = 0; i < prices.length; i++) {
+            assertGt(prices[i].numerator, 0);
+            assertGt(prices[i].denominator, 0);
+        }
+    }
+
+    function testPrice() public {
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+        uint256[] memory amounts = new uint256[](1);
+        amounts[0] = 10e18; // 10 GHO
+
+        Fraction[] memory prices = adapter.price(pair, GHO, USDC, amounts);
+
+        assertEq(prices.length, 1);
+        assertGt(
+            prices[0].numerator, 0, "Price numerator should be greater than 0"
+        );
+        assertGt(
+            prices[0].denominator,
+            0,
+            "Price denominator should be greater than 0"
+        );
+    }
+
+    function testPriceDecreasing() public {
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+        uint256[] memory amounts = new uint256[](TEST_ITERATIONS);
+
+        for (uint256 i = 0; i < TEST_ITERATIONS; i++) {
+            amounts[i] = 100 * (i + 1) * 10 ** 18;
+        }
+
+        Fraction[] memory prices = adapter.price(pair, GHO, USDC, amounts);
+
+        for (uint256 i = 0; i < TEST_ITERATIONS - 1; i++) {
+            assertGe(prices[i].compareFractions(prices[i + 1]), 1); // same bin
+                // price are same
+            assertGt(prices[i].denominator, 0);
+            assertGt(prices[i + 1].denominator, 0);
+        }
+    }
+
+    function testSwapSell() public {
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+        uint256 amount = 10e18; // 10 GHO
+
+        deal(GHO, address(this), GHO_BALANCE);
+        deal(USDC, address(this), USDC_BALANCE);
+
+        // Approve adapter to spend WETH
+        vm.prank(address(this));
+        IERC20(GHO).approve(address(adapter), amount);
+
+        Trade memory trade =
+            adapter.swap(pair, GHO, USDC, OrderSide.Sell, amount);
+
+        assertGt(
+            trade.calculatedAmount,
+            0,
+            "Calculated amount should be greater than 0"
+        );
+        assertGt(
+            trade.price.numerator, 0, "Price numerator should be greater than 0"
+        );
+        assertGt(
+            trade.price.denominator,
+            0,
+            "Price denominator should be greater than 0"
+        );
+        assertGt(trade.gasUsed, 0, "Gas used should be greater than 0");
+    }
+
+    function testSwapBuy() public {
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+        uint256 amount = 100e18; // buy 100 GHO
+
+        deal(GHO, address(this), GHO_BALANCE);
+        deal(USDC, address(this), USDC_BALANCE);
+
+        // Approve adapter to spend USDC
+        vm.prank(address(this));
+        IERC20(USDC).approve(address(adapter), USDC_BALANCE);
+
+        Trade memory trade =
+            adapter.swap(pair, USDC, GHO, OrderSide.Buy, amount);
+
+        assertGt(
+            trade.calculatedAmount,
+            0,
+            "Calculated amount should be greater than 0"
+        );
+        assertGt(
+            trade.price.numerator, 0, "Price numerator should be greater than 0"
+        );
+        assertGt(
+            trade.price.denominator,
+            0,
+            "Price denominator should be greater than 0"
+        );
+        assertGt(trade.gasUsed, 0, "Gas used should be greater than 0");
+    }
+
+    function testSwapFuzz(uint256 specifiedAmount, bool isBuy) public {
+        OrderSide side = isBuy ? OrderSide.Buy : OrderSide.Sell;
+
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+        uint256[] memory limits = adapter.getLimits(pair, GHO, USDC);
+
+        if (side == OrderSide.Buy) {
+            // specify buy usdc amount
+            vm.assume(specifiedAmount < limits[1]);
+
+            deal(GHO, address(this), type(uint256).max);
+            IERC20(GHO).approve(address(adapter), type(uint256).max);
+        } else {
+            // specify sell gho amount
+            vm.assume(specifiedAmount < limits[0]);
+
+            deal(GHO, address(this), specifiedAmount);
+            IERC20(GHO).approve(address(adapter), specifiedAmount);
+        }
+
+        uint256 usdc_balance = IERC20(USDC).balanceOf(address(this));
+        uint256 gho_balance = IERC20(GHO).balanceOf(address(this));
+
+        Trade memory trade =
+            adapter.swap(pair, GHO, USDC, side, specifiedAmount);
+
+        if (trade.calculatedAmount > 0) {
+            if (side == OrderSide.Buy) {
+                assertEq(
+                    specifiedAmount,
+                    IERC20(USDC).balanceOf(address(this)) - usdc_balance
+                );
+                assertEq(
+                    trade.calculatedAmount,
+                    gho_balance - IERC20(GHO).balanceOf(address(this))
+                );
+            } else {
+                assertEq(
+                    specifiedAmount,
+                    gho_balance - IERC20(GHO).balanceOf(address(this))
+                );
+                assertEq(
+                    trade.calculatedAmount,
+                    IERC20(USDC).balanceOf(address(this)) - usdc_balance
+                );
+            }
+        }
+    }
+
+    function testSwapSellIncreasing() public {
+        executeIncreasingSwaps(OrderSide.Sell);
+    }
+
+    function testSwapBuyIncreasing() public {
+        executeIncreasingSwaps(OrderSide.Buy);
+    }
+
+    function executeIncreasingSwaps(OrderSide side) internal {
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+
+        uint256[] memory amounts = new uint256[](TEST_ITERATIONS);
+        for (uint256 i = 0; i < TEST_ITERATIONS; i++) {
+            if (side == OrderSide.Sell) {
+                amounts[i] = 100 * (i + 1) * 10 ** 6; // specify sell usdc
+            } else {
+                amounts[i] = 100 * (i + 1) * 10 ** 18; // specify buy gho
+            }
+        }
+
+        deal(GHO, address(this), GHO_BALANCE);
+        deal(USDC, address(this), USDC_BALANCE);
+
+        Trade[] memory trades = new Trade[](TEST_ITERATIONS);
+        uint256 beforeSwap;
+        for (uint256 i = 0; i < TEST_ITERATIONS; i++) {
+            beforeSwap = vm.snapshot();
+
+            IERC20(USDC).approve(address(adapter), USDC_BALANCE);
+
+            trades[i] = adapter.swap(pair, USDC, GHO, side, amounts[i]);
+            vm.revertTo(beforeSwap);
+        }
+
+        for (uint256 i = 1; i < TEST_ITERATIONS - 1; i++) {
+            assertLe(trades[i].calculatedAmount, trades[i + 1].calculatedAmount);
+            assertLe(trades[i].gasUsed, trades[i + 1].gasUsed);
+            assertEq(trades[i].price.compareFractions(trades[i + 1].price), 1);
+        }
+    }
+
+    function testGetCapabilities() public view {
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+        Capability[] memory capabilities =
+            adapter.getCapabilities(pair, GHO, USDC);
+
+        assertEq(capabilities.length, 3);
+        assertEq(uint256(capabilities[0]), uint256(Capability.SellOrder));
+        assertEq(uint256(capabilities[1]), uint256(Capability.BuyOrder));
+        assertEq(uint256(capabilities[2]), uint256(Capability.PriceFunction));
+    }
+
+    function testGetTokens() public view {
+        bytes32 pair = bytes32(bytes20(GHO_USDC_POOL));
+        address[] memory tokens = adapter.getTokens(pair);
+
+        assertEq(tokens.length, 2);
+        assertEq(tokens[0], GHO);
+        assertEq(tokens[1], USDC);
+    }
+
+    function testGetPoolIds() public view {
+        uint256 offset = 0;
+        uint256 limit = 10;
+        bytes32[] memory poolIds = adapter.getPoolIds(offset, limit);
+
+        assertLe(
+            poolIds.length,
+            limit,
+            "Number of pool IDs should be less than or equal to limit"
+        );
+        if (poolIds.length > 0) {
+            assertGt(uint256(poolIds[0]), 0, "Pool ID should be greater than 0");
+        }
+    }
+
+    function testMavV2PoolBehaviour() public {
+        bytes32[] memory poolIds = new bytes32[](1);
+        poolIds[0] = bytes32(bytes20(GHO_USDC_POOL));
+        runPoolBehaviourTest(adapter, poolIds);
+    }
+}

substreams/Cargo.lock

@@ -296,6 +296,25 @@ dependencies = [
  "tycho-substreams 0.2.0 (git+https://github.com/propeller-heads/tycho-protocol-sdk.git?rev=3c08359)",
 ]
 
+[[package]]
+name = "ethereum-maverick-v2"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "ethabi 18.0.0",
+ "hex",
+ "itertools 0.10.5",
+ "num-bigint",
+ "prost 0.11.9",
+ "serde",
+ "serde-sibor",
+ "serde_qs",
+ "substreams",
+ "substreams-ethereum",
+ "substreams-helper 0.0.2 (git+https://github.com/propeller-heads/tycho-protocol-sdk.git?rev=52d5021)",
+ "tycho-substreams 0.2.1 (git+https://github.com/propeller-heads/tycho-protocol-sdk.git?rev=52d5021)",
+]
+
 [[package]]
 name = "ethereum-pancakeswap-v3"
 version = "0.1.2"
@@ -1447,6 +1466,29 @@ dependencies = [
  "tiny-keccak",
 ]
 
+[[package]]
+name = "substreams-helper"
+version = "0.0.2"
+source = "git+https://github.com/propeller-heads/tycho-protocol-sdk.git?rev=52d5021#52d502198e9aa964814ef5f139df0886c3eb7bb0"
+dependencies = [
+ "anyhow",
+ "base64",
+ "bigdecimal",
+ "downcast-rs",
+ "ethabi 18.0.0",
+ "hex",
+ "hex-literal 0.4.1",
+ "num-bigint",
+ "pad",
+ "prost 0.11.9",
+ "prost-types 0.12.6",
+ "substreams",
+ "substreams-entity-change",
+ "substreams-ethereum",
+ "thiserror 1.0.69",
+ "tiny-keccak",
+]
+
 [[package]]
 name = "substreams-helper"
 version = "0.0.2"

substreams/Cargo.toml

@@ -15,6 +15,7 @@ members = [
     "ethereum-template-singleton",
     "ethereum-uniswap-v4",
     "ethereum-ekubo-v2",
+    "ethereum-maverick-v2",
 ]
 resolver = "2"
 

substreams/ethereum-maverick-v2/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "ethereum-maverick-v2"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "ethereum_maverick_v2"
+crate-type = ["cdylib"]
+
+[dependencies]
+substreams = "0.5.22"
+substreams-ethereum = "0.9.9"
+prost = "0.11"
+substreams-helper = { git = "https://github.com/propeller-heads/tycho-protocol-sdk.git", rev = "52d5021" }
+tycho-substreams = { git = "https://github.com/propeller-heads/tycho-protocol-sdk.git", rev = "52d5021" }
+anyhow = "1.0.95"
+ethabi = "18.0.0"
+num-bigint = "0.4.6"
+hex = "0.4.3"
+itertools = "0.10.5"
+serde = "1.0.217"
+serde_qs = "0.13.0"
+serde-sibor = "0.1.0"
+
+
+[build-dependencies]
+anyhow = "1"
+substreams-ethereum = "0.9.9"

substreams/ethereum-maverick-v2/buf.gen.yaml

@@ -0,0 +1,12 @@
+
+version: v1
+plugins:
+- plugin: buf.build/community/neoeinstein-prost:v0.2.2
+  out: src/pb
+  opt:
+    - file_descriptor_set=false
+
+- plugin: buf.build/community/neoeinstein-prost-crate:v0.3.1
+  out: src/pb
+  opt:
+    - no_features

substreams/ethereum-maverick-v2/build.rs

@@ -0,0 +1,49 @@
+use anyhow::Result;
+use std::{fs, io::Write};
+use substreams_ethereum::Abigen;
+
+fn main() -> Result<()> {
+    let abi_folder = "abi";
+    let output_folder = "src/abi";
+
+    let abis = fs::read_dir(abi_folder)?;
+
+    let mut files = abis.collect::<Result<Vec<_>, _>>()?;
+
+    // Sort the files by their name
+    files.sort_by_key(|a| a.file_name());
+
+    let mut mod_rs_content = String::new();
+    mod_rs_content.push_str("#![allow(clippy::all)]\n");
+
+    for file in files {
+        let file_name = file.file_name();
+        let file_name = file_name.to_string_lossy();
+
+        if !file_name.ends_with(".json") {
+            continue;
+        }
+
+        let contract_name = file_name.split('.').next().unwrap();
+
+        let input_path = format!("{abi_folder}/{file_name}");
+        let output_path = format!("{output_folder}/{contract_name}.rs");
+
+        mod_rs_content.push_str(&format!("pub mod {contract_name};\n"));
+
+        if std::path::Path::new(&output_path).exists() {
+            continue;
+        }
+
+        Abigen::new(contract_name, &input_path)?
+            .generate()?
+            .write_to_file(&output_path)?;
+    }
+
+    let mod_rs_path = format!("{output_folder}/mod.rs");
+    let mut mod_rs_file = fs::File::create(mod_rs_path)?;
+
+    mod_rs_file.write_all(mod_rs_content.as_bytes())?;
+
+    Ok(())
+}

substreams/ethereum-maverick-v2/ethereum-maverick-v2.yaml

@@ -0,0 +1,72 @@
+specVersion: v0.1.0
+package:
+  name: "ethereum_maverick_v2"
+  version: v0.1.0
+
+protobuf:
+  files:
+    - tycho/evm/v1/vm.proto
+    - tycho/evm/v1/common.proto
+    - tycho/evm/v1/utils.proto
+    - maverick.proto
+  importPaths:
+    - ./proto/v1
+    - ../../proto
+
+binaries:
+  default:
+    type: wasm/rust-v1
+    file: ../target/wasm32-unknown-unknown/release/ethereum_maverick_v2.wasm
+
+modules:
+  - name: map_components
+    kind: map
+    initialBlock: 20027237 # factory creation block
+    inputs:
+      - params: string
+      - source: sf.ethereum.type.v2.Block
+    output:
+      type: proto:tycho.evm.v1.BlockTransactionProtocolComponents
+
+  - name: store_components
+    kind: store
+    initialBlock: 20027237
+    updatePolicy: set_if_not_exists
+    valueType: proto:maverick.v2.Pool
+    inputs:
+      - map: map_components
+
+  - name: map_relative_balances
+    kind: map
+    initialBlock: 20027237
+    inputs:
+      - source: sf.ethereum.type.v2.Block
+      - store: store_components
+    output:
+      type: proto:tycho.evm.v1.BlockBalanceDeltas
+
+  - name: store_balances
+    kind: store
+    initialBlock: 20027237
+    updatePolicy: add
+    valueType: bigint
+    inputs:
+      - map: map_relative_balances
+
+  - name: map_protocol_changes
+    kind: map
+    initialBlock: 20027237
+    inputs:
+      - params: string
+      - source: sf.ethereum.type.v2.Block
+      - map: map_components
+      - map: map_relative_balances
+      - store: store_components
+      - store: store_balances
+        mode: deltas
+    output:
+      type: proto:tycho.evm.v1.BlockChanges
+
+params:
+  map_components: "factory=0A7e848Aca42d879EF06507Fca0E7b33A0a63c1e&quoter=b40AfdB85a07f37aE217E7D6462e609900dD8D7A"
+  map_protocol_changes: "factory=0A7e848Aca42d879EF06507Fca0E7b33A0a63c1e&quoter=b40AfdB85a07f37aE217E7D6462e609900dD8D7A"

substreams/ethereum-maverick-v2/integration_test.tycho.yaml

@@ -0,0 +1,40 @@
+substreams_yaml_path: ./ethereum-maverick-v2.yaml
+adapter_contract: "MaverickV2SwapAdapter"
+adapter_build_signature: "constructor(address,address)"
+adapter_build_args: "0x0A7e848Aca42d879EF06507Fca0E7b33A0a63c1e,0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A"
+skip_balance_check: false
+initialized_accounts:
+  - "0x0A7e848Aca42d879EF06507Fca0E7b33A0a63c1e" # Factory
+  - "0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A" # Quoter
+protocol_type_names:
+  - "maverick_v2_pool"
+tests:
+  - name: test_pool_creation
+    start_block: 20122172
+    stop_block: 20122272
+    expected_components:
+      - id: "0xEB1da432D5C1a9FDF52aA5D37698f34706F91397"
+        tokens:
+          - "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" # WETH
+          - "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" # USDC
+        static_attributes:
+          fee_a_in: "0x5af3107a4000"
+          fee_b_in: "0x5af3107a4000"
+          tick_spacing: "0x08b8"
+          kinds: "0x01"
+        creation_tx: "0xb181cf013f46b5bd13a0244733c463b120b3d7eef68c74c11e0f0e4b6a0027e4"
+
+  - name: test_gho_usdc_pool_creation
+    start_block: 20127132
+    stop_block: 20127232
+    expected_components:
+      - id: "0x14Cf6D2Fe3E1B326114b07d22A6F6bb59e346c67"
+        tokens:
+          - "0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f" # GHO
+          - "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" # USDC
+        static_attributes:
+          fee_a_in: "0x5af3107a4000"
+          fee_b_in: "0x5af3107a4000"
+          tick_spacing: "0x2"
+          kinds: "0xf"
+        creation_tx: "0xa1c5c6a7d5886caefa4ab660575f0d3a63297d4859644039fe656edcd031a9dc"

substreams/ethereum-maverick-v2/proto/v1/maverick.proto

@@ -0,0 +1,10 @@
+syntax = "proto3";
+
+package maverick.v2;
+
+message Pool {
+  bytes address = 1;
+  bytes tokenA = 2;
+  bytes tokenB = 3;
+  bytes created_tx_hash = 4;
+}

substreams/ethereum-maverick-v2/rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "1.83.0"
+components = [ "rustfmt" ]
+targets = [ "wasm32-unknown-unknown" ]

substreams/ethereum-maverick-v2/src/abi/mod.rs

@@ -0,0 +1,3 @@
+#![allow(clippy::all)]
+pub mod factory;
+pub mod pool;

substreams/ethereum-maverick-v2/src/events/add_liquidity.rs

@@ -0,0 +1,43 @@
+use crate::{
+    abi::pool::events::PoolAddLiquidity, events::BalanceEventTrait, pb::maverick::v2::Pool,
+};
+use substreams_helper::hex::Hexable;
+use tycho_substreams::prelude::*;
+
+impl BalanceEventTrait for PoolAddLiquidity {
+    fn get_balance_delta(&self, tx: &Transaction, pool: &Pool, ordinal: u64) -> Vec<BalanceDelta> {
+        let changed_balance = vec![
+            BalanceDelta {
+                ord: ordinal,
+                tx: Some(tx.clone()),
+                token: pool.token_a.clone(),
+                delta: self
+                    .token_a_amount
+                    .clone()
+                    .to_signed_bytes_be(),
+                component_id: pool
+                    .address
+                    .clone()
+                    .to_hex()
+                    .as_bytes()
+                    .to_vec(),
+            },
+            BalanceDelta {
+                ord: ordinal,
+                tx: Some(tx.clone()),
+                token: pool.token_b.clone(),
+                delta: self
+                    .token_b_amount
+                    .clone()
+                    .to_signed_bytes_be(),
+                component_id: pool
+                    .address
+                    .clone()
+                    .to_hex()
+                    .as_bytes()
+                    .to_vec(),
+            },
+        ];
+        changed_balance
+    }
+}

substreams/ethereum-maverick-v2/src/events/mod.rs

@@ -0,0 +1,82 @@
+use crate::{
+    abi::pool::events::{PoolAddLiquidity, PoolRemoveLiquidity, PoolSwap},
+    pb::maverick::v2::Pool,
+};
+use substreams_ethereum::{pb::eth::v2::Log, Event};
+use tycho_substreams::prelude::*;
+
+pub mod add_liquidity;
+pub mod remove_liquidity;
+pub mod swap;
+
+/// A trait for extracting changed balance from an event.
+pub trait BalanceEventTrait {
+    /// Get all balance deltas from the event.
+    ///
+    /// # Arguments
+    ///
+    /// * `tx` - Reference to the `Transaction`.
+    /// * `pool` - Reference to the `Pool`.
+    /// * `ordinal` - The ordinal number of the event. This is used by the balance store to sort the
+    ///
+    /// # Returns
+    ///
+    /// A vector of `BalanceDelta` that represents the balance deltas.
+    fn get_balance_delta(&self, tx: &Transaction, pool: &Pool, ordinal: u64) -> Vec<BalanceDelta>;
+}
+
+/// Represent every events of a Maverick pool.
+pub enum EventType {
+    PoolSwap(PoolSwap),
+    AddLiquidity(PoolAddLiquidity),
+    RemoveLiquidity(PoolRemoveLiquidity),
+}
+
+impl EventType {
+    fn as_event_trait(&self) -> &dyn BalanceEventTrait {
+        match self {
+            EventType::PoolSwap(event) => event,
+            EventType::AddLiquidity(event) => event,
+            EventType::RemoveLiquidity(event) => event,
+        }
+    }
+}
+
+/// Decodes the event from the log.
+///
+/// # Arguments
+///
+/// * `event` - A reference to the `Log`.
+///
+/// # Returns
+///
+/// An `Option` that contains the `EventType` if the event is recognized.
+pub fn decode_event(event: &Log) -> Option<EventType> {
+    [
+        PoolSwap::match_and_decode(event).map(EventType::PoolSwap),
+        PoolAddLiquidity::match_and_decode(event).map(EventType::AddLiquidity),
+        PoolRemoveLiquidity::match_and_decode(event).map(EventType::RemoveLiquidity),
+    ]
+    .into_iter()
+    .find_map(std::convert::identity)
+}
+
+/// Gets the changed balances from the log.
+///
+/// # Arguments
+///
+/// * `tx` - Reference to the `Transaction`.
+/// * `event` - Reference to the `Log`.
+/// * `pool` - Reference to the `Pool`.
+///
+/// # Returns
+///
+/// A vector of `BalanceDelta` that represents
+pub fn get_log_changed_balances(tx: &Transaction, event: &Log, pool: &Pool) -> Vec<BalanceDelta> {
+    decode_event(event)
+        .map(|e| {
+            e.as_event_trait()
+                .get_balance_delta(tx, pool, event.ordinal)
+        })
+        .unwrap_or_default()
+}

substreams/ethereum-maverick-v2/src/events/remove_liquidity.rs

@@ -0,0 +1,45 @@
+use crate::{
+    abi::pool::events::PoolRemoveLiquidity, events::BalanceEventTrait, pb::maverick::v2::Pool,
+};
+use substreams_helper::hex::Hexable;
+use tycho_substreams::prelude::*;
+
+impl BalanceEventTrait for PoolRemoveLiquidity {
+    fn get_balance_delta(&self, tx: &Transaction, pool: &Pool, ordinal: u64) -> Vec<BalanceDelta> {
+        let changed_balance = vec![
+            BalanceDelta {
+                ord: ordinal,
+                tx: Some(tx.clone()),
+                token: pool.token_a.clone(),
+                delta: self
+                    .token_a_out
+                    .neg()
+                    .clone()
+                    .to_signed_bytes_be(),
+                component_id: pool
+                    .address
+                    .clone()
+                    .to_hex()
+                    .as_bytes()
+                    .to_vec(),
+            },
+            BalanceDelta {
+                ord: ordinal,
+                tx: Some(tx.clone()),
+                token: pool.token_b.clone(),
+                delta: self
+                    .token_b_out
+                    .neg()
+                    .clone()
+                    .to_signed_bytes_be(),
+                component_id: pool
+                    .address
+                    .clone()
+                    .to_hex()
+                    .as_bytes()
+                    .to_vec(),
+            },
+        ];
+        changed_balance
+    }
+}

substreams/ethereum-maverick-v2/src/events/swap.rs

@@ -0,0 +1,43 @@
+use crate::{abi::pool::events::PoolSwap, events::BalanceEventTrait, pb::maverick::v2::Pool};
+use substreams_helper::hex::Hexable;
+use tycho_substreams::prelude::*;
+
+impl BalanceEventTrait for PoolSwap {
+    fn get_balance_delta(&self, tx: &Transaction, pool: &Pool, ordinal: u64) -> Vec<BalanceDelta> {
+        let (token_in, token_out, amount_in, amount_out) = if self.params.1 {
+            (&pool.token_a, &pool.token_b, &self.amount_in, &self.amount_out)
+        } else {
+            (&pool.token_b, &pool.token_a, &self.amount_in, &self.amount_out)
+        };
+
+        vec![
+            BalanceDelta {
+                ord: ordinal,
+                tx: Some(tx.clone()),
+                token: token_in.clone(),
+                delta: amount_in.clone().to_signed_bytes_be(),
+                component_id: pool
+                    .address
+                    .clone()
+                    .to_hex()
+                    .as_bytes()
+                    .to_vec(),
+            },
+            BalanceDelta {
+                ord: ordinal,
+                tx: Some(tx.clone()),
+                token: token_out.clone(),
+                delta: amount_out
+                    .neg()
+                    .clone()
+                    .to_signed_bytes_be(),
+                component_id: pool
+                    .address
+                    .clone()
+                    .to_hex()
+                    .as_bytes()
+                    .to_vec(),
+            },
+        ]
+    }
+}

substreams/ethereum-maverick-v2/src/lib.rs

@@ -0,0 +1,7 @@
+#![allow(clippy::not_unsafe_ptr_arg_deref)]
+mod abi;
+mod events;
+mod modules;
+mod pb;
+
+pub use modules::*;

substreams/ethereum-maverick-v2/src/modules/1_map_components.rs

@@ -0,0 +1,55 @@
+use anyhow::{Ok, Result};
+use ethabi::ethereum_types::Address;
+use substreams_ethereum::pb::eth::v2::{Block, Log, TransactionTrace};
+use tycho_substreams::prelude::*;
+
+use crate::{abi::factory::events::PoolCreated, modules::utils::Params};
+use substreams_helper::{event_handler::EventHandler, hex::Hexable};
+
+#[substreams::handlers::map]
+pub fn map_components(params: String, block: Block) -> Result<BlockTransactionProtocolComponents> {
+    let mut new_pools: Vec<TransactionProtocolComponents> = vec![];
+    let params = Params::parse_from_query(&params)?;
+    get_new_pools(params, &block, &mut new_pools);
+
+    Ok(BlockTransactionProtocolComponents { tx_components: new_pools })
+}
+
+fn get_new_pools(
+    params: Params,
+    block: &Block,
+    new_pools: &mut Vec<TransactionProtocolComponents>,
+) {
+    let (factory_address, quoter_address) = params.decode_addresses().unwrap();
+
+    let mut on_pool_created = |event: PoolCreated, _tx: &TransactionTrace, _log: &Log| {
+        let tycho_tx: Transaction = _tx.into();
+        let contracts = vec![
+            event.pool_address.as_slice(),
+            factory_address.as_slice(),
+            quoter_address.as_slice(),
+        ];
+        let new_pool_component = ProtocolComponent::new(&event.pool_address.to_hex())
+            .with_tokens(&[event.token_a.as_slice(), event.token_b.as_slice()])
+            .with_contracts(&contracts)
+            .with_attributes(&[
+                ("fee_a_in", &event.fee_a_in.to_signed_bytes_be()),
+                ("fee_b_in", &event.fee_b_in.to_signed_bytes_be()),
+                ("tick_spacing", &event.tick_spacing.to_signed_bytes_be()),
+                ("kinds", &event.kinds.to_signed_bytes_be()),
+            ])
+            .as_swap_type("maverick_v2_pool", ImplementationType::Vm);
+
+        new_pools.push(TransactionProtocolComponents {
+            tx: Some(tycho_tx.clone()),
+            components: vec![new_pool_component],
+        });
+    };
+
+    let mut eh = EventHandler::new(block);
+
+    eh.filter_by_address(vec![Address::from_slice(&factory_address)]);
+
+    eh.on::<PoolCreated, _>(&mut on_pool_created);
+    eh.handle_events();
+}

substreams/ethereum-maverick-v2/src/modules/2_store_components.rs

@@ -0,0 +1,25 @@
+use crate::pb::maverick::v2::Pool;
+use substreams::{
+    prelude::{StoreSetIfNotExists, StoreSetIfNotExistsProto},
+    store::StoreNew,
+};
+use tycho_substreams::prelude::*;
+
+#[substreams::handlers::store]
+pub fn store_components(
+    map: BlockTransactionProtocolComponents,
+    store: StoreSetIfNotExistsProto<Pool>,
+) {
+    for tx_pc in map.tx_components {
+        for pc in tx_pc.components {
+            let pool_address = &pc.id;
+            let pool = Pool {
+                address: hex::decode(pool_address.trim_start_matches("0x")).unwrap(),
+                token_a: pc.tokens[0].clone(),
+                token_b: pc.tokens[1].clone(),
+                created_tx_hash: tx_pc.tx.as_ref().unwrap().hash.clone(),
+            };
+            store.set_if_not_exists(0, format!("Pool:{pool_address}"), &pool);
+        }
+    }
+}

substreams/ethereum-maverick-v2/src/modules/3_map_relative_balances.rs

@@ -0,0 +1,39 @@
+use crate::{events::get_log_changed_balances, pb::maverick::v2::Pool};
+use anyhow::{Ok, Result};
+use substreams::{prelude::StoreGetProto, store::StoreGet};
+use substreams_ethereum::pb::eth::v2::Block;
+use substreams_helper::hex::Hexable;
+use tycho_substreams::prelude::*;
+
+#[substreams::handlers::map]
+pub fn map_relative_balances(
+    block: Block,
+    pools_store: StoreGetProto<Pool>,
+) -> Result<BlockBalanceDeltas, anyhow::Error> {
+    let mut balance_deltas = Vec::new();
+    for trx in block.transactions() {
+        let mut tx_deltas = Vec::new();
+        let tx = Transaction {
+            to: trx.to.clone(),
+            from: trx.from.clone(),
+            hash: trx.hash.clone(),
+            index: trx.index.into(),
+        };
+        for log in trx
+            .calls
+            .iter()
+            .filter(|call| !call.state_reverted)
+            .flat_map(|call| &call.logs)
+        {
+            if let Some(pool) = pools_store.get_last(format!("Pool:{}", &log.address.to_hex())) {
+                tx_deltas.extend(get_log_changed_balances(&tx, log, &pool));
+            } else {
+                continue;
+            }
+        }
+        if !tx_deltas.is_empty() {
+            balance_deltas.extend(tx_deltas);
+        }
+    }
+    Ok(BlockBalanceDeltas { balance_deltas })
+}

substreams/ethereum-maverick-v2/src/modules/4_store_balances.rs

@@ -0,0 +1,7 @@
+use substreams::store::{StoreAddBigInt, StoreNew};
+use tycho_substreams::prelude::*;
+
+#[substreams::handlers::store]
+pub fn store_balances(balances_deltas: BlockBalanceDeltas, store: StoreAddBigInt) {
+    tycho_substreams::balances::store_balance_changes(balances_deltas, store);
+}

substreams/ethereum-maverick-v2/src/modules/5_map_protocol_changes.rs

@@ -0,0 +1,118 @@
+use crate::{modules::utils::Params, pb::maverick::v2::Pool};
+use anyhow::Result;
+use itertools::Itertools;
+use std::collections::HashMap;
+use substreams::{pb::substreams::StoreDeltas, prelude::StoreGetProto, store::StoreGet};
+use substreams_ethereum::pb::eth::v2::Block;
+use substreams_helper::hex::Hexable;
+use tycho_substreams::{
+    balances::aggregate_balances_changes, contract::extract_contract_changes_builder, prelude::*,
+};
+
+#[substreams::handlers::map]
+pub fn map_protocol_changes(
+    params: String,
+    block: Block,
+    protocol_components: BlockTransactionProtocolComponents,
+    balance_deltas: BlockBalanceDeltas,
+    pool_store: StoreGetProto<Pool>,
+    balance_store: StoreDeltas,
+) -> Result<BlockChanges> {
+    let params = Params::parse_from_query(&params)?;
+    let (factory_address, quoter_address) = params.decode_addresses()?;
+    let mut transaction_changes: HashMap<_, TransactionChangesBuilder> = HashMap::new();
+
+    protocol_components
+        .tx_components
+        .iter()
+        .for_each(|tx_component| {
+            let tx = tx_component.tx.as_ref().unwrap();
+            let builder = transaction_changes
+                .entry(tx.index)
+                .or_insert_with(|| TransactionChangesBuilder::new(tx));
+
+            tx_component
+                .components
+                .iter()
+                .for_each(|c| {
+                    builder.add_protocol_component(c);
+                });
+        });
+
+    aggregate_balances_changes(balance_store, balance_deltas)
+        .into_iter()
+        .for_each(|(_, (tx, balances))| {
+            let builder = transaction_changes
+                .entry(tx.index)
+                .or_insert_with(|| TransactionChangesBuilder::new(&tx));
+            balances
+                .values()
+                .for_each(|token_bc_map| {
+                    token_bc_map
+                        .values()
+                        .for_each(|bc| builder.add_balance_change(bc))
+                });
+        });
+
+    extract_contract_changes_builder(
+        &block,
+        |addr| {
+            pool_store
+                .get_last(format!("Pool:0x{}", hex::encode(addr)))
+                .is_some() ||
+                addr.eq(factory_address.as_slice())
+        },
+        &mut transaction_changes,
+    );
+
+    block
+        .transactions()
+        .for_each(|block_tx| {
+            block_tx.calls.iter().for_each(|call| {
+                if call.address == quoter_address {
+                    let mut contract_change =
+                        InterimContractChange::new(call.address.as_slice(), true);
+
+                    if let Some(code_change) = &call.code_changes.first() {
+                        contract_change.set_code(&code_change.new_code);
+                    }
+
+                    let builder = transaction_changes
+                        .entry(block_tx.index.into())
+                        .or_insert_with(|| TransactionChangesBuilder::new(&(block_tx.into())));
+                    builder.add_contract_changes(&contract_change);
+                }
+            });
+        });
+
+    transaction_changes
+        .iter_mut()
+        .for_each(|(_, change)| {
+            // this indirection is necessary due to borrowing rules.
+            let addresses = change
+                .changed_contracts()
+                .map(|e| e.to_vec())
+                .collect::<Vec<_>>();
+            addresses
+                .into_iter()
+                .for_each(|address| {
+                    // check if the address is not a pool
+                    if address != factory_address.as_slice() && address != quoter_address.as_slice()
+                    {
+                        let pool = pool_store
+                            .get_last(format!("Pool:0x{}", hex::encode(address)))
+                            .unwrap();
+                        change.mark_component_as_updated(&pool.address.to_hex());
+                    }
+                })
+        });
+
+    Ok(BlockChanges {
+        block: Some((&block).into()),
+        changes: transaction_changes
+            .drain()
+            .sorted_unstable_by_key(|(index, _)| *index)
+            .filter_map(|(_, builder)| builder.build())
+            .collect::<Vec<_>>(),
+    })
+}

substreams/ethereum-maverick-v2/src/modules/mod.rs

@@ -0,0 +1,21 @@
+pub use map_components::map_components;
+pub use map_protocol_changes::map_protocol_changes;
+pub use map_relative_balances::map_relative_balances;
+pub use store_balances::store_balances;
+pub use store_components::store_components;
+
+#[path = "1_map_components.rs"]
+mod map_components;
+
+#[path = "2_store_components.rs"]
+mod store_components;
+
+#[path = "3_map_relative_balances.rs"]
+mod map_relative_balances;
+
+#[path = "4_store_balances.rs"]
+mod store_balances;
+
+#[path = "5_map_protocol_changes.rs"]
+mod map_protocol_changes;
+mod utils;

substreams/ethereum-maverick-v2/src/modules/utils.rs

@@ -0,0 +1,26 @@
+use anyhow::{anyhow, Result};
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct Params {
+    pub factory: String,
+    pub quoter: String,
+}
+
+impl Params {
+    pub fn parse_from_query(input: &str) -> Result<Self> {
+        serde_qs::from_str(input).map_err(|e| anyhow!("Failed to parse query params: {}", e))
+    }
+
+    pub fn decode_addresses(&self) -> Result<([u8; 20], [u8; 20])> {
+        let factory =
+            hex::decode(&self.factory).map_err(|e| anyhow!("Invalid factory hex: {}", e))?;
+        let quoter = hex::decode(&self.quoter).map_err(|e| anyhow!("Invalid quoter hex: {}", e))?;
+
+        if factory.len() != 20 || quoter.len() != 20 {
+            return Err(anyhow!("Addresses must be 20 bytes"));
+        }
+
+        Ok((factory.try_into().unwrap(), quoter.try_into().unwrap()))
+    }
+}

substreams/ethereum-maverick-v2/src/pb/maverick.v2.rs

@@ -0,0 +1,14 @@
+// @generated
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Pool {
+    #[prost(bytes="vec", tag="1")]
+    pub address: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes="vec", tag="2")]
+    pub token_a: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes="vec", tag="3")]
+    pub token_b: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes="vec", tag="4")]
+    pub created_tx_hash: ::prost::alloc::vec::Vec<u8>,
+}
+// @@protoc_insertion_point(module)

substreams/ethereum-maverick-v2/src/pb/mod.rs

@@ -0,0 +1,8 @@
+// @generated
+pub mod maverick {
+    // @@protoc_insertion_point(attribute:maverick.v2)
+    pub mod v2 {
+        include!("maverick.v2.rs");
+        // @@protoc_insertion_point(maverick.v2)
+    }
+}

substreams/rustfmt.toml

@@ -20,4 +20,5 @@ ignore = [
     "ethereum-uniswap-v3-logs-only/src/abi",
     "ethereum-pancakeswap-v3/src/abi",
     "ethereum-uniswap-v4/src/abi",
+    "ethereum-maverick-v2/src/abi",
 ]