SirProxy

{{
  "language": "Solidity",
  "sources": {
    "src/SirProxy.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {ISIR} from "core/interfaces/ISIR.sol";
import {IVault} from "core/interfaces/IVault.sol";
import {IERC20} from "core/interfaces/IWETH9.sol";
import {IAssistant} from "./interfaces/IAssistant.sol";
import {SirStructs} from "core/libraries/SirStructs.sol";
import {AddressClone} from "core/libraries/AddressClone.sol";

// Minimal interface to get VAULT from Assistant
interface IAssistantVault {
    function VAULT() external view returns (address);
}

/**
 * @title SirProxy
 * @dev This contract is designed for read-only operations
 */
contract SirProxy {
    ISIR public immutable SIR_TOKEN;
    IVault public immutable VAULT;
    IAssistant public immutable ASSISTANT;

    constructor(address _assistant) {
        ASSISTANT = IAssistant(_assistant);
        // Get VAULT address from Assistant (it has a public VAULT getter)
        VAULT = IVault(IAssistantVault(_assistant).VAULT());
        // Get SIR token address from Vault
        SIR_TOKEN = ISIR(payable(VAULT.SIR()));
    }

    /**
     * @notice Returns the name of the token
     * @return The name from the SIR token contract
     */
    function name() external view returns (string memory) {
        return "Proxy SIR for offchain operations";
    }

    /**
     * @notice Returns the symbol of the token
     * @return The symbol from the SIR token contract
     */
    function symbol() external view returns (string memory) {
        return SIR_TOKEN.symbol();
    }

    /**
     * @notice Returns the number of decimals the token uses
     * @return The decimals from the SIR token contract
     */
    function decimals() external view returns (uint8) {
        return SIR_TOKEN.decimals();
    }

    /**
     * @notice Returns the total supply of SIR tokens
     * @return The total supply from the SIR token contract
     */
    function totalSupply() external view returns (uint256) {
        return SIR_TOKEN.totalSupply();
    }

    /**
     * @notice Returns the aggregated SIR balance for an account from all sources
     * @dev Aggregates: current balance, staked (locked + unlocked), unclaimed rewards, pending contributor rewards, and equity from TEA/APE tokens
     * @param account The address to check the balance for
     * @return totalBalance The total aggregated SIR balance
     */
    function balanceOf(address account) external view returns (uint256 totalBalance) {
        // 1. Get current SIR token balance
        totalBalance = SIR_TOKEN.balanceOf(account);

        // 2. Get staked SIR (both unlocked and locked)
        (uint80 unlockedStake, uint80 lockedStake) = SIR_TOKEN.stakeOf(account);
        totalBalance += unlockedStake + lockedStake;

        // 3. Get unclaimed SIR rewards from LP positions across all vaults
        uint48 numberOfVaults = VAULT.numberOfVaults();
        for (uint48 vaultId = 1; vaultId <= numberOfVaults; vaultId++) {
            // Get unclaimed rewards for this vault
            uint80 unclaimedRewards = VAULT.unclaimedRewards(vaultId, account);
            totalBalance += unclaimedRewards;
        }

        // 4. Get pending contributor rewards
        uint80 contributorRewards = SIR_TOKEN.contributorUnclaimedSIR(account);
        totalBalance += contributorRewards;

        // 5. Get SIR equity from TEA and APE tokens
        totalBalance += _getSirEquityFromTeaAndApe(account, numberOfVaults);
    }

    /**
     * @notice Calculate SIR equity from TEA and APE token holdings
     * @dev Uses Assistant's quoteBurn to determine SIR value, wrapped in try-catch
     * @param account The account to check
     * @param numberOfVaults Total number of vaults to iterate through
     * @return sirEquity The total SIR equity from TEA and APE tokens
     */
    function _getSirEquityFromTeaAndApe(
        address account,
        uint48 numberOfVaults
    ) private view returns (uint256 sirEquity) {
        for (uint48 vaultId = 1; vaultId <= numberOfVaults; vaultId++) {
            // Get vault parameters
            SirStructs.VaultParameters memory vaultParams = VAULT.paramsById(vaultId);

            // Skip if collateral is not SIR
            if (vaultParams.collateralToken != address(SIR_TOKEN)) continue;

            // Get TEA balance and calculate SIR equity
            uint256 teaBalance = VAULT.balanceOf(account, vaultId);
            if (teaBalance > 0) {
                try ASSISTANT.quoteBurn(false, vaultParams, teaBalance) returns (uint144 collateralAmount) {
                    // Direct 1:1 since collateral is SIR
                    sirEquity += collateralAmount;
                } catch {
                    // If quoteBurn reverts, assume 0 SIR value
                }
            }

            // Get APE balance and calculate SIR equity
            address apeToken = AddressClone.getAddress(address(VAULT), vaultId);
            uint256 apeBalance = IERC20(apeToken).balanceOf(account);
            if (apeBalance > 0) {
                try ASSISTANT.quoteBurn(true, vaultParams, apeBalance) returns (uint144 collateralAmount) {
                    // Direct 1:1 since collateral is SIR
                    sirEquity += collateralAmount;
                } catch {
                    // If quoteBurn reverts, assume 0 SIR value
                }
            }
        }

        return sirEquity;
    }
}
"
    },
    "lib/Core/src/interfaces/ISIR.sol": {
      "content": "// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import {SirStructs} from "../libraries/SirStructs.sol";

interface ISIR {
    error AuctionIsNotOver();
    error BidTooLow();
    error InsufficientUnlockedStake();
    error InvalidSigner();
    error NewAuctionCannotStartYet();
    error NoAuction();
    error NoAuctionLot();
    error NoDividends();
    error NoFeesCollected();
    error NotTheAuctionWinner();
    error PRBMath_MulDiv_Overflow(uint256 x, uint256 y, uint256 denominator);
    error PermitDeadlineExpired();
    error TransferToStakingVaultNotPermitted();
    error TransferToZeroAddress();

    event Approval(address indexed owner, address indexed spender, uint256 amount);
    event AuctionStarted(address indexed token, uint256 feesToBeAuctioned);
    event AuctionedTokensSentToWinner(
        address indexed winner,
        address indexed beneficiary,
        address indexed token,
        uint256 reward
    );
    event BidReceived(address indexed bidder, address indexed token, uint96 previousBid, uint96 newBid);
    event DividendsClaimed(address indexed staker, uint96 amount);
    event DividendsPaid(uint96 amountETH, uint80 amountStakedSIR);
    event RewardsClaimed(address indexed contributor, uint256 indexed vaultId, uint80 rewards);
    event Staked(address indexed staker, uint80 amount);
    event Transfer(address indexed from, address indexed to, uint256 amount);
    event Unstaked(address indexed staker, uint80 amount);

    receive() external payable;

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function ISSUANCE_RATE() external pure returns (uint72);
    function LP_ISSUANCE_FIRST_3_YEARS() external pure returns (uint72);
    function STAKING_VAULT() external view returns (address);
    function SYSTEM_CONTROL() external view returns (address);
    function allowMinting(bool mintingOfSIRHalted_) external;
    function allowance(address, address) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function auctions(address token) external view returns (SirStructs.Auction memory);
    function balanceOf(address account) external view returns (uint256);
    function bid(address token, uint96 amount) external;
    function claim() external returns (uint96 dividends_);
    function collectFeesAndStartAuction(address token) external returns (uint256 totalFees);
    function contributorMint() external returns (uint80 rewards);
    function contributorMintAndStake() external returns (uint80 rewards);
    function contributorUnclaimedSIR(address contributor) external view returns (uint80);
    function decimals() external view returns (uint8);
    function getAuctionLot(address token, address beneficiary) external;
    function initialize(address vault_) external;
    function lperMint(uint256 vaultId) external returns (uint80 rewards);
    function lperMintAndStake(uint256 vaultId) external returns (uint80 rewards);
    function maxTotalSupply() external view returns (uint256);
    function name() external view returns (string memory);
    function nonces(address) external view returns (uint256);
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
    function stake(uint80 amount) external;
    function stakeOf(address staker) external view returns (uint80 unlockedStake, uint80 lockedStake);
    function supply() external view returns (uint256);
    function symbol() external view returns (string memory);
    function totalSupply() external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function unclaimedDividends(address staker) external view returns (uint96);
    function unstake(uint80 amount) external;
    function unstakeAndClaim(uint80 amount) external returns (uint96 dividends_);
    function vault() external view returns (address);
}
"
    },
    "lib/Core/src/interfaces/IVault.sol": {
      "content": "// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import {SirStructs} from "../libraries/SirStructs.sol";

interface IVault {
    error AmountTooLow();
    error DeadlineExceeded();
    error ExcessiveDeposit();
    error InsufficientCollateralReceivedFromUniswap();
    error InsufficientDeposit();
    error LengthMismatch();
    error LeverageTierOutOfRange();
    error Locked();
    error NotAWETHVault();
    error NotAuthorized();
    error StringsInsufficientHexLength(uint256 value, uint256 length);
    error TEAMaxSupplyExceeded();
    error TransferToZeroAddress();
    error UnsafeRecipient();
    error VaultAlreadyInitialized();
    error VaultDoesNotExist();

    event ApprovalForAll(address indexed account, address indexed operator, bool approved);
    event ReservesChanged(uint48 indexed vaultId, bool isAPE, bool isMint, uint144 reserveLPers, uint144 reserveApes);
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] vaultIds,
        uint256[] amounts
    );
    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 amount
    );
    event URI(string value, uint256 indexed id);
    event VaultInitialized(
        address indexed debtToken,
        address indexed collateralToken,
        int8 indexed leverageTier,
        uint256 vaultId,
        address ape
    );
    event VaultNewTax(uint48 indexed vault, uint8 tax, uint16 cumulativeTax);

    function APE_IMPLEMENTATION() external view returns (address);
    function ORACLE() external view returns (address);
    function SIR() external view returns (address);
    function SYSTEM_CONTROL() external view returns (address);
    function TIMESTAMP_ISSUANCE_START() external view returns (uint40);
    function balanceOf(address account, uint256 vaultId) external view returns (uint256);
    function balanceOfBatch(
        address[] memory owners,
        uint256[] memory vaultIds
    ) external view returns (uint256[] memory balances_);
    function burn(
        bool isAPE,
        SirStructs.VaultParameters memory vaultParams,
        uint256 amount,
        uint40 deadline
    ) external returns (uint144);
    function claimSIR(uint256 vaultId, address lper) external returns (uint80);
    function cumulativeSIRPerTEA(uint256 vaultId) external view returns (uint176 cumulativeSIRPerTEAx96);
    function getReserves(
        SirStructs.VaultParameters memory vaultParams
    ) external view returns (SirStructs.Reserves memory);
    function initialize(SirStructs.VaultParameters memory vaultParams) external;
    function isApprovedForAll(address, address) external view returns (bool);
    function mint(
        bool isAPE,
        SirStructs.VaultParameters memory vaultParams,
        uint256 amountToDeposit,
        uint144 collateralToDepositMin,
        uint40 deadline
    ) external payable returns (uint256 amount);
    function numberOfVaults() external view returns (uint48);
    function paramsById(uint48 vaultId) external view returns (SirStructs.VaultParameters memory);
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory vaultIds,
        uint256[] memory amounts,
        bytes memory data
    ) external;
    function safeTransferFrom(address from, address to, uint256 vaultId, uint256 amount, bytes memory data) external;
    function setApprovalForAll(address operator, bool approved) external;
    function supportsInterface(bytes4 interfaceId) external pure returns (bool);
    function systemParams() external view returns (SirStructs.SystemParameters memory systemParams_);
    function totalReserves(address collateral) external view returns (uint256);
    function totalSupply(uint256 vaultId) external view returns (uint256);
    function unclaimedRewards(uint256 vaultId, address lper) external view returns (uint80);
    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes memory data) external;
    function updateSystemState(uint16 baseFee, uint16 lpFee, bool mintingStopped) external;
    function updateVaults(
        uint48[] memory oldVaults,
        uint48[] memory newVaults,
        uint8[] memory newTaxes,
        uint16 cumulativeTax
    ) external;
    function uri(uint256 vaultId) external view returns (string memory);
    function vaultStates(
        SirStructs.VaultParameters memory vaultParams
    ) external view returns (SirStructs.VaultState memory);
    function vaultTax(uint48 vaultId) external view returns (uint8);
    function withdrawFees(address token) external returns (uint256 totalFeesToStakers);
    function withdrawToSaveSystem(address[] memory tokens, address to) external returns (uint256[] memory amounts);
}
"
    },
    "lib/Core/src/interfaces/IWETH9.sol": {
      "content": "// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/// @title Interface for WETH9
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;
}
"
    },
    "src/interfaces/IAssistant.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {SirStructs} from "core/libraries/SirStructs.sol";

