fluid-contracts-public/deployments/mainnet/dump/0xEb6643733c5E7CaB6B27D98C8CFDc647f8112a96.json

{
  "address": "0xEb6643733c5E7CaB6B27D98C8CFDc647f8112a96",
  "abi": [
    {
      "inputs": [
        {
          "internalType": "contract IFluidLiquidity",
          "name": "liquidity_",
          "type": "address"
        },
        {
          "internalType": "contract ILidoWithdrawalQueue",
          "name": "lidoWithdrawalQueue_",
          "type": "address"
        },
        {
          "internalType": "contract IERC20",
          "name": "stETH_",
          "type": "address"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "constructor"
    },
    {
      "inputs": [
        {
          "internalType": "uint256",
          "name": "errorId_",
          "type": "uint256"
        }
      ],
      "name": "FluidLiquidityCalcsError",
      "type": "error"
    },
    {
      "inputs": [
        {
          "internalType": "uint256",
          "name": "errorId_",
          "type": "uint256"
        }
      ],
      "name": "StETHQueueError",
      "type": "error"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": false,
          "internalType": "address",
          "name": "previousAdmin",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "address",
          "name": "newAdmin",
          "type": "address"
        }
      ],
      "name": "AdminChanged",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "beacon",
          "type": "address"
        }
      ],
      "name": "BeaconUpgraded",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": false,
          "internalType": "uint8",
          "name": "version",
          "type": "uint8"
        }
      ],
      "name": "Initialized",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "claimTo",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "requestIdFrom",
          "type": "uint256"
        },
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "claimedAmount",
          "type": "uint256"
        },
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "repayAmount",
          "type": "uint256"
        }
      ],
      "name": "LogClaim",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [],
      "name": "LogPaused",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "claimTo",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "requestIdFrom",
          "type": "uint256"
        },
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "borrowETHAmount",
          "type": "uint256"
        },
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "queueStETHAmount",
          "type": "uint256"
        },
        {
          "indexed": false,
          "internalType": "address",
          "name": "borrowTo",
          "type": "address"
        }
      ],
      "name": "LogQueue",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": false,
          "internalType": "bool",
          "name": "active",
          "type": "bool"
        }
      ],
      "name": "LogSetAllowListActive",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "user",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "bool",
          "name": "allowed",
          "type": "bool"
        }
      ],
      "name": "LogSetAllowed",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "auth",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "bool",
          "name": "allowed",
          "type": "bool"
        }
      ],
      "name": "LogSetAuth",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "guardian",
          "type": "address"
        },
        {
          "indexed": false,
          "internalType": "bool",
          "name": "allowed",
          "type": "bool"
        }
      ],
      "name": "LogSetGuardian",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "maxLTV",
          "type": "uint256"
        }
      ],
      "name": "LogSetMaxLTV",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [],
      "name": "LogUnpaused",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "previousOwner",
          "type": "address"
        },
        {
          "indexed": true,
          "internalType": "address",
          "name": "newOwner",
          "type": "address"
        }
      ],
      "name": "OwnershipTransferred",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "internalType": "address",
          "name": "implementation",
          "type": "address"
        }
      ],
      "name": "Upgraded",
      "type": "event"
    },
    {
      "inputs": [],
      "name": "allowListActive",
      "outputs": [
        {
          "internalType": "bool",
          "name": "",
          "type": "bool"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "claimTo_",
          "type": "address"
        },
        {
          "internalType": "uint256",
          "name": "requestIdFrom_",
          "type": "uint256"
        }
      ],
      "name": "claim",
      "outputs": [
        {
          "internalType": "uint256",
          "name": "claimedAmount_",
          "type": "uint256"
        },
        {
          "internalType": "uint256",
          "name": "repayAmount_",
          "type": "uint256"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        },
        {
          "internalType": "uint256",
          "name": "",
          "type": "uint256"
        }
      ],
      "name": "claims",
      "outputs": [
        {
          "internalType": "uint128",
          "name": "borrowAmountRaw",
          "type": "uint128"
        },
        {
          "internalType": "uint48",
          "name": "checkpoint",
          "type": "uint48"
        },
        {
          "internalType": "uint40",
          "name": "requestIdTo",
          "type": "uint40"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "constantsView",
      "outputs": [
        {
          "internalType": "contract IFluidLiquidity",
          "name": "",
          "type": "address"
        },
        {
          "internalType": "contract ILidoWithdrawalQueue",
          "name": "",
          "type": "address"
        },
        {
          "internalType": "contract IERC20",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "owner_",
          "type": "address"
        }
      ],
      "name": "initialize",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "auth_",
          "type": "address"
        }
      ],
      "name": "isAuth",
      "outputs": [
        {
          "internalType": "bool",
          "name": "",
          "type": "bool"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "guardian_",
          "type": "address"
        }
      ],
      "name": "isGuardian",
      "outputs": [
        {
          "internalType": "bool",
          "name": "",
          "type": "bool"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "isPaused",
      "outputs": [
        {
          "internalType": "bool",
          "name": "",
          "type": "bool"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "user_",
          "type": "address"
        }
      ],
      "name": "isUserAllowed",
      "outputs": [
        {
          "internalType": "bool",
          "name": "",
          "type": "bool"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        },
        {
          "internalType": "uint256",
          "name": "",
          "type": "uint256"
        },
        {
          "internalType": "bytes",
          "name": "",
          "type": "bytes"
        }
      ],
      "name": "liquidityCallback",
      "outputs": [],
      "stateMutability": "pure",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "maxLTV",
      "outputs": [
        {
          "internalType": "uint16",
          "name": "",
          "type": "uint16"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        },
        {
          "internalType": "uint256",
          "name": "",
          "type": "uint256"
        },
        {
          "internalType": "bytes",
          "name": "",
          "type": "bytes"
        }
      ],
      "name": "onERC721Received",
      "outputs": [
        {
          "internalType": "bytes4",
          "name": "",
          "type": "bytes4"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "owner",
      "outputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "pause",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "proxiableUUID",
      "outputs": [
        {
          "internalType": "bytes32",
          "name": "",
          "type": "bytes32"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "uint256",
          "name": "ethBorrowAmount_",
          "type": "uint256"
        },
        {
          "internalType": "uint256",
          "name": "stETHAmount_",
          "type": "uint256"
        },
        {
          "internalType": "address",
          "name": "borrowTo_",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "claimTo_",
          "type": "address"
        }
      ],
      "name": "queue",
      "outputs": [
        {
          "internalType": "uint256",
          "name": "requestIdFrom_",
          "type": "uint256"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "renounceOwnership",
      "outputs": [],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "bool",
          "name": "status_",
          "type": "bool"
        }
      ],
      "name": "setAllowListActive",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "auth_",
          "type": "address"
        },
        {
          "internalType": "bool",
          "name": "allowed_",
          "type": "bool"
        }
      ],
      "name": "setAuth",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "guardian_",
          "type": "address"
        },
        {
          "internalType": "bool",
          "name": "allowed_",
          "type": "bool"
        }
      ],
      "name": "setGuardian",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "uint16",
          "name": "maxLTV_",
          "type": "uint16"
        }
      ],
      "name": "setMaxLTV",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "user_",
          "type": "address"
        },
        {
          "internalType": "bool",
          "name": "allowed_",
          "type": "bool"
        }
      ],
      "name": "setUserAllowed",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "newOwner",
          "type": "address"
        }
      ],
      "name": "transferOwnership",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "unpause",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "newImplementation",
          "type": "address"
        }
      ],
      "name": "upgradeTo",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "newImplementation",
          "type": "address"
        },
        {
          "internalType": "bytes",
          "name": "data",
          "type": "bytes"
        }
      ],
      "name": "upgradeToAndCall",
      "outputs": [],
      "stateMutability": "payable",
      "type": "function"
    },
    {
      "stateMutability": "payable",
      "type": "receive"
    }
  ],
  "transactionHash": "0x2774e501471fd6e6134a958a276591a1837c69f76eaeec980ef2bab252bb7479",
  "receipt": {
    "to": "0x4e59b44847b379578588920cA78FbF26c0B4956C",
    "from": "0x0Ed35B1609Ec45c7079E80d11149a52717e4859A",
    "contractAddress": null,
    "transactionIndex": 73,
    "gasUsed": "3518187",
    "logsBloom": "0x00000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000",
    "blockHash": "0x7b02f5fa621e392062f1b2bf4ae7d2f535d2d9828be5d17b65a3a8d626037b76",
    "transactionHash": "0x2774e501471fd6e6134a958a276591a1837c69f76eaeec980ef2bab252bb7479",
    "logs": [
      {
        "transactionIndex": 73,
        "blockNumber": 19352991,
        "transactionHash": "0x2774e501471fd6e6134a958a276591a1837c69f76eaeec980ef2bab252bb7479",
        "address": "0xEb6643733c5E7CaB6B27D98C8CFDc647f8112a96",
        "topics": [
          "0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498"
        ],
        "data": "0x00000000000000000000000000000000000000000000000000000000000000ff",
        "logIndex": 255,
        "blockHash": "0x7b02f5fa621e392062f1b2bf4ae7d2f535d2d9828be5d17b65a3a8d626037b76"
      }
    ],
    "blockNumber": 19352991,
    "cumulativeGasUsed": "13671889",
    "status": 1,
    "byzantium": true
  },
  "args": [
    "0x52Aa899454998Be5b000Ad077a46Bbe360F4e497",
    "0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1",
    "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84"
  ],
  "numDeployments": 1,
  "solcInputHash": "592bba28bc51fc04fcbb5005ed8ba2d3",
  "metadata": "{\"compiler\":{\"version\":\"0.8.21+commit.d9974bed\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract IFluidLiquidity\",\"name\":\"liquidity_\",\"type\":\"address\"},{\"internalType\":\"contract ILidoWithdrawalQueue\",\"name\":\"lidoWithdrawalQueue_\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"stETH_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"errorId_\",\"type\":\"uint256\"}],\"name\":\"FluidLiquidityCalcsError\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"errorId_\",\"type\":\"uint256\"}],\"name\":\"StETHQueueError\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"claimTo\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"requestIdFrom\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"claimedAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"repayAmount\",\"type\":\"uint256\"}],\"name\":\"LogClaim\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"LogPaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"claimTo\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"requestIdFrom\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"borrowETHAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"queueStETHAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"borrowTo\",\"type\":\"address\"}],\"name\":\"LogQueue\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"name\":\"LogSetAllowListActive\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"allowed\",\"type\":\"bool\"}],\"name\":\"LogSetAllowed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"auth\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"allowed\",\"type\":\"bool\"}],\"name\":\"LogSetAuth\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"guardian\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"allowed\",\"type\":\"bool\"}],\"name\":\"LogSetGuardian\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"maxLTV\",\"type\":\"uint256\"}],\"name\":\"LogSetMaxLTV\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"LogUnpaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"allowListActive\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"claimTo_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"requestIdFrom_\",\"type\":\"uint256\"}],\"name\":\"claim\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"claimedAmount_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"repayAmount_\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"claims\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"borrowAmountRaw\",\"type\":\"uint128\"},{\"internalType\":\"uint48\",\"name\":\"checkpoint\",\"type\":\"uint48\"},{\"internalType\":\"uint40\",\"name\":\"requestIdTo\",\"type\":\"uint40\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"constantsView\",\"outputs\":[{\"internalType\":\"contract IFluidLiquidity\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"contract ILidoWithdrawalQueue\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner_\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"auth_\",\"type\":\"address\"}],\"name\":\"isAuth\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"guardian_\",\"type\":\"address\"}],\"name\":\"isGuardian\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user_\",\"type\":\"address\"}],\"name\":\"isUserAllowed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"liquidityCallback\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxLTV\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC721Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"ethBorrowAmount_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stETHAmount_\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"borrowTo_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"claimTo_\",\"type\":\"address\"}],\"name\":\"queue\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"requestIdFrom_\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"status_\",\"type\":\"bool\"}],\"name\":\"setAllowListActive\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"auth_\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"allowed_\",\"type\":\"bool\"}],\"name\":\"setAuth\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"guardian_\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"allowed_\",\"type\":\"bool\"}],\"name\":\"setGuardian\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"maxLTV_\",\"type\":\"uint16\"}],\"name\":\"setMaxLTV\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user_\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"allowed_\",\"type\":\"bool\"}],\"name\":\"setUserAllowed\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"details\":\"claims are referenced to via the claimTo address and the Lido requestIdFrom, which must be tracked from the moment of queuing, where it is emitted in the `LogQueue` event, to pass in that information later for `claim()`.For view methods / accessing data, use the \\\"StETHResolver\\\" periphery contract.\",\"events\":{\"AdminChanged(address,address)\":{\"details\":\"Emitted when the admin account has changed.\"},\"BeaconUpgraded(address)\":{\"details\":\"Emitted when the beacon is upgraded.\"},\"Initialized(uint8)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"},\"Upgraded(address)\":{\"details\":\"Emitted when the implementation is upgraded.\"}},\"kind\":\"dev\",\"methods\":{\"claim(address,uint256)\":{\"params\":{\"claimTo_\":\"claimTo receiver to process the claim for\",\"requestIdFrom_\":\"Lido requestId from (start), as emitted at time of queuing (`queue()`) via `LogQueue`\"},\"returns\":{\"claimedAmount_\":\"total amount of claimed stETH\",\"repayAmount_\":\"total repaid ETH amount at Liquidity\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"proxiableUUID()\":{\"details\":\"Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\"},\"queue(uint256,uint256,address,address)\":{\"details\":\"if `allowListActive` == true, then only allowed users can call this method.\",\"params\":{\"borrowTo_\":\"receiver of the `ethBorrowAmount_`\",\"claimTo_\":\"receiver of the left over stETH funds at time of `claim()`\",\"ethBorrowAmount_\":\"amount of ETH to borrow and send to `borrowTo_`\",\"stETHAmount_\":\"amount of stETH to queue at Lido Withdrawal Queue and use as collateral\"},\"returns\":{\"requestIdFrom_\":\"first request id at Lido withdrawal queue. Used to identify claims\"}},\"setAuth(address,bool)\":{\"params\":{\"allowed_\":\"bool flag for whether address is allowed as auth or not\",\"auth_\":\"address to set auth value for\"}},\"setGuardian(address,bool)\":{\"params\":{\"allowed_\":\"bool flag for whether address is allowed as guardian or not\",\"guardian_\":\"address to set guardian value for\"}},\"setUserAllowed(address,bool)\":{\"params\":{\"allowed_\":\"bool flag for whether address is allowed as user or not\",\"user_\":\"address to set allowed value for\"}},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"upgradeTo(address)\":{\"details\":\"Upgrade the implementation of the proxy to `newImplementation`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"},\"upgradeToAndCall(address,bytes)\":{\"details\":\"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"}},\"title\":\"StETHQueue\",\"version\":1},\"userdoc\":{\"errors\":{\"StETHQueueError(uint256)\":[{\"notice\":\"general Custom error used for all contract specific errors with the `errorId_` param as error code. Look up the specific error code in the source code to find a better explanation of what went wrong (errors.sol).\"}]},\"events\":{\"LogClaim(address,uint256,uint256,uint256)\":{\"notice\":\"emitted when a claim() process is executed\"},\"LogPaused()\":{\"notice\":\"emitted when protocol is paused by guardian\"},\"LogQueue(address,uint256,uint256,uint256,address)\":{\"notice\":\"emitted when a queue() process is executed\"},\"LogSetAllowListActive(bool)\":{\"notice\":\"emitted when `allowListActive` status is updated\"},\"LogSetAllowed(address,bool)\":{\"notice\":\"emitted when an allowed user is modified by auths\"},\"LogSetAuth(address,bool)\":{\"notice\":\"emitted when an auth is modified by owner\"},\"LogSetGuardian(address,bool)\":{\"notice\":\"emitted when a guardian is modified by owner\"},\"LogSetMaxLTV(uint256)\":{\"notice\":\"emitted whenever `maxLTV` is updated\"},\"LogUnpaused()\":{\"notice\":\"emitted when protocol is unpaused by owner\"}},\"kind\":\"user\",\"methods\":{\"allowListActive()\":{\"notice\":\"flag whether allow list behavior is enabled or not.\"},\"claim(address,uint256)\":{\"notice\":\"claims all open requests at LidoWithdrawalQueue for `claimTo_`, repays the borrowed ETH amount at Liquidity and sends the rest of funds to `claimTo_`.\"},\"claims(address,uint256)\":{\"notice\":\"maps claimTo address and requestIdFrom to the Claim struct containing necessary information for executing the claim process.\"},\"constantsView()\":{\"notice\":\"returns the constant values for LIQUIDITY, LIDO_WITHDRAWAL_QUEUE, STETH\"},\"initialize(address)\":{\"notice\":\"initializes the contract with `owner_` as owner\"},\"isAuth(address)\":{\"notice\":\"reads if a certain `auth_` address is an allowed auth or not\"},\"isGuardian(address)\":{\"notice\":\"reads if a certain `guardian_` address is an allowed guardian or not\"},\"isPaused()\":{\"notice\":\"reads if the protocol is paused or not\"},\"isUserAllowed(address)\":{\"notice\":\"reads if a certain `user_` address is an allowed user or not\"},\"liquidityCallback(address,uint256,bytes)\":{\"notice\":\"liquidityCallback as used by Liquidity -> But unsupported in this contract as it only ever uses native token as borrowed asset, which is repaid directly via `msg.value`. Always reverts.\"},\"maxLTV()\":{\"notice\":\"maximum allowed percentage of LTV (loan-to-value). E.g. 90% -> max. 90 ETH can be borrowed with 100 stETH as collateral in withdrawal queue. ETH will be received at time of claim to cover the paid borrowed ETH amount. In 1e2 (1% = 100, 90% = 9_000, 100% = 10_000). Configurable by auths.\"},\"onERC721Received(address,address,uint256,bytes)\":{\"notice\":\"accept ERC721 token transfers ONLY from LIDO_WITHDRAWAL_QUEUE\"},\"pause()\":{\"notice\":\"Pauses the protocol (blocks queue() and claim()). Only callable by guardians.\"},\"queue(uint256,uint256,address,address)\":{\"notice\":\"queues an amount of stETH at the Lido WithdrawalQueue, using it as collateral to borrow an amount of ETH from Liquidity that is paid back when Lido Withdrawal is claimable, triggered with `claim()`.\"},\"renounceOwnership()\":{\"notice\":\"override renounce ownership as it could leave the contract in an unwanted state if called by mistake.\"},\"setAllowListActive(bool)\":{\"notice\":\"Sets `allowListActive` flag to `status_`. Only callable by owner.\"},\"setAuth(address,bool)\":{\"notice\":\"Sets an address as allowed auth or not. Only callable by owner.\"},\"setGuardian(address,bool)\":{\"notice\":\"Sets an address as allowed guardian or not. Only callable by owner.\"},\"setMaxLTV(uint16)\":{\"notice\":\"Sets `maxLTV` to `maxLTV_` (in 1e2: 1% = 100, 100% = 10000). Must be > 0 and < 100%.\"},\"setUserAllowed(address,bool)\":{\"notice\":\"Sets an address as allowed user or not. Only callable by auths.\"},\"unpause()\":{\"notice\":\"Unpauses the protocol (enables queue() and claim()). Only callable by owner.\"}},\"notice\":\"queues an amount of stETH at the Lido WithdrawalQueue, using it as collateral to borrow an amount of ETH that is paid back when Lido Withdrawal is claimable. Useful e.g. to deleverage a stETH / ETH borrow position. User target group are whales that want to deleverage stETH / ETH without having to swap (no slippage).\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/protocols/steth/main.sol\":\"FluidStETHQueue\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n    address private _owner;\\n\\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n    /**\\n     * @dev Initializes the contract setting the deployer as the initial owner.\\n     */\\n    function __Ownable_init() internal onlyInitializing {\\n        __Ownable_init_unchained();\\n    }\\n\\n    function __Ownable_init_unchained() internal onlyInitializing {\\n        _transferOwnership(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Throws if called by any account other than the owner.\\n     */\\n    modifier onlyOwner() {\\n        _checkOwner();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns the address of the current owner.\\n     */\\n    function owner() public view virtual returns (address) {\\n        return _owner;\\n    }\\n\\n    /**\\n     * @dev Throws if the sender is not the owner.\\n     */\\n    function _checkOwner() internal view virtual {\\n        require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n    }\\n\\n    /**\\n     * @dev Leaves the contract without owner. It will not be possible to call\\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\\n     *\\n     * NOTE: Renouncing ownership will leave the contract without an owner,\\n     * thereby removing any functionality that is only available to the owner.\\n     */\\n    function renounceOwnership() public virtual onlyOwner {\\n        _transferOwnership(address(0));\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Can only be called by the current owner.\\n     */\\n    function transferOwnership(address newOwner) public virtual onlyOwner {\\n        require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n        _transferOwnership(newOwner);\\n    }\\n\\n    /**\\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n     * Internal function without access restriction.\\n     */\\n    function _transferOwnership(address newOwner) internal virtual {\\n        address oldOwner = _owner;\\n        _owner = newOwner;\\n        emit OwnershipTransferred(oldOwner, newOwner);\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x247c62047745915c0af6b955470a72d1696ebad4352d7d3011aef1a2463cd888\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n *     function initialize() initializer public {\\n *         __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n *     }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n *     function initializeV2() reinitializer(2) public {\\n *         __ERC20Permit_init(\\\"MyToken\\\");\\n *     }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n *     _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n    /**\\n     * @dev Indicates that the contract has been initialized.\\n     * @custom:oz-retyped-from bool\\n     */\\n    uint8 private _initialized;\\n\\n    /**\\n     * @dev Indicates that the contract is in the process of being initialized.\\n     */\\n    bool private _initializing;\\n\\n    /**\\n     * @dev Triggered when the contract has been initialized or reinitialized.\\n     */\\n    event Initialized(uint8 version);\\n\\n    /**\\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n     * `onlyInitializing` functions can be used to initialize parent contracts.\\n     *\\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n     * constructor.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier initializer() {\\n        bool isTopLevelCall = !_initializing;\\n        require(\\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n            \\\"Initializable: contract is already initialized\\\"\\n        );\\n        _initialized = 1;\\n        if (isTopLevelCall) {\\n            _initializing = true;\\n        }\\n        _;\\n        if (isTopLevelCall) {\\n            _initializing = false;\\n            emit Initialized(1);\\n        }\\n    }\\n\\n    /**\\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n     * used to initialize parent contracts.\\n     *\\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n     * are added through upgrades and that require initialization.\\n     *\\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\\n     *\\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n     * a contract, executing them in the right order is up to the developer or operator.\\n     *\\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier reinitializer(uint8 version) {\\n        require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n        _initialized = version;\\n        _initializing = true;\\n        _;\\n        _initializing = false;\\n        emit Initialized(version);\\n    }\\n\\n    /**\\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n     */\\n    modifier onlyInitializing() {\\n        require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n        _;\\n    }\\n\\n    /**\\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n     * through proxies.\\n     *\\n     * Emits an {Initialized} event the first time it is successfully executed.\\n     */\\n    function _disableInitializers() internal virtual {\\n        require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n        if (_initialized < type(uint8).max) {\\n            _initialized = type(uint8).max;\\n            emit Initialized(type(uint8).max);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n     */\\n    function _getInitializedVersion() internal view returns (uint8) {\\n        return _initialized;\\n    }\\n\\n    /**\\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n     */\\n    function _isInitializing() internal view returns (bool) {\\n        return _initializing;\\n    }\\n}\\n\",\"keccak256\":\"0x037c334add4b033ad3493038c25be1682d78c00992e1acb0e2795caff3925271\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n    /**\\n     * @dev Returns true if `account` is a contract.\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * It is unsafe to assume that an address for which this function returns\\n     * false is an externally-owned account (EOA) and not a contract.\\n     *\\n     * Among others, `isContract` will return false for the following\\n     * types of addresses:\\n     *\\n     *  - an externally-owned account\\n     *  - a contract in construction\\n     *  - an address where a contract will be created\\n     *  - an address where a contract lived, but was destroyed\\n     * ====\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n     *\\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n     * constructor.\\n     * ====\\n     */\\n    function isContract(address account) internal view returns (bool) {\\n        // This method relies on extcodesize/address.code.length, which returns 0\\n        // for contracts in construction, since the code is only stored at the end\\n        // of the constructor execution.\\n\\n        return account.code.length > 0;\\n    }\\n\\n    /**\\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n     * `recipient`, forwarding all available gas and reverting on errors.\\n     *\\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n     * imposed by `transfer`, making them unable to receive funds via\\n     * `transfer`. {sendValue} removes this limitation.\\n     *\\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n     *\\n     * IMPORTANT: because control is transferred to `recipient`, care must be\\n     * taken to not create reentrancy vulnerabilities. Consider using\\n     * {ReentrancyGuard} or the\\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n     */\\n    function sendValue(address payable recipient, uint256 amount) internal {\\n        require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n        (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n        require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n    }\\n\\n    /**\\n     * @dev Performs a Solidity function call using a low level `call`. A\\n     * plain `call` is an unsafe replacement for a function call: use this\\n     * function instead.\\n     *\\n     * If `target` reverts with a revert reason, it is bubbled up by this\\n     * function (like regular Solidity function calls).\\n     *\\n     * Returns the raw returned data. To convert to the expected return value,\\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n     *\\n     * Requirements:\\n     *\\n     * - `target` must be a contract.\\n     * - calling `target` with `data` must not revert.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n     * `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but also transferring `value` wei to `target`.\\n     *\\n     * Requirements:\\n     *\\n     * - the calling contract must have an ETH balance of at least `value`.\\n     * - the called Solidity function must be `payable`.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n        return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n     *\\n     * _Available since v4.8._\\n     */\\n    function verifyCallResultFromTarget(\\n        address target,\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        if (success) {\\n            if (returndata.length == 0) {\\n                // only check isContract if the call was successful and the return data is empty\\n                // otherwise we already know that it was a contract\\n                require(isContract(target), \\\"Address: call to non-contract\\\");\\n            }\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n     * revert reason or using the provided one.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function verifyCallResult(\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n        // Look for revert reason and bubble it up if present\\n        if (returndata.length > 0) {\\n            // The easiest way to bubble the revert reason is using memory via assembly\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                let returndata_size := mload(returndata)\\n                revert(add(32, returndata), returndata_size)\\n            }\\n        } else {\\n            revert(errorMessage);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x2edcb41c121abc510932e8d83ff8b82cf9cdde35e7c297622f5c29ef0af25183\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n    function __Context_init() internal onlyInitializing {\\n    }\\n\\n    function __Context_init_unchained() internal onlyInitializing {\\n    }\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822Proxiable {\\n    /**\\n     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n     * address.\\n     *\\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n     * function revert if invoked through a proxy.\\n     */\\n    function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x1d4afe6cb24200cc4545eed814ecf5847277dfe5d613a1707aad5fceecebcfff\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeacon.sol\\\";\\nimport \\\"../../interfaces/draft-IERC1822.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/StorageSlot.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967Upgrade {\\n    // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n    /**\\n     * @dev Storage slot with the address of the current implementation.\\n     * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n     * validated in the constructor.\\n     */\\n    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n    /**\\n     * @dev Emitted when the implementation is upgraded.\\n     */\\n    event Upgraded(address indexed implementation);\\n\\n    /**\\n     * @dev Returns the current implementation address.\\n     */\\n    function _getImplementation() internal view returns (address) {\\n        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n    }\\n\\n    /**\\n     * @dev Stores a new address in the EIP1967 implementation slot.\\n     */\\n    function _setImplementation(address newImplementation) private {\\n        require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n    }\\n\\n    /**\\n     * @dev Perform implementation upgrade\\n     *\\n     * Emits an {Upgraded} event.\\n     */\\n    function _upgradeTo(address newImplementation) internal {\\n        _setImplementation(newImplementation);\\n        emit Upgraded(newImplementation);\\n    }\\n\\n    /**\\n     * @dev Perform implementation upgrade with additional setup call.\\n     *\\n     * Emits an {Upgraded} event.\\n     */\\n    function _upgradeToAndCall(\\n        address newImplementation,\\n        bytes memory data,\\n        bool forceCall\\n    ) internal {\\n        _upgradeTo(newImplementation);\\n        if (data.length > 0 || forceCall) {\\n            Address.functionDelegateCall(newImplementation, data);\\n        }\\n    }\\n\\n    /**\\n     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n     *\\n     * Emits an {Upgraded} event.\\n     */\\n    function _upgradeToAndCallUUPS(\\n        address newImplementation,\\n        bytes memory data,\\n        bool forceCall\\n    ) internal {\\n        // Upgrades from old implementations will perform a rollback test. This test requires the new\\n        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing\\n        // this special case will break upgrade paths from old UUPS implementation to new ones.\\n        if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {\\n            _setImplementation(newImplementation);\\n        } else {\\n            try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n                require(slot == _IMPLEMENTATION_SLOT, \\\"ERC1967Upgrade: unsupported proxiableUUID\\\");\\n            } catch {\\n                revert(\\\"ERC1967Upgrade: new implementation is not UUPS\\\");\\n            }\\n            _upgradeToAndCall(newImplementation, data, forceCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Storage slot with the admin of the contract.\\n     * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n     * validated in the constructor.\\n     */\\n    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n    /**\\n     * @dev Emitted when the admin account has changed.\\n     */\\n    event AdminChanged(address previousAdmin, address newAdmin);\\n\\n    /**\\n     * @dev Returns the current admin.\\n     */\\n    function _getAdmin() internal view returns (address) {\\n        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\\n    }\\n\\n    /**\\n     * @dev Stores a new address in the EIP1967 admin slot.\\n     */\\n    function _setAdmin(address newAdmin) private {\\n        require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n    }\\n\\n    /**\\n     * @dev Changes the admin of the proxy.\\n     *\\n     * Emits an {AdminChanged} event.\\n     */\\n    function _changeAdmin(address newAdmin) internal {\\n        emit AdminChanged(_getAdmin(), newAdmin);\\n        _setAdmin(newAdmin);\\n    }\\n\\n    /**\\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n     */\\n    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n    /**\\n     * @dev Emitted when the beacon is upgraded.\\n     */\\n    event BeaconUpgraded(address indexed beacon);\\n\\n    /**\\n     * @dev Returns the current beacon.\\n     */\\n    function _getBeacon() internal view returns (address) {\\n        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\\n    }\\n\\n    /**\\n     * @dev Stores a new beacon in the EIP1967 beacon slot.\\n     */\\n    function _setBeacon(address newBeacon) private {\\n        require(Address.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n        require(\\n            Address.isContract(IBeacon(newBeacon).implementation()),\\n            \\\"ERC1967: beacon implementation is not a contract\\\"\\n        );\\n        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n    }\\n\\n    /**\\n     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n     *\\n     * Emits a {BeaconUpgraded} event.\\n     */\\n    function _upgradeBeaconToAndCall(\\n        address newBeacon,\\n        bytes memory data,\\n        bool forceCall\\n    ) internal {\\n        _setBeacon(newBeacon);\\n        emit BeaconUpgraded(newBeacon);\\n        if (data.length > 0 || forceCall) {\\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xabf3f59bc0e5423eae45e459dbe92e7052c6983628d39008590edc852a62f94a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n    /**\\n     * @dev Must return an address that can be used as a delegate call target.\\n     *\\n     * {BeaconProxy} will check that this address is a contract.\\n     */\\n    function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xd50a3421ac379ccb1be435fa646d66a65c986b4924f0849839f08692f39dde61\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../../interfaces/draft-IERC1822.sol\\\";\\nimport \\\"../ERC1967/ERC1967Upgrade.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n *\\n * _Available since v4.1._\\n */\\nabstract contract UUPSUpgradeable is IERC1822Proxiable, ERC1967Upgrade {\\n    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment\\n    address private immutable __self = address(this);\\n\\n    /**\\n     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\\n     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n     * fail.\\n     */\\n    modifier onlyProxy() {\\n        require(address(this) != __self, \\\"Function must be called through delegatecall\\\");\\n        require(_getImplementation() == __self, \\\"Function must be called through active proxy\\\");\\n        _;\\n    }\\n\\n    /**\\n     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n     * callable on the implementing contract but not through proxies.\\n     */\\n    modifier notDelegated() {\\n        require(address(this) == __self, \\\"UUPSUpgradeable: must not be called through delegatecall\\\");\\n        _;\\n    }\\n\\n    /**\\n     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\\n     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\\n     *\\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\\n     */\\n    function proxiableUUID() external view virtual override notDelegated returns (bytes32) {\\n        return _IMPLEMENTATION_SLOT;\\n    }\\n\\n    /**\\n     * @dev Upgrade the implementation of the proxy to `newImplementation`.\\n     *\\n     * Calls {_authorizeUpgrade}.\\n     *\\n     * Emits an {Upgraded} event.\\n     */\\n    function upgradeTo(address newImplementation) external virtual onlyProxy {\\n        _authorizeUpgrade(newImplementation);\\n        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);\\n    }\\n\\n    /**\\n     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n     * encoded in `data`.\\n     *\\n     * Calls {_authorizeUpgrade}.\\n     *\\n     * Emits an {Upgraded} event.\\n     */\\n    function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {\\n        _authorizeUpgrade(newImplementation);\\n        _upgradeToAndCallUUPS(newImplementation, data, true);\\n    }\\n\\n    /**\\n     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n     * {upgradeTo} and {upgradeToAndCall}.\\n     *\\n     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n     *\\n     * ```solidity\\n     * function _authorizeUpgrade(address) internal override onlyOwner {}\\n     * ```\\n     */\\n    function _authorizeUpgrade(address newImplementation) internal virtual;\\n}\\n\",\"keccak256\":\"0x85cc5aca68692044586dc5ca19a9868d3288f6b35d1085c620dd0278ed0abdaa\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the amount of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the amount of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves `amount` tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 amount) external returns (bool);\\n\\n    /**\\n     * @dev Moves `amount` tokens from `from` to `to` using the\\n     * allowance mechanism. `amount` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(\\n        address from,\\n        address to,\\n        uint256 amount\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9750c6b834f7b43000631af5cc30001c5f547b3ceb3635488f140f60e897ea6b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\\n *\\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\\n * need to send a transaction, and thus is not required to hold Ether at all.\\n */\\ninterface IERC20Permit {\\n    /**\\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\\n     * given ``owner``'s signed approval.\\n     *\\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\\n     * ordering also apply here.\\n     *\\n     * Emits an {Approval} event.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     * - `deadline` must be a timestamp in the future.\\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\\n     * over the EIP712-formatted function arguments.\\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\\n     *\\n     * For more information on the signature format, see the\\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\\n     * section].\\n     */\\n    function permit(\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external;\\n\\n    /**\\n     * @dev Returns the current nonce for `owner`. This value must be\\n     * included whenever a signature is generated for {permit}.\\n     *\\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\\n     * prevents a signature from being used multiple times.\\n     */\\n    function nonces(address owner) external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\\n     */\\n    // solhint-disable-next-line func-name-mixedcase\\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xf41ca991f30855bf80ffd11e9347856a517b977f0a6c2d52e6421a99b7840329\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../extensions/draft-IERC20Permit.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    using Address for address;\\n\\n    function safeTransfer(\\n        IERC20 token,\\n        address to,\\n        uint256 value\\n    ) internal {\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n    }\\n\\n    function safeTransferFrom(\\n        IERC20 token,\\n        address from,\\n        address to,\\n        uint256 value\\n    ) internal {\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n    }\\n\\n    /**\\n     * @dev Deprecated. This function has issues similar to the ones found in\\n     * {IERC20-approve}, and its usage is discouraged.\\n     *\\n     * Whenever possible, use {safeIncreaseAllowance} and\\n     * {safeDecreaseAllowance} instead.\\n     */\\n    function safeApprove(\\n        IERC20 token,\\n        address spender,\\n        uint256 value\\n    ) internal {\\n        // safeApprove should only be called when setting an initial allowance,\\n        // or when resetting it to zero. To increase and decrease it, use\\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n        require(\\n            (value == 0) || (token.allowance(address(this), spender) == 0),\\n            \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n        );\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n    }\\n\\n    function safeIncreaseAllowance(\\n        IERC20 token,\\n        address spender,\\n        uint256 value\\n    ) internal {\\n        uint256 newAllowance = token.allowance(address(this), spender) + value;\\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n    }\\n\\n    function safeDecreaseAllowance(\\n        IERC20 token,\\n        address spender,\\n        uint256 value\\n    ) internal {\\n        unchecked {\\n            uint256 oldAllowance = token.allowance(address(this), spender);\\n            require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n            uint256 newAllowance = oldAllowance - value;\\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n        }\\n    }\\n\\n    function safePermit(\\n        IERC20Permit token,\\n        address owner,\\n        address spender,\\n        uint256 value,\\n        uint256 deadline,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) internal {\\n        uint256 nonceBefore = token.nonces(owner);\\n        token.permit(owner, spender, value, deadline, v, r, s);\\n        uint256 nonceAfter = token.nonces(owner);\\n        require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n        // the target address contains contract code and also asserts for success in the low-level call.\\n\\n        bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n        if (returndata.length > 0) {\\n            // Return data is optional\\n            require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x9b72f93be69ca894d8492c244259615c4a742afc8d63720dbc8bb81087d9b238\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n    /**\\n     * @dev Returns true if `account` is a contract.\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * It is unsafe to assume that an address for which this function returns\\n     * false is an externally-owned account (EOA) and not a contract.\\n     *\\n     * Among others, `isContract` will return false for the following\\n     * types of addresses:\\n     *\\n     *  - an externally-owned account\\n     *  - a contract in construction\\n     *  - an address where a contract will be created\\n     *  - an address where a contract lived, but was destroyed\\n     * ====\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n     *\\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n     * constructor.\\n     * ====\\n     */\\n    function isContract(address account) internal view returns (bool) {\\n        // This method relies on extcodesize/address.code.length, which returns 0\\n        // for contracts in construction, since the code is only stored at the end\\n        // of the constructor execution.\\n\\n        return account.code.length > 0;\\n    }\\n\\n    /**\\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n     * `recipient`, forwarding all available gas and reverting on errors.\\n     *\\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n     * imposed by `transfer`, making them unable to receive funds via\\n     * `transfer`. {sendValue} removes this limitation.\\n     *\\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n     *\\n     * IMPORTANT: because control is transferred to `recipient`, care must be\\n     * taken to not create reentrancy vulnerabilities. Consider using\\n     * {ReentrancyGuard} or the\\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n     */\\n    function sendValue(address payable recipient, uint256 amount) internal {\\n        require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n        (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n        require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n    }\\n\\n    /**\\n     * @dev Performs a Solidity function call using a low level `call`. A\\n     * plain `call` is an unsafe replacement for a function call: use this\\n     * function instead.\\n     *\\n     * If `target` reverts with a revert reason, it is bubbled up by this\\n     * function (like regular Solidity function calls).\\n     *\\n     * Returns the raw returned data. To convert to the expected return value,\\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n     *\\n     * Requirements:\\n     *\\n     * - `target` must be a contract.\\n     * - calling `target` with `data` must not revert.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n     * `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but also transferring `value` wei to `target`.\\n     *\\n     * Requirements:\\n     *\\n     * - the calling contract must have an ETH balance of at least `value`.\\n     * - the called Solidity function must be `payable`.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n        return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a delegate call.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a delegate call.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function functionDelegateCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.delegatecall(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n     *\\n     * _Available since v4.8._\\n     */\\n    function verifyCallResultFromTarget(\\n        address target,\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        if (success) {\\n            if (returndata.length == 0) {\\n                // only check isContract if the call was successful and the return data is empty\\n                // otherwise we already know that it was a contract\\n                require(isContract(target), \\\"Address: call to non-contract\\\");\\n            }\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n     * revert reason or using the provided one.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function verifyCallResult(\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n        // Look for revert reason and bubble it up if present\\n        if (returndata.length > 0) {\\n            // The easiest way to bubble the revert reason is using memory via assembly\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                let returndata_size := mload(returndata)\\n                revert(add(32, returndata), returndata_size)\\n            }\\n        } else {\\n            revert(errorMessage);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf96f969e24029d43d0df89e59d365f277021dac62b48e1c1e3ebe0acdd7f1ca1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/StorageSlot.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n *     function _getImplementation() internal view returns (address) {\\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n *     }\\n *\\n *     function _setImplementation(address newImplementation) internal {\\n *         require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n *     }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlot {\\n    struct AddressSlot {\\n        address value;\\n    }\\n\\n    struct BooleanSlot {\\n        bool value;\\n    }\\n\\n    struct Bytes32Slot {\\n        bytes32 value;\\n    }\\n\\n    struct Uint256Slot {\\n        uint256 value;\\n    }\\n\\n    /**\\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n     */\\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n        /// @solidity memory-safe-assembly\\n        assembly {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n     */\\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n        /// @solidity memory-safe-assembly\\n        assembly {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n     */\\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n        /// @solidity memory-safe-assembly\\n        assembly {\\n            r.slot := slot\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n     */\\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n        /// @solidity memory-safe-assembly\\n        assembly {\\n            r.slot := slot\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xd5c50c54bf02740ebd122ff06832546cb5fa84486d52695a9ccfd11666e0c81d\",\"license\":\"MIT\"},\"contracts/infiniteProxy/interfaces/iProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.21;\\n\\ninterface IProxy {\\n    function setAdmin(address newAdmin_) external;\\n\\n    function setDummyImplementation(address newDummyImplementation_) external;\\n\\n    function addImplementation(address implementation_, bytes4[] calldata sigs_) external;\\n\\n    function removeImplementation(address implementation_) external;\\n\\n    function getAdmin() external view returns (address);\\n\\n    function getDummyImplementation() external view returns (address);\\n\\n    function getImplementationSigs(address impl_) external view returns (bytes4[] memory);\\n\\n    function getSigsImplementation(bytes4 sig_) external view returns (address);\\n\\n    function readFromStorage(bytes32 slot_) external view returns (uint256 result_);\\n}\\n\",\"keccak256\":\"0xbb605491d4bac08e816248feecae7dd17cfc1877c88b2e555abece2970f5ea00\",\"license\":\"MIT\"},\"contracts/libraries/bigMathMinified.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\n/// @title library that represents a number in BigNumber(coefficient and exponent) format to store in smaller bits.\\n/// @notice the number is divided into two parts: a coefficient and an exponent. This comes at a cost of losing some precision\\n/// at the end of the number because the exponent simply fills it with zeroes. This precision is oftentimes negligible and can\\n/// result in significant gas cost reduction due to storage space reduction.\\n/// Also note, a valid big number is as follows: if the exponent is > 0, then coefficient last bits should be occupied to have max precision.\\n/// @dev roundUp is more like a increase 1, which happens everytime for the same number.\\n/// roundDown simply sets trailing digits after coefficientSize to zero (floor), only once for the same number.\\nlibrary BigMathMinified {\\n    /// @dev constants to use for `roundUp` input param to increase readability\\n    bool internal constant ROUND_DOWN = false;\\n    bool internal constant ROUND_UP = true;\\n\\n    /// @dev converts `normal` number to BigNumber with `exponent` and `coefficient` (or precision).\\n    /// e.g.:\\n    /// 5035703444687813576399599 (normal) = (coefficient[32bits], exponent[8bits])[40bits]\\n    /// 5035703444687813576399599 (decimal) => 10000101010010110100000011111011110010100110100000000011100101001101001101011101111 (binary)\\n    ///                                     => 10000101010010110100000011111011000000000000000000000000000000000000000000000000000\\n    ///                                                                        ^-------------------- 51(exponent) -------------- ^\\n    /// coefficient = 1000,0101,0100,1011,0100,0000,1111,1011               (2236301563)\\n    /// exponent =                                            0011,0011     (51)\\n    /// bigNumber =   1000,0101,0100,1011,0100,0000,1111,1011,0011,0011     (572493200179)\\n    ///\\n    /// @param normal number which needs to be converted into Big Number\\n    /// @param coefficientSize at max how many bits of precision there should be (64 = uint64 (64 bits precision))\\n    /// @param exponentSize at max how many bits of exponent there should be (8 = uint8 (8 bits exponent))\\n    /// @param roundUp signals if result should be rounded down or up\\n    /// @return bigNumber converted bigNumber (coefficient << exponent)\\n    function toBigNumber(\\n        uint256 normal,\\n        uint256 coefficientSize,\\n        uint256 exponentSize,\\n        bool roundUp\\n    ) internal pure returns (uint256 bigNumber) {\\n        assembly {\\n            let lastBit_\\n            let number_ := normal\\n            if gt(number_, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {\\n                number_ := shr(0x80, number_)\\n                lastBit_ := 0x80\\n            }\\n            if gt(number_, 0xFFFFFFFFFFFFFFFF) {\\n                number_ := shr(0x40, number_)\\n                lastBit_ := add(lastBit_, 0x40)\\n            }\\n            if gt(number_, 0xFFFFFFFF) {\\n                number_ := shr(0x20, number_)\\n                lastBit_ := add(lastBit_, 0x20)\\n            }\\n            if gt(number_, 0xFFFF) {\\n                number_ := shr(0x10, number_)\\n                lastBit_ := add(lastBit_, 0x10)\\n            }\\n            if gt(number_, 0xFF) {\\n                number_ := shr(0x8, number_)\\n                lastBit_ := add(lastBit_, 0x8)\\n            }\\n            if gt(number_, 0xF) {\\n                number_ := shr(0x4, number_)\\n                lastBit_ := add(lastBit_, 0x4)\\n            }\\n            if gt(number_, 0x3) {\\n                number_ := shr(0x2, number_)\\n                lastBit_ := add(lastBit_, 0x2)\\n            }\\n            if gt(number_, 0x1) {\\n                lastBit_ := add(lastBit_, 1)\\n            }\\n            if gt(number_, 0) {\\n                lastBit_ := add(lastBit_, 1)\\n            }\\n            if lt(lastBit_, coefficientSize) {\\n                // for throw exception\\n                lastBit_ := coefficientSize\\n            }\\n            let exponent := sub(lastBit_, coefficientSize)\\n            let coefficient := shr(exponent, normal)\\n            if and(roundUp, gt(exponent, 0)) {\\n                // rounding up is only needed if exponent is > 0, as otherwise the coefficient fully holds the original number\\n                coefficient := add(coefficient, 1)\\n                if eq(shl(coefficientSize, 1), coefficient) {\\n                    // case were coefficient was e.g. 111, with adding 1 it became 1000 (in binary) and coefficientSize 3 bits\\n                    // final coefficient would exceed it's size. -> reduce coefficent to 100 and increase exponent by 1.\\n                    coefficient := shl(sub(coefficientSize, 1), 1)\\n                    exponent := add(exponent, 1)\\n                }\\n            }\\n            if iszero(lt(exponent, shl(exponentSize, 1))) {\\n                // if exponent is >= exponentSize, the normal number is too big to fit within\\n                // BigNumber with too small sizes for coefficient and exponent\\n                revert(0, 0)\\n            }\\n            bigNumber := shl(exponentSize, coefficient)\\n            bigNumber := add(bigNumber, exponent)\\n        }\\n    }\\n\\n    /// @dev get `normal` number from `bigNumber`, `exponentSize` and `exponentMask`\\n    function fromBigNumber(\\n        uint256 bigNumber,\\n        uint256 exponentSize,\\n        uint256 exponentMask\\n    ) internal pure returns (uint256 normal) {\\n        assembly {\\n            let coefficient := shr(exponentSize, bigNumber)\\n            let exponent := and(bigNumber, exponentMask)\\n            normal := shl(exponent, coefficient)\\n        }\\n    }\\n\\n    /// @dev gets the most significant bit `lastBit` of a `normal` number (length of given number of binary format).\\n    /// e.g.\\n    /// 5035703444687813576399599 = 10000101010010110100000011111011110010100110100000000011100101001101001101011101111\\n    /// lastBit =                   ^---------------------------------   83   ----------------------------------------^\\n    function mostSignificantBit(uint256 normal) internal pure returns (uint lastBit) {\\n        assembly {\\n            let number_ := normal\\n            if gt(normal, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {\\n                number_ := shr(0x80, number_)\\n                lastBit := 0x80\\n            }\\n            if gt(number_, 0xFFFFFFFFFFFFFFFF) {\\n                number_ := shr(0x40, number_)\\n                lastBit := add(lastBit, 0x40)\\n            }\\n            if gt(number_, 0xFFFFFFFF) {\\n                number_ := shr(0x20, number_)\\n                lastBit := add(lastBit, 0x20)\\n            }\\n            if gt(number_, 0xFFFF) {\\n                number_ := shr(0x10, number_)\\n                lastBit := add(lastBit, 0x10)\\n            }\\n            if gt(number_, 0xFF) {\\n                number_ := shr(0x8, number_)\\n                lastBit := add(lastBit, 0x8)\\n            }\\n            if gt(number_, 0xF) {\\n                number_ := shr(0x4, number_)\\n                lastBit := add(lastBit, 0x4)\\n            }\\n            if gt(number_, 0x3) {\\n                number_ := shr(0x2, number_)\\n                lastBit := add(lastBit, 0x2)\\n            }\\n            if gt(number_, 0x1) {\\n                lastBit := add(lastBit, 1)\\n            }\\n            if gt(number_, 0) {\\n                lastBit := add(lastBit, 1)\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf0be1002909edf30aec3dc6623c2bd2407ed94064b62674c01032b844dec206a\",\"license\":\"BUSL-1.1\"},\"contracts/libraries/errorTypes.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\nlibrary LibsErrorTypes {\\n    /***********************************|\\n    |         LiquidityCalcs            | \\n    |__________________________________*/\\n\\n    /// @notice thrown when supply or borrow exchange price is zero at calc token data (token not configured yet)\\n    uint256 internal constant LiquidityCalcs__ExchangePriceZero = 70001;\\n\\n    /// @notice thrown when rate data is set to a version that is not implemented\\n    uint256 internal constant LiquidityCalcs__UnsupportedRateVersion = 70002;\\n\\n    /***********************************|\\n    |           SafeTransfer            | \\n    |__________________________________*/\\n\\n    /// @notice thrown when safe transfer from for an ERC20 fails\\n    uint256 internal constant SafeTransfer__TransferFromFailed = 71001;\\n\\n    /// @notice thrown when safe transfer for an ERC20 fails\\n    uint256 internal constant SafeTransfer__TransferFailed = 71002;\\n}\\n\",\"keccak256\":\"0xfcd8d3b052c8e023b0db72cb9afe55c552d5a1ef4741dbcd1a494145f2d5ff62\",\"license\":\"BUSL-1.1\"},\"contracts/libraries/liquidityCalcs.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\nimport { LibsErrorTypes as ErrorTypes } from \\\"./errorTypes.sol\\\";\\nimport { LiquiditySlotsLink } from \\\"./liquiditySlotsLink.sol\\\";\\nimport { BigMathMinified } from \\\"./bigMathMinified.sol\\\";\\n\\n/// @notice implements calculation methods used for Fluid liquidity such as updated exchange prices,\\n/// borrow rate, withdrawal / borrow limits, revenue amount.\\nlibrary LiquidityCalcs {\\n    error FluidLiquidityCalcsError(uint256 errorId_);\\n\\n    /// @notice emitted if the calculated borrow rate surpassed max borrow rate (16 bits) and was capped at maximum value 65535\\n    event BorrowRateMaxCap();\\n\\n    /// @dev constants as from Liquidity variables.sol\\n    uint256 internal constant EXCHANGE_PRICES_PRECISION = 1e12;\\n\\n    /// @dev Ignoring leap years\\n    uint256 internal constant SECONDS_PER_YEAR = 365 days;\\n    // constants used for BigMath conversion from and to storage\\n    uint256 internal constant DEFAULT_EXPONENT_SIZE = 8;\\n    uint256 internal constant DEFAULT_EXPONENT_MASK = 0xFF;\\n\\n    uint256 internal constant FOUR_DECIMALS = 1e4;\\n    uint256 internal constant TWELVE_DECIMALS = 1e12;\\n    uint256 internal constant X14 = 0x3fff;\\n    uint256 internal constant X15 = 0x7fff;\\n    uint256 internal constant X16 = 0xffff;\\n    uint256 internal constant X18 = 0x3ffff;\\n    uint256 internal constant X24 = 0xffffff;\\n    uint256 internal constant X33 = 0x1ffffffff;\\n    uint256 internal constant X64 = 0xffffffffffffffff;\\n\\n    ///////////////////////////////////////////////////////////////////////////\\n    //////////                  CALC EXCHANGE PRICES                  /////////\\n    ///////////////////////////////////////////////////////////////////////////\\n\\n    /// @dev calculates interest (exchange prices) for a token given its' exchangePricesAndConfig from storage.\\n    /// @param exchangePricesAndConfig_ exchange prices and config packed uint256 read from storage\\n    /// @return supplyExchangePrice_ updated supplyExchangePrice\\n    /// @return borrowExchangePrice_ updated borrowExchangePrice\\n    function calcExchangePrices(\\n        uint256 exchangePricesAndConfig_\\n    ) internal view returns (uint256 supplyExchangePrice_, uint256 borrowExchangePrice_) {\\n        // Extracting exchange prices\\n        supplyExchangePrice_ =\\n            (exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_SUPPLY_EXCHANGE_PRICE) &\\n            X64;\\n        borrowExchangePrice_ =\\n            (exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_BORROW_EXCHANGE_PRICE) &\\n            X64;\\n\\n        if (supplyExchangePrice_ == 0 || borrowExchangePrice_ == 0) {\\n            revert FluidLiquidityCalcsError(ErrorTypes.LiquidityCalcs__ExchangePriceZero);\\n        }\\n\\n        uint256 temp_ = exchangePricesAndConfig_ & X16; // temp_ = borrowRate\\n\\n        unchecked {\\n            // last timestamp can not be > current timestamp\\n            uint256 secondsSinceLastUpdate_ = block.timestamp -\\n                ((exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_LAST_TIMESTAMP) & X33);\\n\\n            uint256 borrowRatio_ = (exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_BORROW_RATIO) &\\n                X15;\\n            if (secondsSinceLastUpdate_ == 0 || temp_ == 0 || borrowRatio_ == 1) {\\n                // if no time passed, borrow rate is 0, or no raw borrowings: no exchange price update needed\\n                // (if borrowRatio_ == 1 means there is only borrowInterestFree, as first bit is 1 and rest is 0)\\n                return (supplyExchangePrice_, borrowExchangePrice_);\\n            }\\n\\n            // calculate new borrow exchange price.\\n            // formula borrowExchangePriceIncrease: previous price * borrow rate * secondsSinceLastUpdate_.\\n            // nominator is max uint112 (uint64 * uint16 * uint32). Divisor can not be 0.\\n            borrowExchangePrice_ +=\\n                (borrowExchangePrice_ * temp_ * secondsSinceLastUpdate_) /\\n                (SECONDS_PER_YEAR * FOUR_DECIMALS);\\n\\n            // FOR SUPPLY EXCHANGE PRICE:\\n            // all yield paid by borrowers (in mode with interest) goes to suppliers in mode with interest.\\n            // formula: previous price * supply rate * secondsSinceLastUpdate_.\\n            // where supply rate = (borrow rate  - revenueFee%) * ratioSupplyYield. And\\n            // ratioSupplyYield = utilization * supplyRatio * borrowRatio\\n            //\\n            // Example:\\n            // supplyRawInterest is 80, supplyInterestFree is 20. totalSupply is 100. BorrowedRawInterest is 50.\\n            // BorrowInterestFree is 10. TotalBorrow is 60. borrow rate 40%, revenueFee 10%.\\n            // yield is 10 (so half a year must have passed).\\n            // supplyRawInterest must become worth 89. totalSupply must become 109. BorrowedRawInterest must become 60.\\n            // borrowInterestFree must still be 10. supplyInterestFree still 20. totalBorrow 70.\\n            // supplyExchangePrice would have to go from 1 to 1,125 (+ 0.125). borrowExchangePrice from 1 to 1,2 (+0.2).\\n            // utilization is 60%. supplyRatio = 20 / 80 = 25% (only 80% of lenders receiving yield).\\n            // borrowRatio = 10 / 50 = 20% (only 83,333% of borrowers paying yield):\\n            // x of borrowers paying yield = 100% - (20 / (100 + 20)) = 100% - 16.6666666% = 83,333%.\\n            // ratioSupplyYield = 60% * 83,33333% * (100% + 20%) = 62,5%\\n            // supplyRate = (40% * (100% - 10%)) * = 36% * 62,5% = 22.5%\\n            // increase in supplyExchangePrice, assuming 100 as previous price.\\n            // 100 * 22,5% * 1/2 (half a year) = 0,1125.\\n            // cross-check supplyRawInterest worth = 80 * 1.1125 = 89. totalSupply worth = 89 + 20.\\n\\n            // -------------- 1. calculate ratioSupplyYield --------------------------------\\n            // step1: utilization * supplyRatio (or actually part of lenders receiving yield)\\n\\n            // temp_ => supplyRatio (in 1e2: 100% = 10_000; 1% = 100 -> max value 16_383)\\n            // if first bit 0 then ratio is supplyInterestFree / supplyWithInterest (supplyWithInterest is bigger)\\n            // else ratio is supplyWithInterest / supplyInterestFree (supplyInterestFree is bigger)\\n            temp_ = (exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_SUPPLY_RATIO) & X15;\\n\\n            if (temp_ == 1) {\\n                // if no raw supply: no exchange price update needed\\n                // (if supplyRatio_ == 1 means there is only supplyInterestFree, as first bit is 1 and rest is 0)\\n                return (supplyExchangePrice_, borrowExchangePrice_);\\n            }\\n\\n            // ratioSupplyYield precision is 1e27 as 100% for increased precision when supplyInterestFree > supplyWithInterest\\n            if (temp_ & 1 == 1) {\\n                // ratio is supplyWithInterest / supplyInterestFree (supplyInterestFree is bigger)\\n                temp_ = temp_ >> 1;\\n\\n                // Note: case where temp_ == 0 (only supplyInterestFree, no yield) already covered by early return\\n                // in the if statement a little above.\\n\\n                // based on above example but supplyRawInterest is 20, supplyInterestFree is 80. no fee.\\n                // supplyRawInterest must become worth 30. totalSupply must become 110.\\n                // supplyExchangePrice would have to go from 1 to 1,5. borrowExchangePrice from 1 to 1,2.\\n                // so ratioSupplyYield must come out as 2.5 (250%).\\n                // supplyRatio would be (20 * 10_000 / 80) = 2500. but must be inverted.\\n                temp_ = (1e27 * FOUR_DECIMALS) / temp_; // e.g. 1e31 / 2500 = 4e27. (* 1e27 for precision)\\n                // e.g. 5_000 * (1e27 + 4e27) / 1e27 = 25_000 (=250%).\\n                temp_ =\\n                    // utilization * (100% + 100% / supplyRatio)\\n                    (((exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_UTILIZATION) & X14) *\\n                        (1e27 + temp_)) / // extract utilization (max 16_383 so there is no way this can overflow).\\n                    (FOUR_DECIMALS);\\n                // max possible value of temp_ here is 16383 * (1e27 + 1e31) / 1e4 = ~1.64e31\\n            } else {\\n                // ratio is supplyInterestFree / supplyWithInterest (supplyWithInterest is bigger)\\n                temp_ = temp_ >> 1;\\n                // if temp_ == 0 then only supplyWithInterest => full yield. temp_ is already 0\\n\\n                // e.g. 5_000 * 10_000 + (20 * 10_000 / 80) / 10_000 = 5000 * 12500 / 10000 = 6250 (=62.5%).\\n                temp_ =\\n                    // 1e27 * utilization * (100% + supplyRatio) / 100%\\n                    (1e27 *\\n                        ((exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_UTILIZATION) & X14) * // extract utilization (max 16_383 so there is no way this can overflow).\\n                        (FOUR_DECIMALS + temp_)) /\\n                    (FOUR_DECIMALS * FOUR_DECIMALS);\\n                // max possible temp_ value: 1e27 * 16383 * 2e4 / 1e8 = 3.2766e27\\n            }\\n            // from here temp_ => ratioSupplyYield (utilization * supplyRatio part) scaled by 1e27. max possible value ~1.64e31\\n\\n            // step2 of ratioSupplyYield: add borrowRatio (only x% of borrowers paying yield)\\n            if (borrowRatio_ & 1 == 1) {\\n                // ratio is borrowWithInterest / borrowInterestFree (borrowInterestFree is bigger)\\n                borrowRatio_ = borrowRatio_ >> 1;\\n                // borrowRatio_ => x of total bororwers paying yield. scale to 1e27.\\n\\n                // Note: case where borrowRatio_ == 0 (only borrowInterestFree, no yield) already covered\\n                // at the beginning of the method by early return if `borrowRatio_ == 1`.\\n\\n                // based on above example but borrowRawInterest is 10, borrowInterestFree is 50. no fee. borrowRatio = 20%.\\n                // so only 16.66% of borrowers are paying yield. so the 100% - part of the formula is not needed.\\n                // x of borrowers paying yield = (borrowRatio / (100 + borrowRatio)) = 16.6666666%\\n                // borrowRatio_ => x of total bororwers paying yield. scale to 1e27.\\n                borrowRatio_ = (borrowRatio_ * 1e27) / (FOUR_DECIMALS + borrowRatio_);\\n                // max value here for borrowRatio_ is (1e31 / (1e4 + 1e4))= 5e26 (= 50% of borrowers paying yield).\\n            } else {\\n                // ratio is borrowInterestFree / borrowWithInterest (borrowWithInterest is bigger)\\n                borrowRatio_ = borrowRatio_ >> 1;\\n\\n                // borrowRatio_ => x of total bororwers paying yield. scale to 1e27.\\n                // x of borrowers paying yield = 100% - (borrowRatio / (100 + borrowRatio)) = 100% - 16.6666666% = 83,333%.\\n                borrowRatio_ = (1e27 - ((borrowRatio_ * 1e27) / (FOUR_DECIMALS + borrowRatio_)));\\n                // borrowRatio can never be > 100%. so max subtraction can be 100% - 100% / 200%.\\n                // or if borrowRatio_ is 0 -> 100% - 0. or if borrowRatio_ is 1 -> 100% - 1 / 101.\\n                // max value here for borrowRatio_ is 1e27 - 0 = 1e27 (= 100% of borrowers paying yield).\\n            }\\n\\n            // temp_ => ratioSupplyYield. scaled down from 1e25 = 1% each to normal percent precision 1e2 = 1%.\\n            // max nominator value is ~1.64e31 * 1e27 = 1.64e58. max result = 1.64e8\\n            temp_ = (FOUR_DECIMALS * temp_ * borrowRatio_) / 1e54;\\n\\n            // 2. calculate supply rate\\n            // temp_ => supply rate (borrow rate  - revenueFee%) * ratioSupplyYield.\\n            // division part is done in next step to increase precision. (divided by 2x FOUR_DECIMALS, fee + borrowRate)\\n            // Note that all calculation divisions for supplyExchangePrice are rounded down.\\n            // Note supply rate can be bigger than the borrowRate, e.g. if there are only few lenders with interest\\n            // but more suppliers not earning interest.\\n            temp_ = ((exchangePricesAndConfig_ & X16) * // borrow rate\\n                temp_ * // ratioSupplyYield\\n                (FOUR_DECIMALS - ((exchangePricesAndConfig_ >> LiquiditySlotsLink.BITS_EXCHANGE_PRICES_FEE) & X14))); // revenueFee\\n            // fee can not be > 100%. max possible = 65535 * ~1.64e8 * 1e4 =~1.074774e17.\\n\\n            // 3. calculate increase in supply exchange price\\n            supplyExchangePrice_ += ((supplyExchangePrice_ * temp_ * secondsSinceLastUpdate_) /\\n                (SECONDS_PER_YEAR * FOUR_DECIMALS * FOUR_DECIMALS * FOUR_DECIMALS));\\n            // max possible nominator = max uint 64 * 1.074774e17 * max uint32 = ~8.52e45. Denominator can not be 0.\\n        }\\n    }\\n\\n    ///////////////////////////////////////////////////////////////////////////\\n    //////////                     CALC REVENUE                       /////////\\n    ///////////////////////////////////////////////////////////////////////////\\n\\n    /// @dev gets the `revenueAmount_` for a token given its' totalAmounts and exchangePricesAndConfig from storage\\n    /// and the current balance of the Fluid liquidity contract for the token.\\n    /// @param totalAmounts_ total amounts packed uint256 read from storage\\n    /// @param exchangePricesAndConfig_ exchange prices and config packed uint256 read from storage\\n    /// @param liquidityTokenBalance_   current balance of Liquidity contract (IERC20(token_).balanceOf(address(this)))\\n    /// @return revenueAmount_ collectable revenue amount\\n    function calcRevenue(\\n        uint256 totalAmounts_,\\n        uint256 exchangePricesAndConfig_,\\n        uint256 liquidityTokenBalance_\\n    ) internal view returns (uint256 revenueAmount_) {\\n        // @dev no need to super-optimize this method as it is only used by admin\\n\\n        // calculate the new exchange prices based on earned interest\\n        (uint256 supplyExchangePrice_, uint256 borrowExchangePrice_) = calcExchangePrices(exchangePricesAndConfig_);\\n\\n        // total supply = interest free + with interest converted from raw\\n        uint256 totalSupply_ = getTotalSupply(totalAmounts_, supplyExchangePrice_);\\n\\n        if (totalSupply_ > 0) {\\n            // available revenue: balanceOf(token) + totalBorrowings - totalLendings.\\n            revenueAmount_ = liquidityTokenBalance_ + getTotalBorrow(totalAmounts_, borrowExchangePrice_);\\n            // ensure there is no possible case because of rounding etc. where this would revert,\\n            // explicitly check if >\\n            revenueAmount_ = revenueAmount_ > totalSupply_ ? revenueAmount_ - totalSupply_ : 0;\\n            // Note: if utilization > 100% (totalSupply < totalBorrow), then all the amount above 100% utilization\\n            // can only be revenue.\\n        } else {\\n            // if supply is 0, then rest of balance can be withdrawn as revenue so that no amounts get stuck\\n            revenueAmount_ = liquidityTokenBalance_;\\n        }\\n    }\\n\\n    ///////////////////////////////////////////////////////////////////////////\\n    //////////                      CALC LIMITS                       /////////\\n    ///////////////////////////////////////////////////////////////////////////\\n\\n    /// @dev calculates withdrawal limit before an operate execution:\\n    /// amount of user supply that must stay supplied (not amount that can be withdrawn).\\n    /// i.e. if user has supplied 100m and can withdraw 5M, this method returns the 95M, not the withdrawable amount 5M\\n    /// @param userSupplyData_ user supply data packed uint256 from storage\\n    /// @param userSupply_ current user supply amount already extracted from `userSupplyData_` and converted from BigMath\\n    /// @return currentWithdrawalLimit_ current withdrawal limit updated for expansion since last interaction.\\n    ///         returned value is in raw for with interest mode, normal amount for interest free mode!\\n    function calcWithdrawalLimitBeforeOperate(\\n        uint256 userSupplyData_,\\n        uint256 userSupply_\\n    ) internal view returns (uint256 currentWithdrawalLimit_) {\\n        // @dev must support handling the case where timestamp is 0 (config is set but no interactions yet).\\n        // first tx where timestamp is 0 will enter `if (lastWithdrawalLimit_ == 0)` because lastWithdrawalLimit_ is not set yet.\\n        // returning max withdrawal allowed, which is not exactly right but doesn't matter because the first interaction must be\\n        // a deposit anyway. Important is that it would not revert.\\n\\n        // Note the first time a deposit brings the user supply amount to above the base withdrawal limit, the active limit\\n        // is the fully expanded limit immediately.\\n\\n        // extract last set withdrawal limit\\n        uint256 lastWithdrawalLimit_ = (userSupplyData_ >>\\n            LiquiditySlotsLink.BITS_USER_SUPPLY_PREVIOUS_WITHDRAWAL_LIMIT) & X64;\\n        lastWithdrawalLimit_ =\\n            (lastWithdrawalLimit_ >> DEFAULT_EXPONENT_SIZE) <<\\n            (lastWithdrawalLimit_ & DEFAULT_EXPONENT_MASK);\\n        if (lastWithdrawalLimit_ == 0) {\\n            // withdrawal limit is not activated. Max withdrawal allowed\\n            return 0;\\n        }\\n\\n        uint256 maxWithdrawableLimit_;\\n        uint256 temp_;\\n        unchecked {\\n            // extract max withdrawable percent of user supply and\\n            // calculate maximum withdrawable amount expandPercentage of user supply at full expansion duration elapsed\\n            // e.g.: if 10% expandPercentage, meaning 10% is withdrawable after full expandDuration has elapsed.\\n\\n            // userSupply_ needs to be atleast 1e73 to overflow max limit of ~1e77 in uint256 (no token in existence where this is possible).\\n            maxWithdrawableLimit_ =\\n                (((userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_PERCENT) & X14) * userSupply_) /\\n                FOUR_DECIMALS;\\n\\n            // time elapsed since last withdrawal limit was set (in seconds)\\n            // @dev last process timestamp is guaranteed to exist for withdrawal, as a supply must have happened before.\\n            // last timestamp can not be > current timestamp\\n            temp_ =\\n                block.timestamp -\\n                ((userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_LAST_UPDATE_TIMESTAMP) & X33);\\n        }\\n        // calculate withdrawable amount of expandPercent that is elapsed of expandDuration.\\n        // e.g. if 60% of expandDuration has elapsed, then user should be able to withdraw 6% of user supply, down to 94%.\\n        // Note: no explicit check for this needed, it is covered by setting minWithdrawalLimit_ if needed.\\n        temp_ =\\n            (maxWithdrawableLimit_ * temp_) /\\n            // extract expand duration: After this, decrement won't happen (user can withdraw 100% of withdraw limit)\\n            ((userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_DURATION) & X24); // expand duration can never be 0\\n        // calculate expanded withdrawal limit: last withdrawal limit - withdrawable amount.\\n        // Note: withdrawable amount here can grow bigger than userSupply if timeElapsed is a lot bigger than expandDuration,\\n        // which would cause the subtraction `lastWithdrawalLimit_ - withdrawableAmount_` to revert. In that case, set 0\\n        // which will cause minimum (fully expanded) withdrawal limit to be set in lines below.\\n        unchecked {\\n            // underflow explicitly checked & handled\\n            currentWithdrawalLimit_ = lastWithdrawalLimit_ > temp_ ? lastWithdrawalLimit_ - temp_ : 0;\\n            // calculate minimum withdrawal limit: minimum amount of user supply that must stay supplied at full expansion.\\n            // subtraction can not underflow as maxWithdrawableLimit_ is a percentage amount (<=100%) of userSupply_\\n            temp_ = userSupply_ - maxWithdrawableLimit_;\\n        }\\n        // if withdrawal limit is decreased below minimum then set minimum\\n        // (e.g. when more than expandDuration time has elapsed)\\n        if (temp_ > currentWithdrawalLimit_) {\\n            currentWithdrawalLimit_ = temp_;\\n        }\\n    }\\n\\n    /// @dev calculates withdrawal limit after an operate execution:\\n    /// amount of user supply that must stay supplied (not amount that can be withdrawn).\\n    /// i.e. if user has supplied 100m and can withdraw 5M, this method returns the 95M, not the withdrawable amount 5M\\n    /// @param userSupplyData_ user supply data packed uint256 from storage\\n    /// @param userSupply_ current user supply amount already extracted from `userSupplyData_` and added / subtracted with the executed operate amount\\n    /// @param newWithdrawalLimit_ current withdrawal limit updated for expansion since last interaction, result from `calcWithdrawalLimitBeforeOperate`\\n    /// @return withdrawalLimit_ updated withdrawal limit that should be written to storage. returned value is in\\n    ///                          raw for with interest mode, normal amount for interest free mode!\\n    function calcWithdrawalLimitAfterOperate(\\n        uint256 userSupplyData_,\\n        uint256 userSupply_,\\n        uint256 newWithdrawalLimit_\\n    ) internal pure returns (uint256) {\\n        // temp_ => base withdrawal limit. below this, maximum withdrawals are allowed\\n        uint256 temp_ = (userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_BASE_WITHDRAWAL_LIMIT) & X18;\\n        temp_ = (temp_ >> DEFAULT_EXPONENT_SIZE) << (temp_ & DEFAULT_EXPONENT_MASK);\\n\\n        // if user supply is below base limit then max withdrawals are allowed\\n        if (userSupply_ < temp_) {\\n            return 0;\\n        }\\n        // temp_ => withdrawal limit expandPercent (is in 1e2 decimals)\\n        temp_ = (userSupplyData_ >> LiquiditySlotsLink.BITS_USER_SUPPLY_EXPAND_PERCENT) & X14;\\n        unchecked {\\n            // temp_ => minimum withdrawal limit: userSupply - max withdrawable limit (userSupply * expandPercent))\\n            // userSupply_ needs to be atleast 1e73 to overflow max limit of ~1e77 in uint256 (no token in existence where this is possible).\\n            // subtraction can not underflow as maxWithdrawableLimit_ is a percentage amount (<=100%) of userSupply_\\n            temp_ = userSupply_ - ((userSupply_ * temp_) / FOUR_DECIMALS);\\n        }\\n        // if new (before operation) withdrawal limit is less than minimum limit then set minimum limit.\\n        // e.g. can happen on new deposits. withdrawal limit is instantly fully expanded in a scenario where\\n        // increased deposit amount outpaces withrawals.\\n        if (temp_ > newWithdrawalLimit_) {\\n            return temp_;\\n        }\\n        return newWithdrawalLimit_;\\n    }\\n\\n    /// @dev calculates borrow limit before an operate execution:\\n    /// total amount user borrow can reach (not borrowable amount in current operation).\\n    /// i.e. if user has borrowed 50M and can still borrow 5M, this method returns the total 55M, not the borrowable amount 5M\\n    /// @param userBorrowData_ user borrow data packed uint256 from storage\\n    /// @param userBorrow_ current user borrow amount already extracted from `userBorrowData_`\\n    /// @return currentBorrowLimit_ current borrow limit updated for expansion since last interaction. returned value is in\\n    ///                             raw for with interest mode, normal amount for interest free mode!\\n    function calcBorrowLimitBeforeOperate(\\n        uint256 userBorrowData_,\\n        uint256 userBorrow_\\n    ) internal view returns (uint256 currentBorrowLimit_) {\\n        // @dev must support handling the case where timestamp is 0 (config is set but no interactions yet) -> base limit.\\n        // first tx where timestamp is 0 will enter `if (maxExpandedBorrowLimit_ < baseBorrowLimit_)` because `userBorrow_` and thus\\n        // `maxExpansionLimit_` and thus `maxExpandedBorrowLimit_` is 0 and `baseBorrowLimit_` can not be 0.\\n\\n        // temp_ = extract borrow expand percent (is in 1e2 decimals)\\n        uint256 temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_PERCENT) & X14;\\n\\n        uint256 maxExpansionLimit_;\\n        uint256 maxExpandedBorrowLimit_;\\n        unchecked {\\n            // calculate max expansion limit: Max amount limit can expand to since last interaction\\n            // userBorrow_ needs to be atleast 1e73 to overflow max limit of ~1e77 in uint256 (no token in existence where this is possible).\\n            maxExpansionLimit_ = ((userBorrow_ * temp_) / FOUR_DECIMALS);\\n\\n            // calculate max borrow limit: Max point limit can increase to since last interaction\\n            maxExpandedBorrowLimit_ = userBorrow_ + maxExpansionLimit_;\\n        }\\n\\n        // currentBorrowLimit_ = extract base borrow limit\\n        currentBorrowLimit_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_BASE_BORROW_LIMIT) & X18;\\n        currentBorrowLimit_ =\\n            (currentBorrowLimit_ >> DEFAULT_EXPONENT_SIZE) <<\\n            (currentBorrowLimit_ & DEFAULT_EXPONENT_MASK);\\n\\n        if (maxExpandedBorrowLimit_ < currentBorrowLimit_) {\\n            return currentBorrowLimit_;\\n        }\\n        // time elapsed since last borrow limit was set (in seconds)\\n        unchecked {\\n            // temp_ = timeElapsed_ (last timestamp can not be > current timestamp)\\n            temp_ =\\n                block.timestamp -\\n                ((userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_LAST_UPDATE_TIMESTAMP) & X33); // extract last udpate timestamp\\n        }\\n\\n        // currentBorrowLimit_ = expandedBorrowableAmount + extract last set borrow limit\\n        currentBorrowLimit_ =\\n            // calculate borrow limit expansion since last interaction for `expandPercent` that is elapsed of `expandDuration`.\\n            // divisor is extract expand duration (after this, full expansion to expandPercentage happened).\\n            ((maxExpansionLimit_ * temp_) /\\n                ((userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_DURATION) & X24)) + // expand duration can never be 0\\n            //  extract last set borrow limit\\n            BigMathMinified.fromBigNumber(\\n                (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_PREVIOUS_BORROW_LIMIT) & X64,\\n                DEFAULT_EXPONENT_SIZE,\\n                DEFAULT_EXPONENT_MASK\\n            );\\n\\n        // if timeElapsed is bigger than expandDuration, new borrow limit would be > max expansion,\\n        // so set to `maxExpandedBorrowLimit_` in that case.\\n        // also covers the case where last process timestamp = 0 (timeElapsed would simply be very big)\\n        if (currentBorrowLimit_ > maxExpandedBorrowLimit_) {\\n            currentBorrowLimit_ = maxExpandedBorrowLimit_;\\n        }\\n        // temp_ = extract hard max borrow limit. Above this user can never borrow (not expandable above)\\n        temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_MAX_BORROW_LIMIT) & X18;\\n        temp_ = (temp_ >> DEFAULT_EXPONENT_SIZE) << (temp_ & DEFAULT_EXPONENT_MASK);\\n\\n        if (currentBorrowLimit_ > temp_) {\\n            currentBorrowLimit_ = temp_;\\n        }\\n    }\\n\\n    /// @dev calculates borrow limit after an operate execution:\\n    /// total amount user borrow can reach (not borrowable amount in current operation).\\n    /// i.e. if user has borrowed 50M and can still borrow 5M, this method returns the total 55M, not the borrowable amount 5M\\n    /// @param userBorrowData_ user borrow data packed uint256 from storage\\n    /// @param userBorrow_ current user borrow amount already extracted from `userBorrowData_` and added / subtracted with the executed operate amount\\n    /// @param newBorrowLimit_ current borrow limit updated for expansion since last interaction, result from `calcBorrowLimitBeforeOperate`\\n    /// @return borrowLimit_ updated borrow limit that should be written to storage.\\n    ///                      returned value is in raw for with interest mode, normal amount for interest free mode!\\n    function calcBorrowLimitAfterOperate(\\n        uint256 userBorrowData_,\\n        uint256 userBorrow_,\\n        uint256 newBorrowLimit_\\n    ) internal pure returns (uint256 borrowLimit_) {\\n        // temp_ = extract borrow expand percent\\n        uint256 temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_EXPAND_PERCENT) & X14; // (is in 1e2 decimals)\\n\\n        unchecked {\\n            // borrowLimit_ = calculate maximum borrow limit at full expansion.\\n            // userBorrow_ needs to be at least 1e73 to overflow max limit of ~1e77 in uint256 (no token in existence where this is possible).\\n            borrowLimit_ = userBorrow_ + ((userBorrow_ * temp_) / FOUR_DECIMALS);\\n        }\\n\\n        // temp_ = extract base borrow limit\\n        temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_BASE_BORROW_LIMIT) & X18;\\n        temp_ = (temp_ >> DEFAULT_EXPONENT_SIZE) << (temp_ & DEFAULT_EXPONENT_MASK);\\n\\n        if (borrowLimit_ < temp_) {\\n            // below base limit, borrow limit is always base limit\\n            return temp_;\\n        }\\n        // temp_ = extract hard max borrow limit. Above this user can never borrow (not expandable above)\\n        temp_ = (userBorrowData_ >> LiquiditySlotsLink.BITS_USER_BORROW_MAX_BORROW_LIMIT) & X18;\\n        temp_ = (temp_ >> DEFAULT_EXPONENT_SIZE) << (temp_ & DEFAULT_EXPONENT_MASK);\\n\\n        // make sure fully expanded borrow limit is not above hard max borrow limit\\n        if (borrowLimit_ > temp_) {\\n            borrowLimit_ = temp_;\\n        }\\n        // if new borrow limit (from before operate) is > max borrow limit, set max borrow limit.\\n        // (e.g. on a repay shrinking instantly to fully expanded borrow limit from new borrow amount. shrinking is instant)\\n        if (newBorrowLimit_ > borrowLimit_) {\\n            return borrowLimit_;\\n        }\\n        return newBorrowLimit_;\\n    }\\n\\n    ///////////////////////////////////////////////////////////////////////////\\n    //////////                      CALC RATES                        /////////\\n    ///////////////////////////////////////////////////////////////////////////\\n\\n    /// @dev Calculates new borrow rate from utilization for a token\\n    /// @param rateData_ rate data packed uint256 from storage for the token\\n    /// @param utilization_ totalBorrow / totalSupply. 1e4 = 100% utilization\\n    /// @return rate_ rate for that particular token in 1e2 precision (e.g. 5% rate = 500)\\n    function calcBorrowRateFromUtilization(uint256 rateData_, uint256 utilization_) internal returns (uint256 rate_) {\\n        // extract rate version: 4 bits (0xF) starting from bit 0\\n        uint256 rateVersion_ = (rateData_ & 0xF);\\n\\n        if (rateVersion_ == 1) {\\n            rate_ = calcRateV1(rateData_, utilization_);\\n        } else if (rateVersion_ == 2) {\\n            rate_ = calcRateV2(rateData_, utilization_);\\n        } else {\\n            revert FluidLiquidityCalcsError(ErrorTypes.LiquidityCalcs__UnsupportedRateVersion);\\n        }\\n\\n        if (rate_ > X16) {\\n            // hard cap for borrow rate at maximum value 16 bits (65535) to make sure it does not overflow storage space.\\n            // this is unlikely to ever happen if configs stay within expected levels.\\n            rate_ = X16;\\n            // emit event to more easily become aware\\n            emit BorrowRateMaxCap();\\n        }\\n    }\\n\\n    /// @dev calculates the borrow rate based on utilization for rate data version 1 (with one kink) in 1e2 precision\\n    /// @param rateData_ rate data packed uint256 from storage for the token\\n    /// @param utilization_  in 1e2 (100% = 1e4)\\n    /// @return rate_ rate in 1e2 precision\\n    function calcRateV1(uint256 rateData_, uint256 utilization_) internal pure returns (uint256 rate_) {\\n        /// For rate v1 (one kink) ------------------------------------------------------\\n        /// Next 16  bits =>  4 - 19 => Rate at utilization 0% (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Next 16  bits =>  20- 35 => Utilization at kink1 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Next 16  bits =>  36- 51 => Rate at utilization kink1 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Next 16  bits =>  52- 67 => Rate at utilization 100% (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Last 188 bits =>  68-255 => blank, might come in use in future\\n\\n        // y = mx + c.\\n        // y is borrow rate\\n        // x is utilization\\n        // m = slope (m can be 0 but never negative)\\n        // c is constant (c can be negative)\\n\\n        uint256 y1_;\\n        uint256 y2_;\\n        uint256 x1_;\\n        uint256 x2_;\\n\\n        // extract kink1: 16 bits (0xFFFF) starting from bit 20\\n        // kink is in 1e2, same as utilization, so no conversion needed for direct comparison of the two\\n        uint256 kink1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_UTILIZATION_AT_KINK) & X16;\\n        if (utilization_ < kink1_) {\\n            // if utilization is less than kink\\n            y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_ZERO) & X16;\\n            y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_KINK) & X16;\\n            x1_ = 0; // 0%\\n            x2_ = kink1_;\\n        } else {\\n            // else utilization is greater than kink\\n            y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_KINK) & X16;\\n            y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_MAX) & X16;\\n            x1_ = kink1_;\\n            x2_ = FOUR_DECIMALS; // 100%\\n        }\\n\\n        int256 constant_;\\n        uint256 slope_;\\n        unchecked {\\n            // calculating slope with twelve decimal precision. m = (y2 - y1) / (x2 - x1).\\n            // utilization of x2 can not be <= utilization of x1 (so no underflow or 0 divisor) and rate at y2 can not be < rate at y1\\n            // y is in 1e2 so can not overflow when multiplied with TWELVE_DECIMALS\\n            slope_ = ((y2_ - y1_) * TWELVE_DECIMALS) / (x2_ - x1_);\\n\\n            // calculating constant at 12 decimal precision. slope is already in 12 decimal hence only multiple with y1. c = y - mx.\\n            // maximum y1_ value is 65535. 65535 * 1e12 can not overflow int256\\n            // maximum slope is 65535 - 0 * TWELVE_DECIMALS / 1 = 65535 * 1e12;\\n            // maximum x1_ is 100% (9_999 actually) => slope_ * x1_ can not overflow int256\\n            // subtraction most extreme case would be  0 - max value slope_ * x1_ => can not underflow int256\\n            constant_ = int256(y1_ * TWELVE_DECIMALS) - int256(slope_ * x1_);\\n\\n            // calculating new borrow rate\\n            // - slope_ max value is 65535 * 1e12,\\n            // - utilization max value is let's say 500% (extreme case where borrow rate increases borrow amount without new supply)\\n            // - constant max value is 65535 * 1e12\\n            // so max values are 65535 * 1e12 * 50_000 + 65535 * 1e12 -> 3.2768*10^21, which easily fits int256\\n            // divisor TWELVE_DECIMALS can not be 0\\n            rate_ = (uint256(int256(slope_ * utilization_) + constant_)) / TWELVE_DECIMALS;\\n        }\\n    }\\n\\n    /// @dev calculates the borrow rate based on utilization for rate data version 2 (with two kinks) in 1e4 precision\\n    /// @param rateData_ rate data packed uint256 from storage for the token\\n    /// @param utilization_  in 1e2 (100% = 1e4)\\n    /// @return rate_ rate in 1e4 precision\\n    function calcRateV2(uint256 rateData_, uint256 utilization_) internal pure returns (uint256 rate_) {\\n        /// For rate v2 (two kinks) -----------------------------------------------------\\n        /// Next 16  bits =>  4 - 19 => Rate at utilization 0% (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Next 16  bits =>  20- 35 => Utilization at kink1 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Next 16  bits =>  36- 51 => Rate at utilization kink1 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Next 16  bits =>  52- 67 => Utilization at kink2 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Next 16  bits =>  68- 83 => Rate at utilization kink2 (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Next 16  bits =>  84- 99 => Rate at utilization 100% (in 1e2: 100% = 10_000; 1% = 100 -> max value 65535)\\n        /// Last 156 bits => 100-255 => blank, might come in use in future\\n\\n        // y = mx + c.\\n        // y is borrow rate\\n        // x is utilization\\n        // m = slope (m can be 0 but never negative)\\n        // c is constant (c can be negative)\\n\\n        uint256 y1_;\\n        uint256 y2_;\\n        uint256 x1_;\\n        uint256 x2_;\\n\\n        // extract kink1: 16 bits (0xFFFF) starting from bit 20\\n        // kink is in 1e2, same as utilization, so no conversion needed for direct comparison of the two\\n        uint256 kink1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_UTILIZATION_AT_KINK1) & X16;\\n        if (utilization_ < kink1_) {\\n            // if utilization is less than kink1\\n            y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_ZERO) & X16;\\n            y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK1) & X16;\\n            x1_ = 0; // 0%\\n            x2_ = kink1_;\\n        } else {\\n            // extract kink2: 16 bits (0xFFFF) starting from bit 52\\n            uint256 kink2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_UTILIZATION_AT_KINK2) & X16;\\n            if (utilization_ < kink2_) {\\n                // if utilization is less than kink2\\n                y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK1) & X16;\\n                y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK2) & X16;\\n                x1_ = kink1_;\\n                x2_ = kink2_;\\n            } else {\\n                // else utilization is greater than kink2\\n                y1_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK2) & X16;\\n                y2_ = (rateData_ >> LiquiditySlotsLink.BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_MAX) & X16;\\n                x1_ = kink2_;\\n                x2_ = FOUR_DECIMALS;\\n            }\\n        }\\n\\n        int256 constant_;\\n        uint256 slope_;\\n        unchecked {\\n            // calculating slope with twelve decimal precision. m = (y2 - y1) / (x2 - x1).\\n            // utilization of x2 can not be <= utilization of x1 (so no underflow or 0 divisor) and rate at y2 can not be < rate at y1\\n            // y is in 1e2 so can not overflow when multiplied with TWELVE_DECIMALS\\n            slope_ = ((y2_ - y1_) * TWELVE_DECIMALS) / (x2_ - x1_);\\n\\n            // calculating constant at 12 decimal precision. slope is already in 12 decimal hence only multiple with y1. c = y - mx.\\n            // maximum y1_ value is 65535. 65535 * 1e12 can not overflow int256\\n            // maximum slope is 65535 - 0 * TWELVE_DECIMALS / 1 = 65535 * 1e12;\\n            // maximum x1_ is 100% (9_999 actually) => slope_ * x1_ can not overflow int256\\n            // subtraction most extreme case would be  0 - max value slope_ * x1_ => can not underflow int256\\n            constant_ = int256(y1_ * TWELVE_DECIMALS) - int256(slope_ * x1_);\\n\\n            // calculating new borrow rate\\n            // - slope_ max value is 65535 * 1e12,\\n            // - utilization max value is let's say 500% (extreme case where borrow rate increases borrow amount without new supply)\\n            // - constant max value is 65535 * 1e12\\n            // so max values are 65535 * 1e12 * 50_000 + 65535 * 1e12 -> 3.2768*10^21, which easily fits int256\\n            // divisor TWELVE_DECIMALS can not be 0\\n            rate_ = (uint256(int256(slope_ * utilization_) + constant_)) / TWELVE_DECIMALS;\\n        }\\n    }\\n\\n    /// @dev reads the total supply out of Liquidity packed storage `totalAmounts_` for `supplyExchangePrice_`\\n    function getTotalSupply(\\n        uint256 totalAmounts_,\\n        uint256 supplyExchangePrice_\\n    ) internal pure returns (uint256 totalSupply_) {\\n        // totalSupply_ => supplyInterestFree\\n        totalSupply_ = (totalAmounts_ >> LiquiditySlotsLink.BITS_TOTAL_AMOUNTS_SUPPLY_INTEREST_FREE) & X64;\\n        totalSupply_ = (totalSupply_ >> DEFAULT_EXPONENT_SIZE) << (totalSupply_ & DEFAULT_EXPONENT_MASK);\\n\\n        uint256 totalSupplyRaw_ = totalAmounts_ & X64; // no shifting as supplyRaw is first 64 bits\\n        totalSupplyRaw_ = (totalSupplyRaw_ >> DEFAULT_EXPONENT_SIZE) << (totalSupplyRaw_ & DEFAULT_EXPONENT_MASK);\\n\\n        // totalSupply = supplyInterestFree + supplyRawInterest normalized from raw\\n        totalSupply_ += ((totalSupplyRaw_ * supplyExchangePrice_) / EXCHANGE_PRICES_PRECISION);\\n    }\\n\\n    /// @dev reads the total borrow out of Liquidity packed storage `totalAmounts_` for `borrowExchangePrice_`\\n    function getTotalBorrow(\\n        uint256 totalAmounts_,\\n        uint256 borrowExchangePrice_\\n    ) internal pure returns (uint256 totalBorrow_) {\\n        // totalBorrow_ => borrowInterestFree\\n        // no & mask needed for borrow interest free as it occupies the last bits in the storage slot\\n        totalBorrow_ = (totalAmounts_ >> LiquiditySlotsLink.BITS_TOTAL_AMOUNTS_BORROW_INTEREST_FREE);\\n        totalBorrow_ = (totalBorrow_ >> DEFAULT_EXPONENT_SIZE) << (totalBorrow_ & DEFAULT_EXPONENT_MASK);\\n\\n        uint256 totalBorrowRaw_ = (totalAmounts_ >> LiquiditySlotsLink.BITS_TOTAL_AMOUNTS_BORROW_WITH_INTEREST) & X64;\\n        totalBorrowRaw_ = (totalBorrowRaw_ >> DEFAULT_EXPONENT_SIZE) << (totalBorrowRaw_ & DEFAULT_EXPONENT_MASK);\\n\\n        // totalBorrow = borrowInterestFree + borrowRawInterest normalized from raw\\n        totalBorrow_ += ((totalBorrowRaw_ * borrowExchangePrice_) / EXCHANGE_PRICES_PRECISION);\\n    }\\n}\\n\",\"keccak256\":\"0x1abba442b74ee50d039a5491aae9e7a156a62f783363ce545e44ee82cc699f27\",\"license\":\"BUSL-1.1\"},\"contracts/libraries/liquiditySlotsLink.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\n/// @notice library that helps in reading / working with storage slot data of Fluid Liquidity.\\n/// @dev as all data for Fluid Liquidity is internal, any data must be fetched directly through manual\\n/// slot reading through this library or, if gas usage is less important, through the FluidLiquidityResolver.\\nlibrary LiquiditySlotsLink {\\n    /// @dev storage slot for status at Liquidity\\n    uint256 internal constant LIQUIDITY_STATUS_SLOT = 1;\\n    /// @dev storage slot for auths mapping at Liquidity\\n    uint256 internal constant LIQUIDITY_AUTHS_MAPPING_SLOT = 2;\\n    /// @dev storage slot for guardians mapping at Liquidity\\n    uint256 internal constant LIQUIDITY_GUARDIANS_MAPPING_SLOT = 3;\\n    /// @dev storage slot for user class mapping at Liquidity\\n    uint256 internal constant LIQUIDITY_USER_CLASS_MAPPING_SLOT = 4;\\n    /// @dev storage slot for exchangePricesAndConfig mapping at Liquidity\\n    uint256 internal constant LIQUIDITY_EXCHANGE_PRICES_MAPPING_SLOT = 5;\\n    /// @dev storage slot for rateData mapping at Liquidity\\n    uint256 internal constant LIQUIDITY_RATE_DATA_MAPPING_SLOT = 6;\\n    /// @dev storage slot for totalAmounts mapping at Liquidity\\n    uint256 internal constant LIQUIDITY_TOTAL_AMOUNTS_MAPPING_SLOT = 7;\\n    /// @dev storage slot for user supply double mapping at Liquidity\\n    uint256 internal constant LIQUIDITY_USER_SUPPLY_DOUBLE_MAPPING_SLOT = 8;\\n    /// @dev storage slot for user borrow double mapping at Liquidity\\n    uint256 internal constant LIQUIDITY_USER_BORROW_DOUBLE_MAPPING_SLOT = 9;\\n    /// @dev storage slot for listed tokens array at Liquidity\\n    uint256 internal constant LIQUIDITY_LISTED_TOKENS_ARRAY_SLOT = 10;\\n\\n    // --------------------------------\\n    // @dev stacked uint256 storage slots bits position data for each:\\n\\n    // ExchangePricesAndConfig\\n    uint256 internal constant BITS_EXCHANGE_PRICES_BORROW_RATE = 0;\\n    uint256 internal constant BITS_EXCHANGE_PRICES_FEE = 16;\\n    uint256 internal constant BITS_EXCHANGE_PRICES_UTILIZATION = 30;\\n    uint256 internal constant BITS_EXCHANGE_PRICES_UPDATE_THRESHOLD = 44;\\n    uint256 internal constant BITS_EXCHANGE_PRICES_LAST_TIMESTAMP = 58;\\n    uint256 internal constant BITS_EXCHANGE_PRICES_SUPPLY_EXCHANGE_PRICE = 91;\\n    uint256 internal constant BITS_EXCHANGE_PRICES_BORROW_EXCHANGE_PRICE = 155;\\n    uint256 internal constant BITS_EXCHANGE_PRICES_SUPPLY_RATIO = 219;\\n    uint256 internal constant BITS_EXCHANGE_PRICES_BORROW_RATIO = 234;\\n\\n    // RateData:\\n    uint256 internal constant BITS_RATE_DATA_VERSION = 0;\\n    // RateData: V1\\n    uint256 internal constant BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_ZERO = 4;\\n    uint256 internal constant BITS_RATE_DATA_V1_UTILIZATION_AT_KINK = 20;\\n    uint256 internal constant BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_KINK = 36;\\n    uint256 internal constant BITS_RATE_DATA_V1_RATE_AT_UTILIZATION_MAX = 52;\\n    // RateData: V2\\n    uint256 internal constant BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_ZERO = 4;\\n    uint256 internal constant BITS_RATE_DATA_V2_UTILIZATION_AT_KINK1 = 20;\\n    uint256 internal constant BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK1 = 36;\\n    uint256 internal constant BITS_RATE_DATA_V2_UTILIZATION_AT_KINK2 = 52;\\n    uint256 internal constant BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_KINK2 = 68;\\n    uint256 internal constant BITS_RATE_DATA_V2_RATE_AT_UTILIZATION_MAX = 84;\\n\\n    // TotalAmounts\\n    uint256 internal constant BITS_TOTAL_AMOUNTS_SUPPLY_WITH_INTEREST = 0;\\n    uint256 internal constant BITS_TOTAL_AMOUNTS_SUPPLY_INTEREST_FREE = 64;\\n    uint256 internal constant BITS_TOTAL_AMOUNTS_BORROW_WITH_INTEREST = 128;\\n    uint256 internal constant BITS_TOTAL_AMOUNTS_BORROW_INTEREST_FREE = 192;\\n\\n    // UserSupplyData\\n    uint256 internal constant BITS_USER_SUPPLY_MODE = 0;\\n    uint256 internal constant BITS_USER_SUPPLY_AMOUNT = 1;\\n    uint256 internal constant BITS_USER_SUPPLY_PREVIOUS_WITHDRAWAL_LIMIT = 65;\\n    uint256 internal constant BITS_USER_SUPPLY_LAST_UPDATE_TIMESTAMP = 129;\\n    uint256 internal constant BITS_USER_SUPPLY_EXPAND_PERCENT = 162;\\n    uint256 internal constant BITS_USER_SUPPLY_EXPAND_DURATION = 176;\\n    uint256 internal constant BITS_USER_SUPPLY_BASE_WITHDRAWAL_LIMIT = 200;\\n    uint256 internal constant BITS_USER_SUPPLY_IS_PAUSED = 255;\\n\\n    // UserBorrowData\\n    uint256 internal constant BITS_USER_BORROW_MODE = 0;\\n    uint256 internal constant BITS_USER_BORROW_AMOUNT = 1;\\n    uint256 internal constant BITS_USER_BORROW_PREVIOUS_BORROW_LIMIT = 65;\\n    uint256 internal constant BITS_USER_BORROW_LAST_UPDATE_TIMESTAMP = 129;\\n    uint256 internal constant BITS_USER_BORROW_EXPAND_PERCENT = 162;\\n    uint256 internal constant BITS_USER_BORROW_EXPAND_DURATION = 176;\\n    uint256 internal constant BITS_USER_BORROW_BASE_BORROW_LIMIT = 200;\\n    uint256 internal constant BITS_USER_BORROW_MAX_BORROW_LIMIT = 218;\\n    uint256 internal constant BITS_USER_BORROW_IS_PAUSED = 255;\\n\\n    // --------------------------------\\n\\n    /// @notice Calculating the slot ID for Liquidity contract for single mapping at `slot_` for `key_`\\n    function calculateMappingStorageSlot(uint256 slot_, address key_) internal pure returns (bytes32) {\\n        return keccak256(abi.encode(key_, slot_));\\n    }\\n\\n    /// @notice Calculating the slot ID for Liquidity contract for double mapping at `slot_` for `key1_` and `key2_`\\n    function calculateDoubleMappingStorageSlot(\\n        uint256 slot_,\\n        address key1_,\\n        address key2_\\n    ) internal pure returns (bytes32) {\\n        bytes32 intermediateSlot_ = keccak256(abi.encode(key1_, slot_));\\n        return keccak256(abi.encode(key2_, intermediateSlot_));\\n    }\\n}\\n\",\"keccak256\":\"0x85725ce90bbeb00541715fe58fb213b96706515e9eafdae357657995e9ac147d\",\"license\":\"BUSL-1.1\"},\"contracts/liquidity/adminModule/structs.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\nabstract contract Structs {\\n    struct AddressBool {\\n        address addr;\\n        bool value;\\n    }\\n\\n    struct AddressUint256 {\\n        address addr;\\n        uint256 value;\\n    }\\n\\n    /// @notice struct to set borrow rate data for version 1\\n    struct RateDataV1Params {\\n        ///\\n        /// @param token for rate data\\n        address token;\\n        ///\\n        /// @param kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\\n        /// utilization below kink usually means slow increase in rate, once utilization is above kink borrow rate increases fast\\n        uint256 kink;\\n        ///\\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\\n        /// i.e. constant minimum borrow rate\\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\\n        uint256 rateAtUtilizationZero;\\n        ///\\n        /// @param rateAtUtilizationKink borrow rate when utilization is at kink. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 7% at kink then rateAtUtilizationKink would be 700\\n        uint256 rateAtUtilizationKink;\\n        ///\\n        /// @param rateAtUtilizationMax borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\\n        uint256 rateAtUtilizationMax;\\n    }\\n\\n    /// @notice struct to set borrow rate data for version 2\\n    struct RateDataV2Params {\\n        ///\\n        /// @param token for rate data\\n        address token;\\n        ///\\n        /// @param kink1 first kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\\n        /// utilization below kink 1 usually means slow increase in rate, once utilization is above kink 1 borrow rate increases faster\\n        uint256 kink1;\\n        ///\\n        /// @param kink2 second kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\\n        /// utilization below kink 2 usually means slow / medium increase in rate, once utilization is above kink 2 borrow rate increases fast\\n        uint256 kink2;\\n        ///\\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\\n        /// i.e. constant minimum borrow rate\\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\\n        uint256 rateAtUtilizationZero;\\n        ///\\n        /// @param rateAtUtilizationKink1 desired borrow rate when utilization is at first kink. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 7% at first kink then rateAtUtilizationKink would be 700\\n        uint256 rateAtUtilizationKink1;\\n        ///\\n        /// @param rateAtUtilizationKink2 desired borrow rate when utilization is at second kink. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 7% at second kink then rateAtUtilizationKink would be 1_200\\n        uint256 rateAtUtilizationKink2;\\n        ///\\n        /// @param rateAtUtilizationMax desired borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\\n        uint256 rateAtUtilizationMax;\\n    }\\n\\n    /// @notice struct to set token config\\n    struct TokenConfig {\\n        ///\\n        /// @param token address\\n        address token;\\n        ///\\n        /// @param fee charges on borrower's interest. in 1e2: 100% = 10_000; 1% = 100\\n        uint256 fee;\\n        ///\\n        /// @param threshold on when to update the storage slot. in 1e2: 100% = 10_000; 1% = 100\\n        uint256 threshold;\\n    }\\n\\n    /// @notice struct to set user supply & withdrawal config\\n    struct UserSupplyConfig {\\n        ///\\n        /// @param user address\\n        address user;\\n        ///\\n        /// @param token address\\n        address token;\\n        ///\\n        /// @param mode: 0 = without interest. 1 = with interest\\n        uint8 mode;\\n        ///\\n        /// @param expandPercent withdrawal limit expand percent. in 1e2: 100% = 10_000; 1% = 100\\n        /// Also used to calculate rate at which withdrawal limit should decrease (instant).\\n        uint256 expandPercent;\\n        ///\\n        /// @param expandDuration withdrawal limit expand duration in seconds.\\n        /// used to calculate rate together with expandPercent\\n        uint256 expandDuration;\\n        ///\\n        /// @param baseWithdrawalLimit base limit, below this, user can withdraw the entire amount.\\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\\n        /// with interest -> raw, without interest -> normal\\n        uint256 baseWithdrawalLimit;\\n    }\\n\\n    /// @notice struct to set user borrow & payback config\\n    struct UserBorrowConfig {\\n        ///\\n        /// @param user address\\n        address user;\\n        ///\\n        /// @param token address\\n        address token;\\n        ///\\n        /// @param mode: 0 = without interest. 1 = with interest\\n        uint8 mode;\\n        ///\\n        /// @param expandPercent debt limit expand percent. in 1e2: 100% = 10_000; 1% = 100\\n        /// Also used to calculate rate at which debt limit should decrease (instant).\\n        uint256 expandPercent;\\n        ///\\n        /// @param expandDuration debt limit expand duration in seconds.\\n        /// used to calculate rate together with expandPercent\\n        uint256 expandDuration;\\n        ///\\n        /// @param baseDebtCeiling base borrow limit. until here, borrow limit remains as baseDebtCeiling\\n        /// (user can borrow until this point at once without stepped expansion). Above this, automated limit comes in place.\\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\\n        /// with interest -> raw, without interest -> normal\\n        uint256 baseDebtCeiling;\\n        ///\\n        /// @param maxDebtCeiling max borrow ceiling, maximum amount the user can borrow.\\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\\n        /// with interest -> raw, without interest -> normal\\n        uint256 maxDebtCeiling;\\n    }\\n}\\n\",\"keccak256\":\"0xcacc14afd7880d3179d0089d65dad6714c377df4801a9ad79a499d0d079124c0\",\"license\":\"BUSL-1.1\"},\"contracts/liquidity/interfaces/iLiquidity.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity 0.8.21;\\n\\nimport { IProxy } from \\\"../../infiniteProxy/interfaces/iProxy.sol\\\";\\nimport { Structs as AdminModuleStructs } from \\\"../adminModule/structs.sol\\\";\\n\\ninterface IFluidLiquidityAdmin {\\n    /// @notice adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract.\\n    ///         auths can be helpful in reducing governance overhead where it's not needed.\\n    /// @param authsStatus_ array of structs setting allowed status for an address.\\n    ///                     status true => add auth, false => remove auth\\n    function updateAuths(AdminModuleStructs.AddressBool[] calldata authsStatus_) external;\\n\\n    /// @notice adds/removes guardians. Only callable by Governance.\\n    /// @param guardiansStatus_ array of structs setting allowed status for an address.\\n    ///                         status true => add guardian, false => remove guardian\\n    function updateGuardians(AdminModuleStructs.AddressBool[] calldata guardiansStatus_) external;\\n\\n    /// @notice changes the revenue collector address (contract that is sent revenue). Only callable by Governance.\\n    /// @param revenueCollector_  new revenue collector address\\n    function updateRevenueCollector(address revenueCollector_) external;\\n\\n    /// @notice changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths.\\n    /// @param newStatus_ new status\\n    ///        status = 2 -> pause, status = 1 -> resume.\\n    function changeStatus(uint256 newStatus_) external;\\n\\n    /// @notice                  update tokens rate data version 1. Only callable by Auths.\\n    /// @param tokensRateData_   array of RateDataV1Params with rate data to set for each token\\n    function updateRateDataV1s(AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_) external;\\n\\n    /// @notice                  update tokens rate data version 2. Only callable by Auths.\\n    /// @param tokensRateData_   array of RateDataV2Params with rate data to set for each token\\n    function updateRateDataV2s(AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_) external;\\n\\n    /// @notice updates token configs: fee charge on borrowers interest & storage update utilization threshold.\\n    ///         Only callable by Auths.\\n    /// @param tokenConfigs_ contains token address, fee & utilization threshold\\n    function updateTokenConfigs(AdminModuleStructs.TokenConfig[] calldata tokenConfigs_) external;\\n\\n    /// @notice updates user classes: 0 is for new protocols, 1 is for established protocols.\\n    ///         Only callable by Auths.\\n    /// @param userClasses_ struct array of uint256 value to assign for each user address\\n    function updateUserClasses(AdminModuleStructs.AddressUint256[] calldata userClasses_) external;\\n\\n    /// @notice sets user supply configs per token basis. Eg: with interest or interest-free and automated limits.\\n    ///         Only callable by Auths.\\n    /// @param userSupplyConfigs_ struct array containing user supply config, see `UserSupplyConfig` struct for more info\\n    function updateUserSupplyConfigs(AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_) external;\\n\\n    /// @notice setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits.\\n    ///         Only callable by Auths.\\n    /// @param userBorrowConfigs_ struct array containing user borrow config, see `UserBorrowConfig` struct for more info\\n    function updateUserBorrowConfigs(AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_) external;\\n\\n    /// @notice pause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\\n    /// Only callable by Guardians.\\n    /// @param user_          address of user to pause operations for\\n    /// @param supplyTokens_  token addresses to pause withdrawals for\\n    /// @param borrowTokens_  token addresses to pause borrowings for\\n    function pauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\\n\\n    /// @notice unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\\n    /// Only callable by Guardians.\\n    /// @param user_          address of user to unpause operations for\\n    /// @param supplyTokens_  token addresses to unpause withdrawals for\\n    /// @param borrowTokens_  token addresses to unpause borrowings for\\n    function unpauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\\n\\n    /// @notice         collects revenue for tokens to configured revenueCollector address.\\n    /// @param tokens_  array of tokens to collect revenue for\\n    /// @dev            Note that this can revert if token balance is < revenueAmount (utilization > 100%)\\n    function collectRevenue(address[] calldata tokens_) external;\\n\\n    /// @notice gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage.\\n    /// @param tokens_ tokens to update exchange prices for\\n    /// @return supplyExchangePrices_ new supply rates of overall system for each token\\n    /// @return borrowExchangePrices_ new borrow rates of overall system for each token\\n    function updateExchangePrices(\\n        address[] calldata tokens_\\n    ) external returns (uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_);\\n}\\n\\ninterface IFluidLiquidityLogic is IFluidLiquidityAdmin {\\n    /// @notice Single function which handles supply, withdraw, borrow & payback\\n    /// @param token_ address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\\n    /// @param supplyAmount_ if +ve then supply, if -ve then withdraw, if 0 then nothing\\n    /// @param borrowAmount_ if +ve then borrow, if -ve then payback, if 0 then nothing\\n    /// @param withdrawTo_ if withdrawal then to which address\\n    /// @param borrowTo_ if borrow then to which address\\n    /// @param callbackData_ callback data passed to `liquidityCallback` method of protocol\\n    /// @return memVar3_ updated supplyExchangePrice\\n    /// @return memVar4_ updated borrowExchangePrice\\n    /// @dev to trigger skipping in / out transfers when in&out amounts balance themselves out (gas optimization):\\n    /// -   supply(+) == borrow(+), withdraw(-) == payback(-).\\n    /// -   `withdrawTo_` / `borrowTo_` must be msg.sender (protocol)\\n    /// -   `callbackData_` MUST be encoded so that \\\"from\\\" address is at last 20 bytes (if this optimization is desired),\\n    ///     also for native token operations where liquidityCallback is not triggered!\\n    ///     from address must come at last position if there is more data. I.e. encode like:\\n    ///     abi.encode(otherVar1, otherVar2, FROM_ADDRESS). Note dynamic types used with abi.encode come at the end\\n    ///     so if dynamic types are needed, you must use abi.encodePacked to ensure the from address is at the end.\\n    function operate(\\n        address token_,\\n        int256 supplyAmount_,\\n        int256 borrowAmount_,\\n        address withdrawTo_,\\n        address borrowTo_,\\n        bytes calldata callbackData_\\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_);\\n}\\n\\ninterface IFluidLiquidity is IProxy, IFluidLiquidityLogic {}\\n\",\"keccak256\":\"0xc81ac0cfc8183ec57ec4e488b07a4f6d1ecd79787e0aaf0dcfdd0b9b7ac0fc84\",\"license\":\"MIT\"},\"contracts/protocols/steth/error.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\ncontract Error {\\n    /// @notice general Custom error used for all contract specific errors with the `errorId_` param as error code.\\n    /// Look up the specific error code in the source code to find a better explanation of what went wrong (errors.sol).\\n    error StETHQueueError(uint256 errorId_);\\n}\\n\",\"keccak256\":\"0x78b773055eb9da99d4ee18edbddac872ddbcf72c083f5e794f857df440b9bad8\",\"license\":\"BUSL-1.1\"},\"contracts/protocols/steth/errorTypes.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\nlibrary ErrorTypes {\\n    /***********************************|\\n    |               StETH               | \\n    |__________________________________*/\\n\\n    /// @notice thrown when maxLTV precent amount is set to 0\\n    uint256 internal constant StETH__MaxLTVZero = 40001;\\n\\n    /// @notice thrown when the borrow ETH amount to StETH collateral ratio is bigger than the configured `maxLTV`\\n    uint256 internal constant StETH__MaxLTV = 40002;\\n\\n    /// @notice thrown when an ERC721 other than a Lido Withdrawal NFT is transferred to this contract\\n    uint256 internal constant StETH__InvalidERC721Transfer = 40003;\\n\\n    /// @notice thrown when an input amount (ethBorrowAmount or stETHAmount) is zero\\n    uint256 internal constant StETH__InputAmountZero = 40004;\\n\\n    /// @notice thrown when `liquidityCallback` is called, as this protocol only uses native token as borrow asset\\n    uint256 internal constant StETH__UnexpectedLiquidityCallback = 40005;\\n\\n    /// @notice thrown when there is no claim queued for a claim owner\\n    uint256 internal constant StETH__NoClaimQueued = 40006;\\n\\n    /// @notice thrown when an unauthorized `msg.sender` calls a protected method\\n    uint256 internal constant StETH__Unauthorized = 40007;\\n\\n    /// @notice thrown when the borrowAmountRaw is rounded to zero because of the exchange price\\n    uint256 internal constant StETH__BorrowAmountRawRoundingZero = 40008;\\n\\n    /// @notice thrown when an input address is zero\\n    uint256 internal constant StETH__AddressZero = 40009;\\n\\n    /// @notice thrown when a reentrancy happens\\n    uint256 internal constant StETH__Reentrancy = 40010;\\n\\n    /// @notice thrown when maxLTV precent amount is set to >= 100%\\n    uint256 internal constant StETH__MaxLTVAboveCap = 40011;\\n\\n    /// @notice thrown when renounceOwnership is called\\n    uint256 internal constant StETH__RenounceOwnershipUnsupported = 40012;\\n}\\n\",\"keccak256\":\"0x6911b3183abe64eca317bb68d03b2c777f6a50a9a25193eb0bd24bd1e8eae4b6\",\"license\":\"BUSL-1.1\"},\"contracts/protocols/steth/events.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\nabstract contract Events {\\n    /// @notice emitted whenever `maxLTV` is updated\\n    event LogSetMaxLTV(uint256 maxLTV);\\n\\n    /// @notice emitted when a queue() process is executed\\n    event LogQueue(\\n        address indexed claimTo,\\n        uint256 requestIdFrom,\\n        uint256 borrowETHAmount,\\n        uint256 queueStETHAmount,\\n        address borrowTo\\n    );\\n\\n    /// @notice emitted when a claim() process is executed\\n    event LogClaim(address indexed claimTo, uint256 requestIdFrom, uint256 claimedAmount, uint256 repayAmount);\\n\\n    /// @notice emitted when an auth is modified by owner\\n    event LogSetAuth(address indexed auth, bool allowed);\\n\\n    /// @notice emitted when a guardian is modified by owner\\n    event LogSetGuardian(address indexed guardian, bool allowed);\\n\\n    /// @notice emitted when an allowed user is modified by auths\\n    event LogSetAllowed(address indexed user, bool allowed);\\n\\n    /// @notice emitted when `allowListActive` status is updated\\n    event LogSetAllowListActive(bool active);\\n\\n    /// @notice emitted when protocol is paused by guardian\\n    event LogPaused();\\n\\n    /// @notice emitted when protocol is unpaused by owner\\n    event LogUnpaused();\\n}\\n\",\"keccak256\":\"0x04839996a1afb276212ee8202354d1578b5b20b98ebc04440ad7a37b1645fa26\",\"license\":\"BUSL-1.1\"},\"contracts/protocols/steth/interfaces/external/iLidoWithdrawalQueue.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity 0.8.21;\\n\\ninterface ILidoWithdrawalQueue {\\n    function balanceOf(address) external view returns (uint);\\n\\n    /**\\n     * @dev Returns the owner of the `tokenId` token.\\n     *\\n     * Requirements:\\n     *\\n     * - `tokenId` must exist.\\n     */\\n    function ownerOf(uint256 tokenId) external view returns (address owner);\\n\\n    // code below based on Lido WithdrawalQueueBase.sol\\n    // see https://github.com/lidofinance/lido-dao/blob/v2.0.0/contracts/0.8.9/WithdrawalQueueBase.sol\\n\\n    /// @notice output format struct for `_getWithdrawalStatus()` method\\n    struct WithdrawalRequestStatus {\\n        /// @notice stETH token amount that was locked on withdrawal queue for this request\\n        uint256 amountOfStETH;\\n        /// @notice amount of stETH shares locked on withdrawal queue for this request\\n        uint256 amountOfShares;\\n        /// @notice address that can claim or transfer this request\\n        address owner;\\n        /// @notice timestamp of when the request was created, in seconds\\n        uint256 timestamp;\\n        /// @notice true, if request is finalized\\n        bool isFinalized;\\n        /// @notice true, if request is claimed. Request is claimable if (isFinalized && !isClaimed)\\n        bool isClaimed;\\n    }\\n\\n    /// @notice length of the checkpoint array. Last possible value for the hint.\\n    ///  NB! checkpoints are indexed from 1, so it returns 0 if there is no checkpoints\\n    function getLastCheckpointIndex() external view returns (uint256);\\n\\n    // code below based on Lido WithdrawalQueue.sol\\n    // see https://github.com/lidofinance/lido-dao/blob/v2.0.0/contracts/0.8.9/WithdrawalQueue.sol\\n\\n    /// @notice Request the batch of stETH for withdrawal. Approvals for the passed amounts should be done before.\\n    /// @param _amounts an array of stETH amount values.\\n    ///  The standalone withdrawal request will be created for each item in the passed list.\\n    /// @param _owner address that will be able to manage the created requests.\\n    ///  If `address(0)` is passed, `msg.sender` will be used as owner.\\n    /// @return requestIds an array of the created withdrawal request ids\\n    function requestWithdrawals(\\n        uint256[] calldata _amounts,\\n        address _owner\\n    ) external returns (uint256[] memory requestIds);\\n\\n    /// @notice Claim one`_requestId` request once finalized sending locked ether to the owner\\n    /// @param _requestId request id to claim\\n    /// @dev use unbounded loop to find a hint, which can lead to OOG\\n    /// @dev\\n    ///  Reverts if requestId or hint are not valid\\n    ///  Reverts if request is not finalized or already claimed\\n    ///  Reverts if msg sender is not an owner of request\\n    function claimWithdrawal(uint256 _requestId) external;\\n\\n    /// @notice Claim a batch of withdrawal requests if they are finalized sending locked ether to the owner\\n    /// @param _requestIds array of request ids to claim\\n    /// @param _hints checkpoint hint for each id. Can be obtained with `findCheckpointHints()`\\n    /// @dev\\n    ///  Reverts if requestIds and hints arrays length differs\\n    ///  Reverts if any requestId or hint in arguments are not valid\\n    ///  Reverts if any request is not finalized or already claimed\\n    ///  Reverts if msg sender is not an owner of the requests\\n    function claimWithdrawals(uint256[] calldata _requestIds, uint256[] calldata _hints) external;\\n\\n    //// @notice Returns all withdrawal requests that belongs to the `_owner` address\\n    ///\\n    /// WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\\n    /// to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\\n    /// this function has an unbounded cost, and using it as part of a state-changing function may render the function\\n    /// uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\\n    function getWithdrawalRequests(address _owner) external view returns (uint256[] memory requestsIds);\\n\\n    /// @notice Finds the list of hints for the given `_requestIds` searching among the checkpoints with indices\\n    ///  in the range  `[_firstIndex, _lastIndex]`.\\n    ///  NB! Array of request ids should be sorted\\n    ///  NB! `_firstIndex` should be greater than 0, because checkpoint list is 1-based array\\n    ///  Usage: findCheckpointHints(_requestIds, 1, getLastCheckpointIndex())\\n    /// @param _requestIds ids of the requests sorted in the ascending order to get hints for\\n    /// @param _firstIndex left boundary of the search range. Should be greater than 0\\n    /// @param _lastIndex right boundary of the search range. Should be less than or equal to getLastCheckpointIndex()\\n    /// @return hintIds array of hints used to find required checkpoint for the request\\n    function findCheckpointHints(\\n        uint256[] calldata _requestIds,\\n        uint256 _firstIndex,\\n        uint256 _lastIndex\\n    ) external view returns (uint256[] memory hintIds);\\n\\n    /// @notice Returns status for requests with provided ids\\n    /// @param _requestIds array of withdrawal request ids\\n    function getWithdrawalStatus(\\n        uint256[] calldata _requestIds\\n    ) external view returns (WithdrawalRequestStatus[] memory statuses);\\n\\n    /// @notice maximum amount of stETH that is possible to withdraw by a single request\\n    /// Prevents accumulating too much funds per single request fulfillment in the future.\\n    /// @dev To withdraw larger amounts, it's recommended to split it to several requests\\n    function MAX_STETH_WITHDRAWAL_AMOUNT() external view returns (uint256);\\n\\n    /// @notice minimum amount of stETH that is possible to withdraw by a single request\\n    function MIN_STETH_WITHDRAWAL_AMOUNT() external view returns (uint256);\\n\\n    // code below based on Lido WithdrawalQueueERC721.sol\\n    // see https://github.com/lidofinance/lido-dao/blob/v2.0.0/contracts/0.8.9/WithdrawalQueueERC721.sol\\n\\n    /// @notice Finalize requests from last finalized one up to `_lastRequestIdToBeFinalized`\\n    /// @dev ether to finalize all the requests should be calculated using `prefinalize()` and sent along\\n    function finalize(uint256 _lastRequestIdToBeFinalized, uint256 _maxShareRate) external payable;\\n}\\n\",\"keccak256\":\"0x9e1912b988a0076746564086faf9ebfb604a2acb7ebeb5ee28e8e72dd330ae63\",\"license\":\"MIT\"},\"contracts/protocols/steth/main.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Address } from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport { UUPSUpgradeable } from \\\"@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol\\\";\\n\\nimport { LiquiditySlotsLink } from \\\"../../libraries/liquiditySlotsLink.sol\\\";\\nimport { ILidoWithdrawalQueue } from \\\"./interfaces/external/iLidoWithdrawalQueue.sol\\\";\\nimport { IFluidLiquidity } from \\\"../../liquidity/interfaces/iLiquidity.sol\\\";\\nimport { ErrorTypes } from \\\"./errorTypes.sol\\\";\\nimport { Error } from \\\"./error.sol\\\";\\nimport { Events } from \\\"./events.sol\\\";\\nimport { Variables } from \\\"./variables.sol\\\";\\nimport { LiquidityCalcs } from \\\"../../libraries/liquidityCalcs.sol\\\";\\n\\nabstract contract StETHQueueCore is Variables, Events, Error {\\n    /// @dev validates that an address is not the zero address\\n    modifier validAddress(address value_) {\\n        if (value_ == address(0)) {\\n            revert StETHQueueError(ErrorTypes.StETH__AddressZero);\\n        }\\n        _;\\n    }\\n\\n    /// @dev reads the current, updated borrow exchange price for Native ETH at Liquidity\\n    function _getLiquidityExchangePrice() internal view returns (uint256 borrowExchangePrice_) {\\n        (, borrowExchangePrice_) = LiquidityCalcs.calcExchangePrices(\\n            LIQUIDITY.readFromStorage(LIQUIDITY_EXCHANGE_PRICES_SLOT)\\n        );\\n    }\\n}\\n\\n/// @dev ReentrancyGuard based on OpenZeppelin implementation.\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.8/contracts/security/ReentrancyGuard.sol\\nabstract contract ReentrancyGuard is StETHQueueCore {\\n    uint8 internal constant REENTRANCY_NOT_ENTERED = 1;\\n    uint8 internal constant REENTRANCY_ENTERED = 2;\\n\\n    constructor() {\\n        _status = REENTRANCY_ENTERED; // set status to entered on logic contract so only delegateCalls are possible\\n    }\\n\\n    /// @dev Prevents a contract from calling itself, directly or indirectly.\\n    /// See OpenZeppelin implementation for more info\\n    modifier nonReentrant() {\\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\\n        if (_status != REENTRANCY_NOT_ENTERED) {\\n            revert StETHQueueError(ErrorTypes.StETH__Reentrancy);\\n        }\\n\\n        // Any calls to nonReentrant after this point will fail\\n        _status = REENTRANCY_ENTERED;\\n\\n        _;\\n\\n        // By storing the original value once again, a refund is triggered (see\\n        // https://eips.ethereum.org/EIPS/eip-2200)\\n        _status = REENTRANCY_NOT_ENTERED;\\n    }\\n}\\n\\n/// @dev FluidStETHQueue admin related methods\\nabstract contract StETHQueueAdmin is Variables, ReentrancyGuard {\\n    /// @dev only auths guard\\n    modifier onlyAuths() {\\n        if (!isAuth(msg.sender)) {\\n            revert StETHQueueError(ErrorTypes.StETH__Unauthorized);\\n        }\\n        _;\\n    }\\n\\n    /// @notice reads if a certain `auth_` address is an allowed auth or not\\n    function isAuth(address auth_) public view returns (bool) {\\n        return auth_ == owner() || _auths[auth_] == 1;\\n    }\\n\\n    /// @notice reads if a certain `guardian_` address is an allowed guardian or not\\n    function isGuardian(address guardian_) public view returns (bool) {\\n        return guardian_ == owner() || _guardians[guardian_] == 1;\\n    }\\n\\n    /// @notice reads if a certain `user_` address is an allowed user or not\\n    function isUserAllowed(address user_) public view returns (bool) {\\n        return _allowed[user_] == 1;\\n    }\\n\\n    /// @notice reads if the protocol is paused or not\\n    function isPaused() public view returns (bool){\\n        return _status == REENTRANCY_ENTERED;\\n    }\\n\\n    /// @notice                   Sets an address as allowed auth or not. Only callable by owner.\\n    /// @param auth_              address to set auth value for\\n    /// @param allowed_           bool flag for whether address is allowed as auth or not\\n    function setAuth(address auth_, bool allowed_) external onlyOwner validAddress(auth_) {\\n        _auths[auth_] = allowed_ ? 1 : 0;\\n\\n        emit LogSetAuth(auth_, allowed_);\\n    }\\n\\n    /// @notice                   Sets an address as allowed guardian or not. Only callable by owner.\\n    /// @param guardian_          address to set guardian value for\\n    /// @param allowed_           bool flag for whether address is allowed as guardian or not\\n    function setGuardian(address guardian_, bool allowed_) external onlyOwner validAddress(guardian_) {\\n        _guardians[guardian_] = allowed_ ? 1 : 0;\\n\\n        emit LogSetGuardian(guardian_, allowed_);\\n    }\\n\\n    /// @notice                   Sets an address as allowed user or not. Only callable by auths.\\n    /// @param user_              address to set allowed value for\\n    /// @param allowed_           bool flag for whether address is allowed as user or not\\n    function setUserAllowed(address user_, bool allowed_) external onlyAuths validAddress(user_) {\\n        _allowed[user_] = allowed_ ? 1 : 0;\\n\\n        emit LogSetAllowed(user_, allowed_);\\n    }\\n\\n    /// @notice                   Sets `maxLTV` to `maxLTV_` (in 1e2: 1% = 100, 100% = 10000). Must be > 0 and < 100%.\\n    function setMaxLTV(uint16 maxLTV_) external onlyAuths {\\n        if (maxLTV_ == 0) {\\n            revert StETHQueueError(ErrorTypes.StETH__MaxLTVZero);\\n        }\\n        if (maxLTV_ >= HUNDRED_PERCENT) {\\n            revert StETHQueueError(ErrorTypes.StETH__MaxLTVAboveCap);\\n        }\\n\\n        maxLTV = maxLTV_;\\n        emit LogSetMaxLTV(maxLTV_);\\n    }\\n\\n    /// @notice Pauses the protocol (blocks queue() and claim()). Only callable by guardians.\\n    function pause() external {\\n        if (!isGuardian(msg.sender)) {\\n            revert StETHQueueError(ErrorTypes.StETH__Unauthorized);\\n        }\\n\\n        _status = REENTRANCY_ENTERED;\\n\\n        emit LogPaused();\\n    }\\n\\n    /// @notice Unpauses the protocol (enables queue() and claim()). Only callable by owner.\\n    function unpause() external onlyOwner(){\\n        _status = REENTRANCY_NOT_ENTERED;\\n\\n        emit LogUnpaused();\\n    }\\n\\n    /// @notice Sets `allowListActive` flag to `status_`. Only callable by owner.\\n    function setAllowListActive(bool status_) external onlyOwner {\\n        allowListActive = status_;\\n\\n        emit LogSetAllowListActive(status_);\\n    }\\n}\\n\\n/// @title StETHQueue\\n/// @notice queues an amount of stETH at the Lido WithdrawalQueue, using it as collateral to borrow an amount\\n/// of ETH that is paid back when Lido Withdrawal is claimable. Useful e.g. to deleverage a stETH / ETH borrow position.\\n/// User target group are whales that want to deleverage stETH / ETH without having to swap (no slippage).\\n/// @dev claims are referenced to via the claimTo address and the Lido requestIdFrom, which must be tracked from the moment\\n/// of queuing, where it is emitted in the `LogQueue` event, to pass in that information later for `claim()`.\\n/// @dev For view methods / accessing data, use the \\\"StETHResolver\\\" periphery contract.\\n//\\n// @dev Note that as a precaution if any claim fails for unforeseen, unexpected reasons, this contract is upgradeable so\\n// that Governance could rescue the funds.\\n// Note that claiming at Lido Withdrawal Queue is gas-cost-wise cheaper than queueing. So any queue process that passes\\n// below block gas limit, also passes at claiming.\\ncontract FluidStETHQueue is Variables, StETHQueueCore, StETHQueueAdmin, UUPSUpgradeable {\\n    constructor(\\n        IFluidLiquidity liquidity_,\\n        ILidoWithdrawalQueue lidoWithdrawalQueue_,\\n        IERC20 stETH_\\n    )\\n        validAddress(address(liquidity_))\\n        validAddress(address(lidoWithdrawalQueue_))\\n        validAddress(address(stETH_))\\n        Variables(liquidity_, lidoWithdrawalQueue_, stETH_)\\n    {\\n        // ensure logic contract initializer is not abused by disabling initializing\\n        // see https://forum.openzeppelin.com/t/security-advisory-initialize-uups-implementation-contracts/15301\\n        // and https://docs.openzeppelin.com/upgrades-plugins/1.x/writing-upgradeable#initializing_the_implementation_contract\\n        _disableInitializers();\\n    }\\n\\n    /// @notice initializes the contract with `owner_` as owner\\n    function initialize(address owner_) public initializer validAddress(owner_) {\\n        _transferOwnership(owner_);\\n\\n        // approve infinite stETH to Lido withdrawal queue for requesting withdrawals\\n        SafeERC20.safeApprove(STETH, address(LIDO_WITHDRAWAL_QUEUE), type(uint256).max);\\n\\n        _status = REENTRANCY_NOT_ENTERED; // set reentrancy to not entered on proxy\\n\\n        allowListActive = true; // start protocol in a protected state with allow list being active\\n\\n        // Borrow a minor dust amount of ETH (`DUST_BORROW_AMOUNT`) from Liquidity to avoid any potential reverts\\n        // because of rounding differences etc\\n        LIQUIDITY.operate(NATIVE_TOKEN_ADDRESS, 0, int256(DUST_BORROW_AMOUNT), address(0), address(this), new bytes(0));\\n    }\\n\\n    receive() external payable {}\\n\\n    function _authorizeUpgrade(address) internal override onlyOwner {}\\n\\n    /// @notice override renounce ownership as it could leave the contract in an unwanted state if called by mistake.\\n    function renounceOwnership() public view override onlyOwner {\\n        revert StETHQueueError(ErrorTypes.StETH__RenounceOwnershipUnsupported);\\n    }\\n\\n    /// @notice queues an amount of stETH at the Lido WithdrawalQueue, using it as collateral to borrow an amount\\n    /// of ETH from Liquidity that is paid back when Lido Withdrawal is claimable, triggered with `claim()`.\\n    /// @dev if `allowListActive` == true, then only allowed users can call this method.\\n    /// @param ethBorrowAmount_ amount of ETH to borrow and send to `borrowTo_`\\n    /// @param stETHAmount_ amount of stETH to queue at Lido Withdrawal Queue and use as collateral\\n    /// @param borrowTo_ receiver of the `ethBorrowAmount_`\\n    /// @param claimTo_ receiver of the left over stETH funds at time of `claim()`\\n    /// @return requestIdFrom_ first request id at Lido withdrawal queue. Used to identify claims\\n    function queue(\\n        uint256 ethBorrowAmount_,\\n        uint256 stETHAmount_,\\n        address borrowTo_,\\n        address claimTo_\\n    ) public nonReentrant validAddress(borrowTo_) validAddress(claimTo_) returns (uint256 requestIdFrom_) {\\n        if (allowListActive && !isUserAllowed(msg.sender)) {\\n            revert StETHQueueError(ErrorTypes.StETH__Unauthorized);\\n        }\\n\\n        // 1. sanity checks\\n        if (ethBorrowAmount_ == 0 || stETHAmount_ == 0) {\\n            revert StETHQueueError(ErrorTypes.StETH__InputAmountZero);\\n        }\\n        // validity check ltv of borrow amount / collateral is below configured maxLTV\\n        if ((ethBorrowAmount_ * HUNDRED_PERCENT) / stETHAmount_ > maxLTV) {\\n            revert StETHQueueError(ErrorTypes.StETH__MaxLTV);\\n        }\\n\\n        // 2. get `stETHAmount_` from msg.sender. must be approved to this contract\\n        SafeERC20.safeTransferFrom(STETH, msg.sender, address(this), stETHAmount_);\\n\\n        // 3. queue stETH withdrawal at Lido, receive withdrawal NFT\\n        uint256[] memory amounts_;\\n        {\\n            // maximum amount of stETH that is possible to withdraw by a single request at Lido (should be 1_000 stETH).\\n            uint256 maxStETHWithdrawalAmount_ = LIDO_WITHDRAWAL_QUEUE.MAX_STETH_WITHDRAWAL_AMOUNT();\\n            // minimum amount of stETH that is possible to withdraw by a single request at Lido (should be 100 wei).\\n            uint256 minStETHWithdrawalAmount_ = LIDO_WITHDRAWAL_QUEUE.MIN_STETH_WITHDRAWAL_AMOUNT();\\n\\n            if (stETHAmount_ > maxStETHWithdrawalAmount_) {\\n                // if withdraw amount is > MAX_STETH_WITHDRAWAL_AMOUNT it must be split into multiple smaller amounts\\n                // each of maximum MAX_STETH_WITHDRAWAL_AMOUNT\\n\\n                bool lastAmountExact_;\\n                uint256 fullAmountsLength_ = stETHAmount_ / maxStETHWithdrawalAmount_;\\n                unchecked {\\n                    // check if remainder for last amount in array is exactly matching MAX_STETH_WITHDRAWAL_AMOUNT\\n                    lastAmountExact_ = stETHAmount_ % maxStETHWithdrawalAmount_ == 0;\\n                    // total elements are count of full amounts + 1 (unless lastAmountExact_ is true)\\n                    amounts_ = new uint256[](fullAmountsLength_ + (lastAmountExact_ ? 0 : 1));\\n                }\\n                // fill amounts array with MAX_STETH_WITHDRAWAL_AMOUNT except for last element\\n                for (uint256 i; i < fullAmountsLength_; ) {\\n                    amounts_[i] = maxStETHWithdrawalAmount_;\\n\\n                    unchecked {\\n                        ++i;\\n                    }\\n                }\\n\\n                if (!lastAmountExact_) {\\n                    // last element is result of modulo operation so length of array is fullAmountsLength_ +1\\n                    amounts_[fullAmountsLength_] = stETHAmount_ % maxStETHWithdrawalAmount_;\\n\\n                    if (amounts_[fullAmountsLength_] < minStETHWithdrawalAmount_) {\\n                        // make sure remainder amount for last element in array is at least MIN_STETH_WITHDRAWAL_AMOUNT.\\n                        // if smaller, deduct MIN_STETH_WITHDRAWAL_AMOUNT from the second last element and it to the last.\\n                        unchecked {\\n                            amounts_[fullAmountsLength_ - 1] -= minStETHWithdrawalAmount_;\\n                            amounts_[fullAmountsLength_] += minStETHWithdrawalAmount_;\\n                        }\\n                    }\\n                }\\n            } else {\\n                amounts_ = new uint256[](1);\\n                amounts_[0] = stETHAmount_;\\n            }\\n        }\\n\\n        // request withdrawal at Lido, receiving the withdrawal NFT to this contract as owner\\n        uint256[] memory requestIds_ = LIDO_WITHDRAWAL_QUEUE.requestWithdrawals(amounts_, address(this));\\n\\n        requestIdFrom_ = requestIds_[0];\\n\\n        // 4. borrow amount of ETH from Liquidity and send it to msg.sender.\\n        // sender can use this to e.g. pay back a flashloan used to deleverage at a borrowing protocol.\\n        (, uint256 borrowExchangePrice_) = LIQUIDITY.operate(\\n            NATIVE_TOKEN_ADDRESS,\\n            0,\\n            int256(ethBorrowAmount_),\\n            address(0),\\n            borrowTo_,\\n            new bytes(0)\\n        );\\n\\n        uint256 borrowAmountRaw_ = (ethBorrowAmount_ * EXCHANGE_PRICES_PRECISION) / borrowExchangePrice_;\\n        if (borrowAmountRaw_ == 0) {\\n            revert StETHQueueError(ErrorTypes.StETH__BorrowAmountRawRoundingZero);\\n        }\\n\\n        // 5. write linked claim data in storage\\n        claims[claimTo_][requestIdFrom_] = Claim({\\n            // storing borrow amount in raw to account for borrow interest that must be paid back at `claim()` time.\\n            borrowAmountRaw: uint128(borrowAmountRaw_),\\n            checkpoint: uint48(LIDO_WITHDRAWAL_QUEUE.getLastCheckpointIndex()),\\n            requestIdTo: uint40(requestIds_[requestIds_.length - 1])\\n        });\\n\\n        // 6. emit event\\n        emit LogQueue(claimTo_, requestIdFrom_, ethBorrowAmount_, stETHAmount_, borrowTo_);\\n    }\\n\\n    /// @notice claims all open requests at LidoWithdrawalQueue for `claimTo_`, repays the borrowed ETH amount at Liquidity\\n    /// and sends the rest of funds to `claimTo_`.\\n    /// @param claimTo_ claimTo receiver to process the claim for\\n    /// @param requestIdFrom_ Lido requestId from (start), as emitted at time of queuing (`queue()`) via `LogQueue`\\n    /// @return claimedAmount_ total amount of claimed stETH\\n    /// @return repayAmount_ total repaid ETH amount at Liquidity\\n    function claim(\\n        address claimTo_,\\n        uint256 requestIdFrom_\\n    ) public nonReentrant returns (uint256 claimedAmount_, uint256 repayAmount_) {\\n        Claim memory claim_ = claims[claimTo_][requestIdFrom_];\\n\\n        if (claim_.checkpoint == 0) {\\n            // this implicitly confirms input params claimTo_ and requestIdFrom_ are valid, as a claim was found.\\n            revert StETHQueueError(ErrorTypes.StETH__NoClaimQueued);\\n        }\\n\\n        // store snapshot of balance before claiming\\n        claimedAmount_ = address(this).balance;\\n\\n        // 1. claim all requests at Lido. This will burn the NFTs.\\n        uint256 requestsLength_ = claim_.requestIdTo - requestIdFrom_ + 1;\\n        if (requestsLength_ == 1) {\\n            // only one request id\\n            LIDO_WITHDRAWAL_QUEUE.claimWithdrawal(claim_.requestIdTo);\\n        } else {\\n            uint256 curRequest_ = requestIdFrom_;\\n\\n            // build requestIds array from `requestIdFrom` to `requestIdTo`\\n            uint256[] memory requestIds_ = new uint256[](requestsLength_);\\n            for (uint256 i; i < requestsLength_; ) {\\n                requestIds_[i] = curRequest_;\\n\\n                unchecked {\\n                    ++i;\\n                    ++curRequest_;\\n                }\\n            }\\n            // claim withdrawals at Lido queue\\n            LIDO_WITHDRAWAL_QUEUE.claimWithdrawals(\\n                requestIds_,\\n                LIDO_WITHDRAWAL_QUEUE.findCheckpointHints(\\n                    requestIds_,\\n                    claim_.checkpoint,\\n                    LIDO_WITHDRAWAL_QUEUE.getLastCheckpointIndex()\\n                )\\n            );\\n        }\\n\\n        claimedAmount_ = address(this).balance - claimedAmount_;\\n\\n        // 2. calculate borrowed amount to repay after interest with updated exchange price from Liquidity\\n        // round up for safe rounding\\n        repayAmount_ = ((claim_.borrowAmountRaw * _getLiquidityExchangePrice()) / EXCHANGE_PRICES_PRECISION) + 1;\\n\\n        // 3. repay borrow amount at Liquidity. reverts if claimed amount does not cover borrowed amount.\\n        LIQUIDITY.operate{ value: repayAmount_ }(\\n            NATIVE_TOKEN_ADDRESS,\\n            0,\\n            -int256(repayAmount_),\\n            address(0),\\n            address(0),\\n            new bytes(0) // not needed for native token\\n        );\\n\\n        // 4. pay out rest of balance to owner\\n        Address.sendValue(payable(claimTo_), claimedAmount_ - repayAmount_);\\n\\n        // 5. delete mapping\\n        delete claims[claimTo_][requestIdFrom_];\\n\\n        // 6. emit event\\n        emit LogClaim(claimTo_, requestIdFrom_, claimedAmount_, repayAmount_);\\n    }\\n\\n    /// @notice accept ERC721 token transfers ONLY from LIDO_WITHDRAWAL_QUEUE\\n    function onERC721Received(\\n        address /** operator_ */,\\n        address /** from_ */,\\n        uint256 /** tokenId_ */,\\n        bytes memory /** data_ */\\n    ) public view returns (bytes4) {\\n        if (msg.sender == address(LIDO_WITHDRAWAL_QUEUE)) {\\n            return this.onERC721Received.selector;\\n        }\\n\\n        revert StETHQueueError(ErrorTypes.StETH__InvalidERC721Transfer);\\n    }\\n\\n    /// @notice liquidityCallback as used by Liquidity -> But unsupported in this contract as it only ever uses native\\n    /// token as borrowed asset, which is repaid directly via `msg.value`. Always reverts.\\n    function liquidityCallback(\\n        address /** token_ */,\\n        uint256 /** amount_ */,\\n        bytes calldata /** data_ */\\n    ) external pure {\\n        revert StETHQueueError(ErrorTypes.StETH__UnexpectedLiquidityCallback);\\n    }\\n}\\n\",\"keccak256\":\"0xadfff6cd698df995f95c8b770fe4666d1c4ca631600a7c36fba4432fcf80364a\",\"license\":\"BUSL-1.1\"},\"contracts/protocols/steth/structs.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\nabstract contract Structs {\\n    /// @notice Claim data struct for storage link to owner address\\n    struct Claim {\\n        /// @param borrowAmountRaw raw borrow amount at Liquidity. Multiply with borrowExchangePrice to get normal borrow amount\\n        uint128 borrowAmountRaw;\\n        /// @param checkpoint checkpoint at time of queue. optimizes finding checkpoint hints range at claim time.\\n        uint48 checkpoint;\\n        /// @param requestIdTo last request Id linked to the claim\\n        uint40 requestIdTo;\\n        // 5 bytes empty\\n    }\\n}\\n\",\"keccak256\":\"0x343943168af0e9e5ce5b9e3c536c19f1cb5c4402c9cea3e63aa7deca70ad507f\",\"license\":\"BUSL-1.1\"},\"contracts/protocols/steth/variables.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.21;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Initializable } from \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport { OwnableUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\n\\nimport { LiquiditySlotsLink } from \\\"../../libraries/liquiditySlotsLink.sol\\\";\\nimport { IFluidLiquidity } from \\\"../../liquidity/interfaces/iLiquidity.sol\\\";\\nimport { ILidoWithdrawalQueue } from \\\"./interfaces/external/iLidoWithdrawalQueue.sol\\\";\\nimport { Structs } from \\\"./structs.sol\\\";\\n\\nabstract contract Constants {\\n    /// @dev hundred percent at 1e2 precision\\n    uint256 internal constant HUNDRED_PERCENT = 1e4;\\n\\n    /// @dev precision for exchange prices in Liquidity\\n    uint256 internal constant EXCHANGE_PRICES_PRECISION = 1e12;\\n\\n    /// @dev address that is mapped to the chain native token at Liquidity\\n    address internal constant NATIVE_TOKEN_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\\n\\n    /// @dev dust amount to borrow from Liquidity at initialize()\\n    uint256 internal constant DUST_BORROW_AMOUNT = 1e12;\\n\\n    /// @notice address of the Liquidity contract.\\n    IFluidLiquidity internal immutable LIQUIDITY;\\n\\n    /// @notice address of the Lido Withdrawal Queue contract (0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1)\\n    ILidoWithdrawalQueue internal immutable LIDO_WITHDRAWAL_QUEUE;\\n\\n    /// @notice address of the StETH contract.\\n    IERC20 internal immutable STETH;\\n\\n    /// @dev slot id in Liquidity contract for exchange prices storage slot for NATIVE_TOKEN_ADDRESS.\\n    bytes32 internal immutable LIQUIDITY_EXCHANGE_PRICES_SLOT;\\n\\n    constructor(IFluidLiquidity liquidity_, ILidoWithdrawalQueue lidoWithdrawalQueue_, IERC20 stETH_) {\\n        LIQUIDITY = liquidity_;\\n\\n        LIDO_WITHDRAWAL_QUEUE = lidoWithdrawalQueue_;\\n\\n        STETH = stETH_;\\n\\n        LIQUIDITY_EXCHANGE_PRICES_SLOT = LiquiditySlotsLink.calculateMappingStorageSlot(\\n            LiquiditySlotsLink.LIQUIDITY_EXCHANGE_PRICES_MAPPING_SLOT,\\n            NATIVE_TOKEN_ADDRESS\\n        );\\n    }\\n\\n    /// @notice returns the constant values for LIQUIDITY, LIDO_WITHDRAWAL_QUEUE, STETH\\n    function constantsView() external view returns (IFluidLiquidity, ILidoWithdrawalQueue, IERC20) {\\n        return (LIQUIDITY, LIDO_WITHDRAWAL_QUEUE, STETH);\\n    }\\n}\\n\\nabstract contract Variables is Initializable, OwnableUpgradeable, Constants, Structs {\\n    // ------------ storage variables from inherited contracts (Initializable, OwnableUpgradeable) come before vars here --------\\n    // @dev variables here start at storage slot 101, before is:\\n    // - Initializable with storage slot 0:\\n    // uint8 private _initialized;\\n    // bool private _initializing;\\n    // - OwnableUpgradeable with slots 1 to 100:\\n    // uint256[50] private __gap; (from ContextUpgradeable, slot 1 until slot 50)\\n    // address private _owner; (at slot 51)\\n    // uint256[49] private __gap; (slot 52 until slot 100)\\n\\n    // ----------------------- slot 101 ---------------------------\\n\\n    /// @notice maps claimTo address and requestIdFrom to the Claim struct containing necessary information for executing the claim process.\\n    mapping(address => mapping(uint256 => Claim)) public claims;\\n\\n    // ----------------------- slot 102 ---------------------------\\n\\n    /// @dev status for reentrancy guard\\n    uint8 internal _status;\\n\\n    /// @notice maximum allowed percentage of LTV (loan-to-value). E.g. 90% -> max. 90 ETH can be borrowed with 100 stETH\\n    /// as collateral in withdrawal queue. ETH will be received at time of claim to cover the paid borrowed ETH amount.\\n    /// In 1e2 (1% = 100, 90% = 9_000, 100% = 10_000).\\n    /// Configurable by auths.\\n    uint16 public maxLTV;\\n\\n    /// @notice flag whether allow list behavior is enabled or not.\\n    bool public allowListActive;\\n\\n    // 28 bytes free\\n\\n    // ----------------------- slot 103 ---------------------------\\n    /// @dev auths can update maxLTV.\\n    /// owner can add/remove auths.\\n    /// Owner is auth by default.\\n    mapping(address => uint256) internal _auths;\\n\\n    // ----------------------- slot 104 ---------------------------\\n    /// @dev guardians can pause/unpause queue() and claim().\\n    /// owner can add/remove guardians.\\n    /// Owner is guardian by default.\\n    mapping(address => uint256) internal _guardians;\\n\\n    // ----------------------- slot 105 ---------------------------\\n    /// @dev allowed users can use the StETH protocol (if `allowListActive` is true, then use is open for everyone).\\n    /// owner and auths can add/remove allowed users.\\n    mapping(address => uint256) internal _allowed;\\n\\n    constructor(\\n        IFluidLiquidity liquidity_,\\n        ILidoWithdrawalQueue lidoWithdrawalQueue_,\\n        IERC20 stETH_\\n    ) Constants(liquidity_, lidoWithdrawalQueue_, stETH_) {}\\n}\\n\",\"keccak256\":\"0xa8205390d6b46230db572947af384d7b4982840907cd5294c01f191f83160b00\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
  "bytecode": "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",
  "deployedBytecode": "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",
  "devdoc": {
    "details": "claims are referenced to via the claimTo address and the Lido requestIdFrom, which must be tracked from the moment of queuing, where it is emitted in the `LogQueue` event, to pass in that information later for `claim()`.For view methods / accessing data, use the \"StETHResolver\" periphery contract.",
    "events": {
      "AdminChanged(address,address)": {
        "details": "Emitted when the admin account has changed."
      },
      "BeaconUpgraded(address)": {
        "details": "Emitted when the beacon is upgraded."
      },
      "Initialized(uint8)": {
        "details": "Triggered when the contract has been initialized or reinitialized."
      },
      "Upgraded(address)": {
        "details": "Emitted when the implementation is upgraded."
      }
    },
    "kind": "dev",
    "methods": {
      "claim(address,uint256)": {
        "params": {
          "claimTo_": "claimTo receiver to process the claim for",
          "requestIdFrom_": "Lido requestId from (start), as emitted at time of queuing (`queue()`) via `LogQueue`"
        },
        "returns": {
          "claimedAmount_": "total amount of claimed stETH",
          "repayAmount_": "total repaid ETH amount at Liquidity"
        }
      },
      "owner()": {
        "details": "Returns the address of the current owner."
      },
      "proxiableUUID()": {
        "details": "Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier."
      },
      "queue(uint256,uint256,address,address)": {
        "details": "if `allowListActive` == true, then only allowed users can call this method.",
        "params": {
          "borrowTo_": "receiver of the `ethBorrowAmount_`",
          "claimTo_": "receiver of the left over stETH funds at time of `claim()`",
          "ethBorrowAmount_": "amount of ETH to borrow and send to `borrowTo_`",
          "stETHAmount_": "amount of stETH to queue at Lido Withdrawal Queue and use as collateral"
        },
        "returns": {
          "requestIdFrom_": "first request id at Lido withdrawal queue. Used to identify claims"
        }
      },
      "setAuth(address,bool)": {
        "params": {
          "allowed_": "bool flag for whether address is allowed as auth or not",
          "auth_": "address to set auth value for"
        }
      },
      "setGuardian(address,bool)": {
        "params": {
          "allowed_": "bool flag for whether address is allowed as guardian or not",
          "guardian_": "address to set guardian value for"
        }
      },
      "setUserAllowed(address,bool)": {
        "params": {
          "allowed_": "bool flag for whether address is allowed as user or not",
          "user_": "address to set allowed value for"
        }
      },
      "transferOwnership(address)": {
        "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."
      },
      "upgradeTo(address)": {
        "details": "Upgrade the implementation of the proxy to `newImplementation`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event."
      },
      "upgradeToAndCall(address,bytes)": {
        "details": "Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event."
      }
    },
    "title": "StETHQueue",
    "version": 1
  },
  "userdoc": {
    "errors": {
      "StETHQueueError(uint256)": [
        {
          "notice": "general Custom error used for all contract specific errors with the `errorId_` param as error code. Look up the specific error code in the source code to find a better explanation of what went wrong (errors.sol)."
        }
      ]
    },
    "events": {
      "LogClaim(address,uint256,uint256,uint256)": {
        "notice": "emitted when a claim() process is executed"
      },
      "LogPaused()": {
        "notice": "emitted when protocol is paused by guardian"
      },
      "LogQueue(address,uint256,uint256,uint256,address)": {
        "notice": "emitted when a queue() process is executed"
      },
      "LogSetAllowListActive(bool)": {
        "notice": "emitted when `allowListActive` status is updated"
      },
      "LogSetAllowed(address,bool)": {
        "notice": "emitted when an allowed user is modified by auths"
      },
      "LogSetAuth(address,bool)": {
        "notice": "emitted when an auth is modified by owner"
      },
      "LogSetGuardian(address,bool)": {
        "notice": "emitted when a guardian is modified by owner"
      },
      "LogSetMaxLTV(uint256)": {
        "notice": "emitted whenever `maxLTV` is updated"
      },
      "LogUnpaused()": {
        "notice": "emitted when protocol is unpaused by owner"
      }
    },
    "kind": "user",
    "methods": {
      "allowListActive()": {
        "notice": "flag whether allow list behavior is enabled or not."
      },
      "claim(address,uint256)": {
        "notice": "claims all open requests at LidoWithdrawalQueue for `claimTo_`, repays the borrowed ETH amount at Liquidity and sends the rest of funds to `claimTo_`."
      },
      "claims(address,uint256)": {
        "notice": "maps claimTo address and requestIdFrom to the Claim struct containing necessary information for executing the claim process."
      },
      "constantsView()": {
        "notice": "returns the constant values for LIQUIDITY, LIDO_WITHDRAWAL_QUEUE, STETH"
      },
      "initialize(address)": {
        "notice": "initializes the contract with `owner_` as owner"
      },
      "isAuth(address)": {
        "notice": "reads if a certain `auth_` address is an allowed auth or not"
      },
      "isGuardian(address)": {
        "notice": "reads if a certain `guardian_` address is an allowed guardian or not"
      },
      "isPaused()": {
        "notice": "reads if the protocol is paused or not"
      },
      "isUserAllowed(address)": {
        "notice": "reads if a certain `user_` address is an allowed user or not"
      },
      "liquidityCallback(address,uint256,bytes)": {
        "notice": "liquidityCallback as used by Liquidity -> But unsupported in this contract as it only ever uses native token as borrowed asset, which is repaid directly via `msg.value`. Always reverts."
      },
      "maxLTV()": {
        "notice": "maximum allowed percentage of LTV (loan-to-value). E.g. 90% -> max. 90 ETH can be borrowed with 100 stETH as collateral in withdrawal queue. ETH will be received at time of claim to cover the paid borrowed ETH amount. In 1e2 (1% = 100, 90% = 9_000, 100% = 10_000). Configurable by auths."
      },
      "onERC721Received(address,address,uint256,bytes)": {
        "notice": "accept ERC721 token transfers ONLY from LIDO_WITHDRAWAL_QUEUE"
      },
      "pause()": {
        "notice": "Pauses the protocol (blocks queue() and claim()). Only callable by guardians."
      },
      "queue(uint256,uint256,address,address)": {
        "notice": "queues an amount of stETH at the Lido WithdrawalQueue, using it as collateral to borrow an amount of ETH from Liquidity that is paid back when Lido Withdrawal is claimable, triggered with `claim()`."
      },
      "renounceOwnership()": {
        "notice": "override renounce ownership as it could leave the contract in an unwanted state if called by mistake."
      },
      "setAllowListActive(bool)": {
        "notice": "Sets `allowListActive` flag to `status_`. Only callable by owner."
      },
      "setAuth(address,bool)": {
        "notice": "Sets an address as allowed auth or not. Only callable by owner."
      },
      "setGuardian(address,bool)": {
        "notice": "Sets an address as allowed guardian or not. Only callable by owner."
      },
      "setMaxLTV(uint16)": {
        "notice": "Sets `maxLTV` to `maxLTV_` (in 1e2: 1% = 100, 100% = 10000). Must be > 0 and < 100%."
      },
      "setUserAllowed(address,bool)": {
        "notice": "Sets an address as allowed user or not. Only callable by auths."
      },
      "unpause()": {
        "notice": "Unpauses the protocol (enables queue() and claim()). Only callable by owner."
      }
    },
    "notice": "queues an amount of stETH at the Lido WithdrawalQueue, using it as collateral to borrow an amount of ETH that is paid back when Lido Withdrawal is claimable. Useful e.g. to deleverage a stETH / ETH borrow position. User target group are whales that want to deleverage stETH / ETH without having to swap (no slippage).",
    "version": 1
  },
  "storageLayout": {
    "storage": [
      {
        "astId": 138,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "_initialized",
        "offset": 0,
        "slot": "0",
        "type": "t_uint8"
      },
      {
        "astId": 141,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "_initializing",
        "offset": 1,
        "slot": "0",
        "type": "t_bool"
      },
      {
        "astId": 625,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "__gap",
        "offset": 0,
        "slot": "1",
        "type": "t_array(t_uint256)50_storage"
      },
      {
        "astId": 10,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "_owner",
        "offset": 0,
        "slot": "51",
        "type": "t_address"
      },
      {
        "astId": 130,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "__gap",
        "offset": 0,
        "slot": "52",
        "type": "t_array(t_uint256)49_storage"
      },
      {
        "astId": 6237,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "claims",
        "offset": 0,
        "slot": "101",
        "type": "t_mapping(t_address,t_mapping(t_uint256,t_struct(Claim)6119_storage))"
      },
      {
        "astId": 6240,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "_status",
        "offset": 0,
        "slot": "102",
        "type": "t_uint8"
      },
      {
        "astId": 6243,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "maxLTV",
        "offset": 1,
        "slot": "102",
        "type": "t_uint16"
      },
      {
        "astId": 6246,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "allowListActive",
        "offset": 3,
        "slot": "102",
        "type": "t_bool"
      },
      {
        "astId": 6251,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "_auths",
        "offset": 0,
        "slot": "103",
        "type": "t_mapping(t_address,t_uint256)"
      },
      {
        "astId": 6256,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "_guardians",
        "offset": 0,
        "slot": "104",
        "type": "t_mapping(t_address,t_uint256)"
      },
      {
        "astId": 6261,
        "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
        "label": "_allowed",
        "offset": 0,
        "slot": "105",
        "type": "t_mapping(t_address,t_uint256)"
      }
    ],
    "types": {
      "t_address": {
        "encoding": "inplace",
        "label": "address",
        "numberOfBytes": "20"
      },
      "t_array(t_uint256)49_storage": {
        "base": "t_uint256",
        "encoding": "inplace",
        "label": "uint256[49]",
        "numberOfBytes": "1568"
      },
      "t_array(t_uint256)50_storage": {
        "base": "t_uint256",
        "encoding": "inplace",
        "label": "uint256[50]",
        "numberOfBytes": "1600"
      },
      "t_bool": {
        "encoding": "inplace",
        "label": "bool",
        "numberOfBytes": "1"
      },
      "t_mapping(t_address,t_mapping(t_uint256,t_struct(Claim)6119_storage))": {
        "encoding": "mapping",
        "key": "t_address",
        "label": "mapping(address => mapping(uint256 => struct Structs.Claim))",
        "numberOfBytes": "32",
        "value": "t_mapping(t_uint256,t_struct(Claim)6119_storage)"
      },
      "t_mapping(t_address,t_uint256)": {
        "encoding": "mapping",
        "key": "t_address",
        "label": "mapping(address => uint256)",
        "numberOfBytes": "32",
        "value": "t_uint256"
      },
      "t_mapping(t_uint256,t_struct(Claim)6119_storage)": {
        "encoding": "mapping",
        "key": "t_uint256",
        "label": "mapping(uint256 => struct Structs.Claim)",
        "numberOfBytes": "32",
        "value": "t_struct(Claim)6119_storage"
      },
      "t_struct(Claim)6119_storage": {
        "encoding": "inplace",
        "label": "struct Structs.Claim",
        "members": [
          {
            "astId": 6112,
            "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
            "label": "borrowAmountRaw",
            "offset": 0,
            "slot": "0",
            "type": "t_uint128"
          },
          {
            "astId": 6115,
            "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
            "label": "checkpoint",
            "offset": 16,
            "slot": "0",
            "type": "t_uint48"
          },
          {
            "astId": 6118,
            "contract": "contracts/protocols/steth/main.sol:FluidStETHQueue",
            "label": "requestIdTo",
            "offset": 22,
            "slot": "0",
            "type": "t_uint40"
          }
        ],
        "numberOfBytes": "32"
      },
      "t_uint128": {
        "encoding": "inplace",
        "label": "uint128",
        "numberOfBytes": "16"
      },
      "t_uint16": {
        "encoding": "inplace",
        "label": "uint16",
        "numberOfBytes": "2"
      },
      "t_uint256": {
        "encoding": "inplace",
        "label": "uint256",
        "numberOfBytes": "32"
      },
      "t_uint40": {
        "encoding": "inplace",
        "label": "uint40",
        "numberOfBytes": "5"
      },
      "t_uint48": {
        "encoding": "inplace",
        "label": "uint48",
        "numberOfBytes": "6"
      },
      "t_uint8": {
        "encoding": "inplace",
        "label": "uint8",
        "numberOfBytes": "1"
      }
    }
  }
}