/** @notice Helper functions for SIR protocol
 */
interface IAssistant {
    error VaultCanBeCreated();

    enum VaultStatus {
        InvalidVault,
        NoUniswapPool,
        VaultCanBeCreated,
        VaultAlreadyExists
    }

    function getReserves(uint48[] calldata vaultIds) external view returns (SirStructs.Reserves[] memory reserves);

    function priceOfTEA(
        SirStructs.VaultParameters calldata vaultParams
    ) external view returns (uint256 num, uint256 den);

    function priceOfAPE(
        SirStructs.VaultParameters calldata vaultParams
    ) external view returns (uint256 num, uint256 den);

    function getVaultStatus(SirStructs.VaultParameters calldata vaultParams) external view returns (VaultStatus);

    function getAddressAPE(uint48 vaultId) external view returns (address);

    function quoteMint(
        bool isAPE,
        SirStructs.VaultParameters calldata vaultParams,
        uint144 amountCollateral
    ) external view returns (uint256 amountTokens);

    function quoteMintWithDebtToken(
        bool isAPE,
        SirStructs.VaultParameters calldata vaultParams,
        uint256 amountDebtToken
    ) external view returns (uint256 amountTokens, uint256 amountCollateral, uint256 amountCollateralIdeal);

    function quoteCollateralToDebtToken(
        address debtToken,
        address collateralToken,
        uint256 amountCollateral
    ) external view returns (uint256 amountDebtToken);

    function quoteBurn(
        bool isAPE,
        SirStructs.VaultParameters calldata vaultParams,
        uint256 amountTokens
    ) external view returns (uint144 amountCollateral);
}
"
    },
    "lib/Core/src/libraries/SirStructs.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library SirStructs {
    struct VaultIssuanceParams {
        uint8 tax; // (tax / type(uint8).max * 10%) of its fee revenue is directed to the Treasury.
        uint40 timestampLastUpdate; // timestamp of the last time cumulativeSIRPerTEAx96 was updated. 0 => use systemParams.timestampIssuanceStart instead
        uint176 cumulativeSIRPerTEAx96; // Q104.96, cumulative SIR minted by the vaultId per unit of TEA.
    }

    struct VaultParameters {
        address debtToken;
        address collateralToken;
        int8 leverageTier;
    }

    struct FeeStructure {
        uint16 fee; // Fee in basis points.
        uint16 feeNew; // New fee to replace fee if current time exceeds FEE_CHANGE_DELAY since timestampUpdate
        uint40 timestampUpdate; // Timestamp fee change was made. If 0, feeNew is not used.
    }

    struct SystemParameters {
        FeeStructure baseFee;
        FeeStructure lpFee;
        bool mintingStopped; // If true, no minting of TEA/APE
        /** Aggregated taxes for all vaults. Choice of uint16 type.
            For vault i, (tax_i / type(uint8).max)*10% is charged, where tax_i is of type uint8.
            They must satisfy the condition
                Σ_i (tax_i / type(uint8).max)^2 ≤ 0.1^2
            Under this constraint, cumulativeTax = Σ_i tax_i is maximized when all taxes are equal (tax_i = tax for all i) and
                tax = type(uint8).max / sqrt(Nvaults)
            Since the lowest non-zero value is tax=1, the maximum number of vaults with non-zero tax is
                Nvaults = type(uint8).max^2 < type(uint16).max
         */
        uint16 cumulativeTax;
    }

    /** Collateral owned by the apes and LPers in a vault
     */
    struct Reserves {
        uint144 reserveApes;
        uint144 reserveLPers;
        int64 tickPriceX42;
    }

    /** Data needed for recoverying the amount of collateral owned by the apes and LPers in a vault
     */
    struct VaultState {
        uint144 reserve; // reserve =  reserveApes + reserveLPers
        /** Price at the border of the power and saturation zone.
            Q21.42 - Fixed point number with 42 bits of precision after the comma.
            type(int64).max and type(int64).min are used to represent +∞ and -∞ respectively.
         */
        int64 tickPriceSatX42; // Saturation price in Q21.42 fixed point
        uint48 vaultId; // Allows the creation of approximately 281 trillion vaults
    }

    /** The sum of all amounts in Fees are equal to the amounts deposited by the user (in the case of a mint)
        or taken out by the user (in the case of a burn).
        collateralInOrWithdrawn: Amount of collateral deposited by the user (in the case of a mint) or taken out by the user (in the case of a burn).
        collateralFeeToStakers: Amount of collateral paid to the stakers.
        collateralFeeToLPers: Amount of collateral paid to the gentlemen.
        collateralFeeToProtocol: Amount of collateral paid to the protocol.
     */
    struct Fees {
        uint144 collateralInOrWithdrawn;
        uint144 collateralFeeToStakers;
        uint144 collateralFeeToLPers; // Sometimes all LPers and sometimes only protocol owned liquidity
    }

    struct StakingParams {
        uint80 stake; // Amount of staked SIR
        uint176 cumulativeETHPerSIRx80; // Cumulative ETH per SIR * 2^80
    }

    struct StakerParams {
        uint80 stake; // Total amount of staked SIR by the staker
        uint176 cumulativeETHPerSIRx80; // Cumulative ETH per SIR * 2^80 last time the user updated his balance of ETH dividends
        uint80 lockedStake; // Amount of stake that was locked at time 'tsLastUpdate'
        uint40 tsLastUpdate; // Timestamp of the last time the user staked or unstaked
    }

    struct Auction {
        address bidder; // Address of the bidder
        uint96 bid; // Amount of the bid
        uint40 startTime; // Auction start time
    }

    struct OracleState {
        int64 tickPriceX42; // Last stored price. Q21.42
        uint40 timeStampPrice; // Timestamp of the last stored price
        uint8 indexFeeTier; // Uniswap v3 fee tier currently being used as oracle
        uint8 indexFeeTierProbeNext; // Uniswap v3 fee tier to probe next
        uint40 timeStampFeeTier; // Timestamp of the last probed fee tier
        bool initialized; // Whether the oracle has been initialized
        UniswapFeeTier uniswapFeeTier; // Uniswap v3 fee tier currently being used as oracle
    }

    /**
     * Parameters of a Uniswap v3 tier.
     */
    struct UniswapFeeTier {
        uint24 fee;
        int24 tickSpacing;
    }
}
"
    },
    "lib/Core/src/libraries/AddressClone.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

library AddressClone {
    /// @dev Hash of the `_CREATE3_PROXY_BYTECODE`.
    /// Equivalent to `keccak256(abi.encodePacked(hex"67363d3d37363d34f03d5260086018f3"))`.
    bytes32 private constant _CREATE3_PROXY_BYTECODE_HASH =
        0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f;

    function getAddress(address deployer, uint256 vaultId) internal pure returns (address clone) {
        /// @solidity memory-safe-assembly
        // solhint-disable-next-line no-inline-assembly
        assembly {
            // Cache the free memory pointer.
            let m := mload(0x40)
            // Store `address(this)`.
            mstore(0x00, deployer)
            // Store the prefix.
            mstore8(0x0b, 0xff)
            // Store the salt.
            mstore(0x20, vaultId)
            // Store the bytecode hash.
            mstore(0x40, _CREATE3_PROXY_BYTECODE_HASH)

            // Store the proxy's address.
            mstore(0x14, keccak256(0x0b, 0x55))
            // Restore the free memory pointer.
            mstore(0x40, m)
            // 0xd6 = 0xc0 (short RLP prefix) + 0x16 (length of: 0x94 ++ proxy ++ 0x01).
            // 0x94 = 0x80 + 0x14 (0x14 = the length of an address, 20 bytes, in hex).
            mstore(0x00, 0xd694)
            // Nonce of the proxy contract (1).
            mstore8(0x34, 0x01)

            clone := and(keccak256(0x1e, 0x17), 0xffffffffffffffffffffffffffffffffffffffff)
        }
    }
}
"
    },
    "lib/Core/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}
"
    }
  },
  "settings": {
    "remappings": [
      "core/=lib/Core/src/",
      "v3-periphery/=lib/Core/lib/v3-periphery/contracts/",
      "v3-core/=lib/Core/lib/v3-core/contracts/",
      "v2-core/=lib/Core/lib/v2-core/contracts/",
      "solmate/=lib/solmate/src/",
      "openzeppelin/=lib/Core/lib/openzeppelin-contracts/contracts/",
      "@openzeppelin/=lib/Core/lib/openzeppelin-contracts/",
      "oz-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
      "@uniswap/lib/=lib/Core/lib/uniswap-lib/",
      "@uniswap/v3-core/=lib/Core/lib/v3-core/",
      "Core/=lib/Core/",
      "ERC1155-in-pure-yul/=lib/Core/lib/ERC1155-in-pure-yul/contracts/",
      "abdk-libraries-solidity/=lib/Core/lib/abdk-libraries-solidity/",
      "abdk/=lib/Core/lib/abdk-libraries-solidity/",
      "base64-sol/=lib/Core/lib/base64/",
      "base64/=lib/Core/lib/base64/",
      "canonical-weth/=lib/Core/lib/canonical-weth/contracts/",
      "clones-with-immutable-args/=lib/Core/lib/clones-with-immutable-args/src/",
      "ds-test/=lib/solmate/lib/ds-test/src/",
      "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
      "forge-std/=lib/forge-std/src/",
      "halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/",
      "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
      "openzeppelin-contracts/=lib/Core/lib/openzeppelin-contracts/",
      "prb-math/=lib/Core/lib/prb-math/src/",
      "prb/=lib/Core/lib/prb-math/src/",
      "uniswap-lib/=lib/Core/lib/uniswap-lib/contracts/",
      "uniswap-openzeppelin/=lib/Core/lib/uniswap-openzeppelin/",
      "view-quoter-v3/=lib/view-quoter-v3/"
    ],
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "metadata": {
      "useLiteralContent": false,
      "bytecodeHash": "ipfs",
      "appendCBOR": true
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "evmVersion": "cancun",
    "viaIR": false
  }
}}