{
  "language": "Solidity",
  "sources": {
    "contracts/controllers/BadgerBridgeZeroController.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0;\npragma abicoder v2;\n\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { ISwapRouter } from \"@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol\";\nimport { UniswapV2Library } from \"../libraries/UniswapV2Library.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\nimport { IERC2612Permit } from \"../interfaces/IERC2612Permit.sol\";\nimport { IRenCrv } from \"../interfaces/CurvePools/IRenCrv.sol\";\nimport { SplitSignatureLib } from \"../libraries/SplitSignatureLib.sol\";\nimport { IBadgerSettPeak } from \"../interfaces/IBadgerSettPeak.sol\";\nimport { IWETH } from \"../interfaces/IWETH.sol\";\nimport { ICurveFi } from \"../interfaces/ICurveFi.sol\";\nimport { IGateway } from \"../interfaces/IGateway.sol\";\nimport { ICurveTricrypto } from \"../interfaces/CurvePools/ICurveTricrypto.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { IyVault } from \"../interfaces/IyVault.sol\";\nimport { ISett } from \"../interfaces/ISett.sol\";\nimport { Math } from \"@openzeppelin/contracts/math/Math.sol\";\nimport { SafeMath } from \"@openzeppelin/contracts/math/SafeMath.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts/token/ERC20/SafeERC20.sol\";\nimport { ECDSA } from \"@openzeppelin/contracts/cryptography/ECDSA.sol\";\nimport { EIP712Upgradeable } from \"@openzeppelin/contracts-upgradeable/drafts/EIP712Upgradeable.sol\";\n\ncontract BadgerBridgeZeroController is EIP712Upgradeable {\n  using SafeERC20 for IERC20;\n  using SafeMath for *;\n  uint256 public fee;\n  address public governance;\n  address public strategist;\n\n  address constant btcGateway = 0xe4b679400F0f267212D5D812B95f58C83243EE71;\n  address constant router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;\n  address constant routerv3 = 0xE592427A0AEce92De3Edee1F18E0157C05861564;\n  address constant factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;\n  address constant usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\n  address constant weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n  address constant wbtc = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;\n  address constant renbtc = 0xEB4C2781e4ebA804CE9a9803C67d0893436bB27D;\n  address constant renCrv = 0x93054188d876f558f4a66B2EF1d97d16eDf0895B;\n  address constant threepool = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7;\n  address constant tricrypto = 0x80466c64868E1ab14a1Ddf27A676C3fcBE638Fe5;\n  address constant renCrvLp = 0x49849C98ae39Fff122806C06791Fa73784FB3675;\n  address constant bCrvRen = 0x6dEf55d2e18486B9dDfaA075bc4e4EE0B28c1545;\n  address constant settPeak = 0x41671BA1abcbA387b9b2B752c205e22e916BE6e3;\n  address constant usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;\n  uint24 constant wethWbtcFee = 500;\n  uint24 constant usdcWethFee = 500;\n  uint256 public governanceFee;\n  bytes32 constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;\n  bytes32 constant LOCK_SLOT = keccak256(\"upgrade-lock-v3\");\n  uint256 constant GAS_COST = uint256(42e4);\n  uint256 constant ETH_RESERVE = uint256(5 ether);\n  uint256 internal renbtcForOneETHPrice;\n  uint256 internal burnFee;\n  uint256 public keeperReward;\n  uint256 public constant REPAY_GAS_DIFF = 41510;\n  uint256 public constant BURN_GAS_DIFF = 41118;\n  mapping(address => uint256) public nonces;\n  bytes32 internal PERMIT_DOMAIN_SEPARATOR_WBTC;\n  mapping(address => uint256) public noncesUsdt;\n  bytes32 constant PERMIT_DOMAIN_SEPARATOR_USDT_SLOT = keccak256(\"usdt-permit\");\n\n  function getUsdtDomainSeparator() public view returns (bytes32) {\n    bytes32 separator_slot = PERMIT_DOMAIN_SEPARATOR_USDT_SLOT;\n    bytes32 separator;\n    assembly {\n      separator := sload(separator_slot)\n    }\n    return separator;\n  }\n\n  function setStrategist(address _strategist) public {\n    require(msg.sender == governance, \"!governance\");\n    strategist = _strategist;\n  }\n\n  function setGovernance(address _governance) public {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function approveUpgrade(bool lock) public {\n    bool isLocked;\n    bytes32 lock_slot = LOCK_SLOT;\n    bytes32 permit_slot = PERMIT_DOMAIN_SEPARATOR_USDT_SLOT;\n\n    assembly {\n      isLocked := sload(lock_slot)\n    }\n    require(!isLocked, \"cannot run upgrade function\");\n\n    IERC20(usdt).safeApprove(tricrypto, ~uint256(0) >> 2);\n    bytes32 permit_usdt_separator = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"USDT\"),\n        keccak256(\"1\"),\n        getChainId(),\n        usdt\n      )\n    );\n\n    assembly {\n      sstore(lock_slot, lock)\n      sstore(permit_slot, permit_usdt_separator)\n    }\n  }\n\n  function computeCalldataGasDiff() internal pure returns (uint256 diff) {\n    if (true) return 0; // TODO: implement exact gas metering\n    // EVM charges less for zero bytes, we must compute the offset for refund\n    // TODO make this efficient\n    uint256 sz;\n    assembly {\n      sz := calldatasize()\n    }\n    diff = sz.mul(uint256(68));\n    bytes memory slice;\n    for (uint256 i = 0; i < sz; i += 0x20) {\n      uint256 word;\n      assembly {\n        word := calldataload(i)\n      }\n      for (uint256 i = 0; i < 256 && ((uint256(~0) << i) & word) != 0; i += 8) {\n        if ((word >> i) & 0xff != 0) diff -= 64;\n      }\n    }\n  }\n\n  function getChainId() internal pure returns (uint256 result) {\n    assembly {\n      result := chainid()\n    }\n  }\n\n  function setParameters(\n    uint256 _governanceFee,\n    uint256 _fee,\n    uint256 _burnFee,\n    uint256 _keeperReward\n  ) public {\n    require(governance == msg.sender, \"!governance\");\n    governanceFee = _governanceFee;\n    fee = _fee;\n    burnFee = _burnFee;\n    keeperReward = _keeperReward;\n  }\n\n  function initialize(address _governance, address _strategist) public initializer {\n    fee = uint256(25e14);\n    burnFee = uint256(4e15);\n    governanceFee = uint256(5e17);\n    governance = _governance;\n    strategist = _strategist;\n    keeperReward = uint256(1 ether).div(1000);\n    IERC20(renbtc).safeApprove(btcGateway, ~uint256(0) >> 2);\n    IERC20(renbtc).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(tricrypto, ~uint256(0) >> 2);\n    IERC20(usdt).safeApprove(tricrypto, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(routerv3, ~uint256(0) >> 2);\n    IERC20(usdc).safeApprove(routerv3, ~uint256(0) >> 2);\n    PERMIT_DOMAIN_SEPARATOR_WBTC = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"WBTC\"),\n        keccak256(\"1\"),\n        getChainId(),\n        wbtc\n      )\n    );\n    bytes32 permit_separator_usdt = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"USDT\"),\n        keccak256(\"1\"),\n        getChainId(),\n        usdt\n      )\n    );\n    bytes32 permit_slot = PERMIT_DOMAIN_SEPARATOR_USDT_SLOT;\n    assembly {\n      sstore(permit_slot, permit_separator_usdt)\n    }\n  }\n\n  function applyRatio(uint256 v, uint256 n) internal pure returns (uint256 result) {\n    result = v.mul(n).div(uint256(1 ether));\n  }\n\n  function toWBTC(uint256 amount) internal returns (uint256 amountOut) {\n    uint256 amountStart = IERC20(wbtc).balanceOf(address(this));\n    (bool success, ) = renCrv.call(abi.encodeWithSelector(IRenCrv.exchange.selector, 0, 1, amount));\n    amountOut = IERC20(wbtc).balanceOf(address(this)).sub(amountStart);\n  }\n\n  function toUSDC(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    uint256 wbtcAmountIn = toWBTC(amountIn);\n    bytes memory path = abi.encodePacked(wbtc, wethWbtcFee, weth, usdcWethFee, usdc);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: out,\n      deadline: block.timestamp + 1,\n      amountIn: wbtcAmountIn,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput(params);\n  }\n\n  function quote() internal {\n    (uint256 amountWeth, uint256 amountRenBTC) = UniswapV2Library.getReserves(factory, weth, renbtc);\n    renbtcForOneETHPrice = UniswapV2Library.quote(uint256(1 ether), amountWeth, amountRenBTC);\n  }\n\n  function renBTCtoETH(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    uint256 wbtcAmountOut = toWBTC(amountIn);\n    ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({\n      tokenIn: wbtc,\n      tokenOut: weth,\n      fee: wethWbtcFee,\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: wbtcAmountOut,\n      amountOutMinimum: minOut,\n      sqrtPriceLimitX96: 0\n    });\n    amountOut = ISwapRouter(routerv3).exactInputSingle(params);\n    IWETH(weth).withdraw(amountOut);\n    address payable recipient = address(uint160(out));\n    recipient.transfer(amountOut);\n  }\n\n  function burnApproved(\n    address from,\n    address asset,\n    uint256 amount,\n    uint256 minOut,\n    bytes memory destination\n  ) public payable returns (uint256 amountToBurn) {\n    require(asset == wbtc || asset == usdc || asset == renbtc || asset == address(0x0), \"!approved-module\");\n    if (asset != address(0x0)) IERC20(asset).transferFrom(msg.sender, address(this), amount);\n    amountToBurn = asset == wbtc ? toRenBTC(amount.sub(applyRatio(amount, burnFee))) : asset == usdc\n      ? fromUSDC(minOut, amount.sub(applyRatio(amount, burnFee)))\n      : asset == renbtc\n      ? amount\n      : fromETHToRenBTC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(btcGateway).burn(destination, amountToBurn);\n  }\n\n  function toRenBTC(uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 balanceStart = IERC20(renbtc).balanceOf(address(this));\n    (bool success, ) = renCrv.call(abi.encodeWithSelector(IRenCrv.exchange.selector, 1, 0, amountIn));\n    amountOut = IERC20(renbtc).balanceOf(address(this)).sub(balanceStart);\n  }\n\n  function fromUSDC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    bytes memory path = abi.encodePacked(usdc, usdcWethFee, weth, wethWbtcFee, wbtc);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: amountIn,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput(params);\n    amountOut = toRenBTC(amountOut);\n  }\n\n  function fromETHToRenBTC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 amountStart = IERC20(renbtc).balanceOf(address(this));\n    ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({\n      tokenIn: weth,\n      tokenOut: wbtc,\n      fee: wethWbtcFee,\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: amountIn,\n      amountOutMinimum: minOut,\n      sqrtPriceLimitX96: 0\n    });\n    amountOut = ISwapRouter(routerv3).exactInputSingle{ value: amountIn }(params);\n    (bool success, ) = renCrv.call(abi.encodeWithSelector(IRenCrv.exchange.selector, 1, 0, amountOut, 1));\n    require(success, \"!curve\");\n    amountOut = IERC20(renbtc).balanceOf(address(this)).sub(amountStart);\n  }\n\n  function toETH() internal returns (uint256 amountOut) {\n    uint256 wbtcStart = IERC20(wbtc).balanceOf(address(this));\n\n    uint256 amountStart = address(this).balance;\n    (bool success, ) = tricrypto.call(\n      abi.encodeWithSelector(ICurveTricrypto.exchange.selector, 1, 2, wbtcStart, 0, true)\n    );\n    amountOut = address(this).balance.sub(amountStart);\n  }\n\n  function fromUSDT(uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 wbtcIn = IERC20(wbtc).balanceOf(address(this));\n    (bool success, ) = tricrypto.call(\n      abi.encodeWithSelector(ICurveTricrypto.exchange.selector, 0, 1, amountIn, 0, false)\n    );\n    require(success, \"!curve\");\n    wbtcIn = IERC20(wbtc).balanceOf(address(this)).sub(wbtcIn);\n    amountOut = toRenBTC(wbtcIn);\n  }\n\n  function toUSDT(uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 wbtcOut = toWBTC(amountIn);\n    amountOut = IERC20(usdt).balanceOf(address(this));\n    (bool success, ) = tricrypto.call(\n      abi.encodeWithSelector(ICurveTricrypto.exchange.selector, 1, 0, wbtcOut, 0, false)\n    );\n    require(success, \"!curve\");\n    amountOut = IERC20(usdt).balanceOf(address(this)).sub(amountOut);\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function earn() public {\n    quote();\n    toWBTC(IERC20(renbtc).balanceOf(address(this)));\n    toETH();\n    uint256 balance = address(this).balance;\n    if (balance > ETH_RESERVE) {\n      uint256 output = balance - ETH_RESERVE;\n      uint256 toGovernance = applyRatio(output, governanceFee);\n      address payable governancePayable = address(uint160(governance));\n      require(governancePayable.send(toGovernance), \"error on sending to governance\");\n      address payable strategistPayable = address(uint160(strategist));\n      require(strategistPayable.send(output.sub(toGovernance)), \"error on sending to strategist\");\n    }\n  }\n\n  function computeRenBTCGasFee(uint256 gasCost, uint256 gasPrice) internal view returns (uint256 result) {\n    result = gasCost.mul(tx.gasprice).mul(renbtcForOneETHPrice).div(uint256(1 ether));\n  }\n\n  function deductMintFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, fee, multiplier));\n  }\n\n  function deductBurnFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, burnFee, multiplier));\n  }\n\n  function applyFee(\n    uint256 amountIn,\n    uint256 _fee,\n    uint256 multiplier\n  ) internal view returns (uint256 amount) {\n    amount = computeRenBTCGasFee(GAS_COST.add(keeperReward.div(tx.gasprice)), tx.gasprice).add(\n      applyRatio(amountIn, _fee)\n    );\n  }\n\n  struct LoanParams {\n    address to;\n    address asset;\n    uint256 nonce;\n    uint256 amount;\n    address module;\n    address underwriter;\n    bytes data;\n    uint256 minOut;\n    uint256 _mintAmount;\n    uint256 gasDiff;\n  }\n\n  function toTypedDataHash(LoanParams memory params) internal view returns (bytes32 result) {\n    bytes32 digest = _hashTypedDataV4(\n      keccak256(\n        abi.encode(\n          keccak256(\n            \"TransferRequest(address asset,uint256 amount,address underwriter,address module,uint256 nonce,bytes data)\"\n          ),\n          params.asset,\n          params.amount,\n          params.underwriter,\n          params.module,\n          params.nonce,\n          keccak256(params.data)\n        )\n      )\n    );\n    return digest;\n  }\n\n  function repay(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public returns (uint256 amountOut) {\n    require(msg.data.length <= 516, \"too much calldata\");\n    uint256 _gasBefore = gasleft();\n    LoanParams memory params;\n    {\n      require(\n        module == wbtc || module == usdc || module == renbtc || module == usdt || module == address(0x0),\n        \"!approved-module\"\n      );\n      params = LoanParams({\n        to: to,\n        asset: asset,\n        amount: amount,\n        nonce: nonce,\n        module: module,\n        underwriter: underwriter,\n        data: data,\n        minOut: 1,\n        _mintAmount: 0,\n        gasDiff: computeCalldataGasDiff()\n      });\n      if (data.length > 0) (params.minOut) = abi.decode(data, (uint256));\n    }\n    bytes32 digest = toTypedDataHash(params);\n\n    params._mintAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n\n    {\n      amountOut = module == wbtc ? toWBTC(deductMintFee(params._mintAmount, 1)) : module == address(0x0)\n        ? renBTCtoETH(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : module == usdt\n        ? toUSDT(deductMintFee(params._mintAmount, 1))\n        : module == usdc\n        ? toUSDC(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : deductMintFee(params._mintAmount, 1);\n    }\n    {\n      if (module != usdc && module != address(0x0)) IERC20(module).safeTransfer(to, amountOut);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          _gasBefore.sub(gasleft()).add(REPAY_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function computeBurnNonce(BurnLocals memory params) internal view returns (uint256 result) {\n    result = uint256(\n      keccak256(\n        abi.encodePacked(params.asset, params.amount, params.deadline, params.nonce, params.data, params.destination)\n      )\n    );\n    while (result < block.timestamp) {\n      // negligible probability of this\n      result = uint256(keccak256(abi.encodePacked(result)));\n    }\n  }\n\n  function computeERC20PermitDigest(bytes32 domainSeparator, BurnLocals memory params)\n    internal\n    view\n    returns (bytes32 result)\n  {\n    result = keccak256(\n      abi.encodePacked(\n        \"\\x19\\x01\",\n        domainSeparator,\n        keccak256(abi.encode(PERMIT_TYPEHASH, params.to, address(this), params.nonce, computeBurnNonce(params), true))\n      )\n    );\n  }\n\n  struct BurnLocals {\n    address to;\n    address asset;\n    uint256 amount;\n    uint256 deadline;\n    uint256 nonce;\n    bytes data;\n    uint256 minOut;\n    uint256 burnNonce;\n    uint256 gasBefore;\n    uint256 gasDiff;\n    uint8 v;\n    bytes32 r;\n    bytes32 s;\n    bytes destination;\n    bytes signature;\n  }\n\n  function burn(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    bytes memory data,\n    bytes memory destination,\n    bytes memory signature\n  ) public returns (uint256 amountToBurn) {\n    require(msg.data.length <= 580, \"too much calldata\");\n    BurnLocals memory params = BurnLocals({\n      to: to,\n      asset: asset,\n      amount: amount,\n      deadline: deadline,\n      data: data,\n      nonce: 0,\n      burnNonce: 0,\n      v: uint8(0),\n      r: bytes32(0),\n      s: bytes32(0),\n      destination: destination,\n      signature: signature,\n      gasBefore: gasleft(),\n      minOut: 1,\n      gasDiff: 0\n    });\n    {\n      params.gasDiff = computeCalldataGasDiff();\n      if (params.data.length > 0) (params.minOut) = abi.decode(params.data, (uint256));\n    }\n    require(block.timestamp < params.deadline, \"!deadline\");\n    if (params.asset == wbtc) {\n      params.nonce = nonces[to];\n      nonces[params.to]++;\n      require(\n        params.to == ECDSA.recover(computeERC20PermitDigest(PERMIT_DOMAIN_SEPARATOR_WBTC, params), params.signature),\n        \"!signature\"\n      ); //  wbtc does not implement ERC20Permit\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n        amountToBurn = toRenBTC(deductBurnFee(params.amount, 1));\n      }\n    } else if (params.asset == usdt) {\n      params.nonce = noncesUsdt[to];\n      noncesUsdt[params.to]++;\n      require(\n        params.to == ECDSA.recover(computeERC20PermitDigest(getUsdtDomainSeparator(), params), params.signature),\n        \"!signature\"\n      ); //  usdt does not implement ERC20Permit\n      {\n        (bool success, ) = params.asset.call(\n          abi.encodeWithSelector(IERC20.transferFrom.selector, params.to, address(this), params.amount)\n        );\n        require(success, \"!usdt\");\n      }\n      amountToBurn = deductBurnFee(fromUSDT(params.amount), 1);\n    } else if (params.asset == renbtc) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.nonce,\n          params.burnNonce,\n          true,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(params.amount, 1);\n    } else if (params.asset == usdc) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.amount,\n          params.burnNonce,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(fromUSDC(params.minOut, params.amount), 1);\n    } else revert(\"!supported-asset\");\n    {\n      IGateway(btcGateway).burn(params.destination, amountToBurn);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          params.gasBefore.sub(gasleft()).add(BURN_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function burnETH(uint256 minOut, bytes memory destination) public payable returns (uint256 amountToBurn) {\n    amountToBurn = fromETHToRenBTC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(btcGateway).burn(destination, amountToBurn);\n  }\n\n  function fallbackMint(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public {\n    LoanParams memory params = LoanParams({\n      to: to,\n      asset: asset,\n      amount: amount,\n      nonce: nonce,\n      module: module,\n      underwriter: underwriter,\n      data: data,\n      minOut: 1,\n      _mintAmount: 0,\n      gasDiff: 0\n    });\n    bytes32 digest = toTypedDataHash(params);\n    uint256 _actualAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    IERC20(asset).safeTransfer(to, _actualAmount);\n  }\n}\n"
    },
    "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol": {
      "content": "pragma solidity >=0.6.2;\n\nimport './IUniswapV2Router01.sol';\n\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\n    function removeLiquidityETHSupportingFeeOnTransferTokens(\n        address token,\n        uint liquidity,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline\n    ) external returns (uint amountETH);\n    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\n        address token,\n        uint liquidity,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline,\n        bool approveMax, uint8 v, bytes32 r, bytes32 s\n    ) external returns (uint amountETH);\n\n    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\n        uint amountIn,\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external;\n    function swapExactETHForTokensSupportingFeeOnTransferTokens(\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external payable;\n    function swapExactTokensForETHSupportingFeeOnTransferTokens(\n        uint amountIn,\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external;\n}\n"
    },
    "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol": {
      "content": "// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.7.5;\npragma abicoder v2;\n\nimport '@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol';\n\n/// @title Router token swapping functionality\n/// @notice Functions for swapping tokens via Uniswap V3\ninterface ISwapRouter is IUniswapV3SwapCallback {\n    struct ExactInputSingleParams {\n        address tokenIn;\n        address tokenOut;\n        uint24 fee;\n        address recipient;\n        uint256 deadline;\n        uint256 amountIn;\n        uint256 amountOutMinimum;\n        uint160 sqrtPriceLimitX96;\n    }\n\n    /// @notice Swaps `amountIn` of one token for as much as possible of another token\n    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata\n    /// @return amountOut The amount of the received token\n    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);\n\n    struct ExactInputParams {\n        bytes path;\n        address recipient;\n        uint256 deadline;\n        uint256 amountIn;\n        uint256 amountOutMinimum;\n    }\n\n    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path\n    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata\n    /// @return amountOut The amount of the received token\n    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);\n\n    struct ExactOutputSingleParams {\n        address tokenIn;\n        address tokenOut;\n        uint24 fee;\n        address recipient;\n        uint256 deadline;\n        uint256 amountOut;\n        uint256 amountInMaximum;\n        uint160 sqrtPriceLimitX96;\n    }\n\n    /// @notice Swaps as little as possible of one token for `amountOut` of another token\n    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata\n    /// @return amountIn The amount of the input token\n    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);\n\n    struct ExactOutputParams {\n        bytes path;\n        address recipient;\n        uint256 deadline;\n        uint256 amountOut;\n        uint256 amountInMaximum;\n    }\n\n    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)\n    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata\n    /// @return amountIn The amount of the input token\n    function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);\n}\n"
    },
    "contracts/libraries/UniswapV2Library.sol": {
      "content": "pragma solidity >=0.5.0;\n\nimport \"@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol\";\n\nimport \"@openzeppelin/contracts/math/SafeMath.sol\";\n\nlibrary UniswapV2Library {\n  using SafeMath for uint256;\n\n  // returns sorted token addresses, used to handle return values from pairs sorted in this order\n  function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {\n    require(tokenA != tokenB, \"UniswapV2Library: IDENTICAL_ADDRESSES\");\n    (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);\n    require(token0 != address(0), \"UniswapV2Library: ZERO_ADDRESS\");\n  }\n\n  // calculates the CREATE2 address for a pair without making any external calls\n  function pairFor(\n    address factory,\n    address tokenA,\n    address tokenB\n  ) internal pure returns (address pair) {\n    (address token0, address token1) = sortTokens(tokenA, tokenB);\n    pair = address(\n      uint160(\n        uint256(\n          keccak256(\n            abi.encodePacked(\n              hex\"ff\",\n              factory,\n              keccak256(abi.encodePacked(token0, token1)),\n              hex\"96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f\" // init code hash\n            )\n          )\n        )\n      )\n    );\n  }\n\n  // fetches and sorts the reserves for a pair\n  function getReserves(\n    address factory,\n    address tokenA,\n    address tokenB\n  ) internal view returns (uint256 reserveA, uint256 reserveB) {\n    (address token0, ) = sortTokens(tokenA, tokenB);\n    (uint256 reserve0, uint256 reserve1, ) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();\n    (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);\n  }\n\n  // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset\n  function quote(\n    uint256 amountA,\n    uint256 reserveA,\n    uint256 reserveB\n  ) internal pure returns (uint256 amountB) {\n    require(amountA > 0, \"UniswapV2Library: INSUFFICIENT_AMOUNT\");\n    require(reserveA > 0 && reserveB > 0, \"UniswapV2Library: INSUFFICIENT_LIQUIDITY\");\n    amountB = amountA.mul(reserveB) / reserveA;\n  }\n}\n"
    },
    "contracts/libraries/ZeroLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.5.0 <0.8.0;\n\n/**\n@title helper functions for the Zero contract suite\n@author raymondpulver\n*/\nlibrary ZeroLib {\n  enum LoanStatusCode {\n    UNINITIALIZED,\n    UNPAID,\n    PAID\n  }\n  struct LoanParams {\n    address to;\n    address asset;\n    uint256 amount;\n    uint256 nonce;\n    address module;\n    bytes data;\n  }\n  struct MetaParams {\n    address from;\n    uint256 nonce;\n    bytes data;\n    address module;\n    address asset;\n  }\n  struct LoanStatus {\n    address underwriter;\n    LoanStatusCode status;\n  }\n  struct BalanceSheet {\n    uint128 loaned;\n    uint128 required;\n    uint256 repaid;\n  }\n}\n"
    },
    "contracts/interfaces/IERC2612Permit.sol": {
      "content": "interface IERC2612Permit {\n  /**\n   * @dev Sets `amount` 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   * - `owner` cannot be the zero address.\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 holder,\n    address spender,\n    uint256 nonce,\n    uint256 expiry,\n    bool allowed,\n    uint8 v,\n    bytes32 r,\n    bytes32 s\n  ) external;\n\n  function permit(\n    address holder,\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 ERC2612 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  function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"
    },
    "contracts/interfaces/CurvePools/IRenCrv.sol": {
      "content": "interface IRenCrv {\n  function exchange(\n    int128 i,\n    int128 j,\n    uint256 dx,\n    uint256 min_dy\n  ) external;\n}\n"
    },
    "contracts/libraries/SplitSignatureLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0;\n\nlibrary SplitSignatureLib {\n  function splitSignature(bytes memory signature)\n    internal\n    pure\n    returns (\n      uint8 v,\n      bytes32 r,\n      bytes32 s\n    )\n  {\n    if (signature.length == 65) {\n      assembly {\n        r := mload(add(signature, 0x20))\n        s := mload(add(signature, 0x40))\n        v := byte(0, mload(add(signature, 0x60)))\n      }\n    } else if (signature.length == 64) {\n      assembly {\n        r := mload(add(signature, 0x20))\n        let vs := mload(add(signature, 0x40))\n        s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)\n        v := add(shr(255, vs), 27)\n      }\n    }\n  }\n}\n"
    },
    "contracts/interfaces/IBadgerSettPeak.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0;\n\ninterface IBadgerSettPeak {\n  function mint(\n    uint256,\n    uint256,\n    bytes32[] calldata\n  ) external returns (uint256);\n\n  function redeem(uint256, uint256) external returns (uint256);\n}\n"
    },
    "contracts/interfaces/IWETH.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.5.0 <0.8.0;\n\ninterface IWETH {\n  function withdraw(uint256) external;\n}\n"
    },
    "contracts/interfaces/ICurveFi.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0;\n\ninterface ICurveFi {\n  function add_liquidity(uint256[2] calldata amounts, uint256 idx) external;\n\n  function remove_liquidity_one_coin(\n    uint256,\n    int128,\n    uint256\n  ) external;\n}\n"
    },
    "contracts/interfaces/IGateway.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\ninterface IMintGateway {\n  function mint(\n    bytes32 _pHash,\n    uint256 _amount,\n    bytes32 _nHash,\n    bytes calldata _sig\n  ) external returns (uint256);\n\n  function mintFee() external view returns (uint256);\n}\n\ninterface IBurnGateway {\n  function burn(bytes memory _to, uint256 _amountScaled) external returns (uint256);\n\n  function burnFee() external view returns (uint256);\n}\n\ninterface IGateway is IMintGateway, IBurnGateway {\n\n}\n\n/*\ninterface IGateway is IMintGateway, IBurnGateway {\n    function mint(\n        bytes32 _pHash,\n        uint256 _amount,\n        bytes32 _nHash,\n        bytes calldata _sig\n    ) external returns (uint256);\n\n    function mintFee() external view returns (uint256);\n\n    function burn(bytes calldata _to, uint256 _amountScaled)\n        external\n        returns (uint256);\n\n    function burnFee() external view returns (uint256);\n}\n*/\n"
    },
    "contracts/interfaces/CurvePools/ICurveTricrypto.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\n\ninterface ICurveTricrypto {\n  function exchange(\n    uint256 i,\n    uint256 j,\n    uint256 dx,\n    uint256 min_dy,\n    bool use_eth\n  ) external payable;\n}\n"
    },
    "@openzeppelin/contracts/token/ERC20/IERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\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 `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, 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 `sender` to `recipient` 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(address sender, address recipient, uint256 amount) external returns (bool);\n\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"
    },
    "contracts/interfaces/IyVault.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\n\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\n\nabstract contract IyVault is IERC20 {\n  function pricePerShare() external view virtual returns (uint256);\n\n  function getPricePerFullShare() external view virtual returns (uint256);\n\n  function totalAssets() external view virtual returns (uint256);\n\n  function deposit(uint256 _amount) external virtual returns (uint256);\n\n  function withdraw(uint256 maxShares) external virtual returns (uint256);\n\n  function want() external virtual returns (address);\n\n  function decimals() external view virtual returns (uint8);\n}\n"
    },
    "contracts/interfaces/ISett.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0;\n\ninterface ISett {\n  function deposit(uint256) external;\n\n  function withdraw(uint256) external;\n}\n"
    },
    "@openzeppelin/contracts/math/Math.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a >= b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow, so we distribute\n        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);\n    }\n}\n"
    },
    "@openzeppelin/contracts/math/SafeMath.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        uint256 c = a + b;\n        if (c < a) return (false, 0);\n        return (true, c);\n    }\n\n    /**\n     * @dev Returns the substraction of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b > a) return (false, 0);\n        return (true, a - b);\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) return (true, 0);\n        uint256 c = a * b;\n        if (c / a != b) return (false, 0);\n        return (true, c);\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b == 0) return (false, 0);\n        return (true, a / b);\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b == 0) return (false, 0);\n        return (true, a % b);\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, \"SafeMath: addition overflow\");\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b <= a, \"SafeMath: subtraction overflow\");\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (a == 0) return 0;\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n        return c;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b > 0, \"SafeMath: division by zero\");\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b > 0, \"SafeMath: modulo by zero\");\n        return a % b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {trySub}.\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryDiv}.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b > 0, errorMessage);\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting with custom message when dividing by zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryMod}.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b > 0, errorMessage);\n        return a % b;\n    }\n}\n"
    },
    "@openzeppelin/contracts/token/ERC20/SafeERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"../../math/SafeMath.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 SafeMath for uint256;\n    using Address for address;\n\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) 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(IERC20 token, address spender, uint256 value) 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        // solhint-disable-next-line max-line-length\n        require((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(IERC20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).add(value);\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).sub(value, \"SafeERC20: decreased allowance below zero\");\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\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) { // Return data is optional\n            // solhint-disable-next-line max-line-length\n            require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n        }\n    }\n}\n"
    },
    "@openzeppelin/contracts/cryptography/ECDSA.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        // Check the signature length\n        if (signature.length != 65) {\n            revert(\"ECDSA: invalid signature length\");\n        }\n\n        // Divide the signature in r, s and v variables\n        bytes32 r;\n        bytes32 s;\n        uint8 v;\n\n        // ecrecover takes the signature parameters, and the only way to get them\n        // currently is to use assembly.\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            r := mload(add(signature, 0x20))\n            s := mload(add(signature, 0x40))\n            v := byte(0, mload(add(signature, 0x60)))\n        }\n\n        return recover(hash, v, r, s);\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover-bytes32-bytes-} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, \"ECDSA: invalid signature 's' value\");\n        require(v == 27 || v == 28, \"ECDSA: invalid signature 'v' value\");\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        require(signer != address(0), \"ECDSA: invalid signature\");\n\n        return signer;\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n     * replicates the behavior of the\n     * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]\n     * JSON-RPC method.\n     *\n     * See {recover}.\n     */\n    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n        // 32 is the length in bytes of hash,\n        // enforced by the type signature above\n        return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n    }\n}\n"
    },
    "@openzeppelin/contracts-upgradeable/drafts/EIP712Upgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\nimport \"../proxy/Initializable.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,\n * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding\n * they need in their contracts using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * _Available since v3.4._\n */\nabstract contract EIP712Upgradeable is Initializable {\n    /* solhint-disable var-name-mixedcase */\n    bytes32 private _HASHED_NAME;\n    bytes32 private _HASHED_VERSION;\n    bytes32 private constant _TYPE_HASH = keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n    /* solhint-enable var-name-mixedcase */\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    function __EIP712_init(string memory name, string memory version) internal initializer {\n        __EIP712_init_unchained(name, version);\n    }\n\n    function __EIP712_init_unchained(string memory name, string memory version) internal initializer {\n        bytes32 hashedName = keccak256(bytes(name));\n        bytes32 hashedVersion = keccak256(bytes(version));\n        _HASHED_NAME = hashedName;\n        _HASHED_VERSION = hashedVersion;\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());\n    }\n\n    function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {\n        return keccak256(\n            abi.encode(\n                typeHash,\n                name,\n                version,\n                _getChainId(),\n                address(this)\n            )\n        );\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19\\x01\", _domainSeparatorV4(), structHash));\n    }\n\n    function _getChainId() private view returns (uint256 chainId) {\n        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            chainId := chainid()\n        }\n    }\n\n    /**\n     * @dev The hash of the name parameter for the EIP712 domain.\n     *\n     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\n     * are a concern.\n     */\n    function _EIP712NameHash() internal virtual view returns (bytes32) {\n        return _HASHED_NAME;\n    }\n\n    /**\n     * @dev The hash of the version parameter for the EIP712 domain.\n     *\n     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\n     * are a concern.\n     */\n    function _EIP712VersionHash() internal virtual view returns (bytes32) {\n        return _HASHED_VERSION;\n    }\n    uint256[50] private __gap;\n}\n"
    },
    "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol": {
      "content": "pragma solidity >=0.6.2;\n\ninterface IUniswapV2Router01 {\n    function factory() external pure returns (address);\n    function WETH() external pure returns (address);\n\n    function addLiquidity(\n        address tokenA,\n        address tokenB,\n        uint amountADesired,\n        uint amountBDesired,\n        uint amountAMin,\n        uint amountBMin,\n        address to,\n        uint deadline\n    ) external returns (uint amountA, uint amountB, uint liquidity);\n    function addLiquidityETH(\n        address token,\n        uint amountTokenDesired,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline\n    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);\n    function removeLiquidity(\n        address tokenA,\n        address tokenB,\n        uint liquidity,\n        uint amountAMin,\n        uint amountBMin,\n        address to,\n        uint deadline\n    ) external returns (uint amountA, uint amountB);\n    function removeLiquidityETH(\n        address token,\n        uint liquidity,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline\n    ) external returns (uint amountToken, uint amountETH);\n    function removeLiquidityWithPermit(\n        address tokenA,\n        address tokenB,\n        uint liquidity,\n        uint amountAMin,\n        uint amountBMin,\n        address to,\n        uint deadline,\n        bool approveMax, uint8 v, bytes32 r, bytes32 s\n    ) external returns (uint amountA, uint amountB);\n    function removeLiquidityETHWithPermit(\n        address token,\n        uint liquidity,\n        uint amountTokenMin,\n        uint amountETHMin,\n        address to,\n        uint deadline,\n        bool approveMax, uint8 v, bytes32 r, bytes32 s\n    ) external returns (uint amountToken, uint amountETH);\n    function swapExactTokensForTokens(\n        uint amountIn,\n        uint amountOutMin,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external returns (uint[] memory amounts);\n    function swapTokensForExactTokens(\n        uint amountOut,\n        uint amountInMax,\n        address[] calldata path,\n        address to,\n        uint deadline\n    ) external returns (uint[] memory amounts);\n    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)\n        external\n        payable\n        returns (uint[] memory amounts);\n    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\n        external\n        returns (uint[] memory amounts);\n    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\n        external\n        returns (uint[] memory amounts);\n    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)\n        external\n        payable\n        returns (uint[] memory amounts);\n\n    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);\n    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);\n    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);\n    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);\n    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);\n}\n"
    },
    "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol": {
      "content": "// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\n/// @title Callback for IUniswapV3PoolActions#swap\n/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface\ninterface IUniswapV3SwapCallback {\n    /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.\n    /// @dev In the implementation you must pay the pool tokens owed for the swap.\n    /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.\n    /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.\n    /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by\n    /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.\n    /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by\n    /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.\n    /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call\n    function uniswapV3SwapCallback(\n        int256 amount0Delta,\n        int256 amount1Delta,\n        bytes calldata data\n    ) external;\n}\n"
    },
    "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol": {
      "content": "pragma solidity >=0.5.0;\n\ninterface IUniswapV2Pair {\n    event Approval(address indexed owner, address indexed spender, uint value);\n    event Transfer(address indexed from, address indexed to, uint value);\n\n    function name() external pure returns (string memory);\n    function symbol() external pure returns (string memory);\n    function decimals() external pure returns (uint8);\n    function totalSupply() external view returns (uint);\n    function balanceOf(address owner) external view returns (uint);\n    function allowance(address owner, address spender) external view returns (uint);\n\n    function approve(address spender, uint value) external returns (bool);\n    function transfer(address to, uint value) external returns (bool);\n    function transferFrom(address from, address to, uint value) external returns (bool);\n\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n    function PERMIT_TYPEHASH() external pure returns (bytes32);\n    function nonces(address owner) external view returns (uint);\n\n    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;\n\n    event Mint(address indexed sender, uint amount0, uint amount1);\n    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);\n    event Swap(\n        address indexed sender,\n        uint amount0In,\n        uint amount1In,\n        uint amount0Out,\n        uint amount1Out,\n        address indexed to\n    );\n    event Sync(uint112 reserve0, uint112 reserve1);\n\n    function MINIMUM_LIQUIDITY() external pure returns (uint);\n    function factory() external view returns (address);\n    function token0() external view returns (address);\n    function token1() external view returns (address);\n    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\n    function price0CumulativeLast() external view returns (uint);\n    function price1CumulativeLast() external view returns (uint);\n    function kLast() external view returns (uint);\n\n    function mint(address to) external returns (uint liquidity);\n    function burn(address to) external returns (uint amount0, uint amount1);\n    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;\n    function skim(address to) external;\n    function sync() external;\n\n    function initialize(address, address) external;\n}\n"
    },
    "oz410/token/ERC20/IERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\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 `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, 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 `sender` to `recipient` 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(address sender, address recipient, uint256 amount) external returns (bool);\n\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"
    },
    "@openzeppelin/contracts/utils/Address.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.2 <0.8.0;\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    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        // solhint-disable-next-line no-inline-assembly\n        assembly { size := extcodesize(account) }\n        return size > 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        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\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 functionCall(target, data, \"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(address target, bytes memory data, string memory errorMessage) 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(address target, bytes memory data, uint256 value) 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(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.call{ value: value }(data);\n        return _verifyCallResult(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(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return _verifyCallResult(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(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n        require(isContract(target), \"Address: delegate call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return _verifyCallResult(success, returndata, errorMessage);\n    }\n\n    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\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\n                // solhint-disable-next-line no-inline-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}\n"
    },
    "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\n// solhint-disable-next-line compiler-version\npragma solidity >=0.4.24 <0.8.0;\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 a proxied contract can't have 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 * 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 {UpgradeableProxy-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 */\nabstract contract Initializable {\n\n    /**\n     * @dev Indicates that the contract has been initialized.\n     */\n    bool 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 Modifier to protect an initializer function from being invoked twice.\n     */\n    modifier initializer() {\n        require(_initializing || _isConstructor() || !_initialized, \"Initializable: contract is already initialized\");\n\n        bool isTopLevelCall = !_initializing;\n        if (isTopLevelCall) {\n            _initializing = true;\n            _initialized = true;\n        }\n\n        _;\n\n        if (isTopLevelCall) {\n            _initializing = false;\n        }\n    }\n\n    /// @dev Returns true if and only if the function is running in the constructor\n    function _isConstructor() private view returns (bool) {\n        return !AddressUpgradeable.isContract(address(this));\n    }\n}\n"
    },
    "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\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    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        // solhint-disable-next-line no-inline-assembly\n        assembly { size := extcodesize(account) }\n        return size > 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        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\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 functionCall(target, data, \"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(address target, bytes memory data, string memory errorMessage) 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(address target, bytes memory data, uint256 value) 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(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.call{ value: value }(data);\n        return _verifyCallResult(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(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return _verifyCallResult(success, returndata, errorMessage);\n    }\n\n    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\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\n                // solhint-disable-next-line no-inline-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}\n"
    },
    "contracts/test/DummyBurnCaller.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.9.0;\nimport { BadgerBridgeZeroController } from \"../controllers/BadgerBridgeZeroController.sol\";\nimport { IERC2612Permit } from \"../interfaces/IERC2612Permit.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"../libraries/SplitSignatureLib.sol\";\n\ncontract DummyBurnCaller {\n  constructor(address controller, address renzec) {\n    IERC20(renzec).approve(controller, ~uint256(0) >> 2);\n  }\n\n  function callBurn(\n    address controller,\n    address from,\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    bytes memory signature,\n    bytes memory destination\n  ) public {\n    (uint8 v, bytes32 r, bytes32 s) = SplitSignatureLib.splitSignature(signature);\n    uint256 nonce = IERC2612Permit(asset).nonces(from);\n    IERC2612Permit(asset).permit(from, address(this), nonce, deadline, true, v, r, s);\n    address payable _controller = address(uint160(controller));\n    BadgerBridgeZeroController(_controller).burnApproved(from, asset, amount, 1, destination);\n  }\n}\n"
    },
    "contracts/controllers/ZeroController.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\nimport { EIP712Upgradeable } from \"@openzeppelin/contracts-upgradeable/drafts/EIP712Upgradeable.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/ERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IZeroMeta } from \"../interfaces/IZeroMeta.sol\";\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\nimport { ZeroUnderwriterLock } from \"../underwriter/ZeroUnderwriterLock.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\nimport { OwnableUpgradeable } from \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\nimport { ControllerUpgradeable } from \"./ControllerUpgradeable.sol\";\nimport { EIP712 } from \"oz410/drafts/EIP712.sol\";\nimport { ECDSA } from \"oz410/cryptography/ECDSA.sol\";\nimport { FactoryLib } from \"../libraries/factory/FactoryLib.sol\";\nimport { SplitSignatureLib } from \"../libraries/SplitSignatureLib.sol\";\nimport { ZeroUnderwriterLockBytecodeLib } from \"../libraries/bytecode/ZeroUnderwriterLockBytecodeLib.sol\";\nimport { IGateway } from \"../interfaces/IGateway.sol\";\nimport { IGatewayRegistry } from \"../interfaces/IGatewayRegistry.sol\";\nimport { IStrategy } from \"../interfaces/IStrategy.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { LockForImplLib } from \"../libraries/LockForImplLib.sol\";\nimport { IERC2612Permit } from \"../interfaces/IERC2612Permit.sol\";\nimport \"../interfaces/IConverter.sol\";\nimport { ZeroControllerTemplate } from \"./ZeroControllerTemplate.sol\";\nimport \"@openzeppelin/contracts/math/Math.sol\";\nimport \"hardhat/console.sol\";\n\n/**\n@title upgradeable contract which determines the authority of a given address to sign off on loans\n@author raymondpulver\n*/\ncontract ZeroController is ZeroControllerTemplate {\n  using SafeMath for uint256;\n  using SafeERC20 for *;\n\n  function getChainId() internal view returns (uint8 response) {\n    assembly {\n      response := chainid()\n    }\n  }\n\n  function setFee(uint256 _fee) public {\n    require(msg.sender == governance, \"!governance\");\n    fee = _fee;\n  }\n\n  function approveModule(address module, bool isApproved) public virtual {\n    require(msg.sender == governance, \"!governance\");\n    approvedModules[module] = isApproved;\n  }\n\n  function setBaseFeeByAsset(address _asset, uint256 _fee) public {\n    require(msg.sender == governance, \"!governance\");\n    baseFeeByAsset[_asset] = _fee;\n  }\n\n  function deductFee(uint256 _amount, address _asset) internal view returns (uint256 result) {\n    result = _amount.mul(uint256(1 ether).sub(fee)).div(uint256(1 ether)).sub(baseFeeByAsset[_asset]);\n  }\n\n  function addFee(uint256 _amount, address _asset) internal view returns (uint256 result) {\n    result = _amount.mul(uint256(1 ether).add(fee)).div(uint256(1 ether)).add(baseFeeByAsset[_asset]);\n  }\n\n  function initialize(address _rewards, address _gatewayRegistry) public {\n    __Ownable_init_unchained();\n    __Controller_init_unchained(_rewards);\n    __EIP712_init_unchained(\"ZeroController\", \"1\");\n    gatewayRegistry = _gatewayRegistry;\n    underwriterLockImpl = FactoryLib.deployImplementation(\n      ZeroUnderwriterLockBytecodeLib.get(),\n      \"zero.underwriter.lock-implementation\"\n    );\n\n    maxGasPrice = 100e9;\n    maxGasRepay = 250000;\n    maxGasLoan = 500000;\n  }\n\n  modifier onlyUnderwriter() {\n    require(ownerOf[uint256(uint160(address(lockFor(msg.sender))))] != address(0x0), \"must be called by underwriter\");\n    _;\n  }\n\n  function setGasParameters(\n    uint256 _maxGasPrice,\n    uint256 _maxGasRepay,\n    uint256 _maxGasLoan,\n    uint256 _maxGasBurn\n  ) public {\n    require(msg.sender == governance, \"!governance\");\n    maxGasPrice = _maxGasPrice;\n    maxGasRepay = _maxGasRepay;\n    maxGasLoan = _maxGasLoan;\n    maxGasBurn = _maxGasBurn;\n  }\n\n  function balanceOf(address _owner) public view override returns (uint256 result) {\n    result = _balanceOf(_owner);\n  }\n\n  function lockFor(address underwriter) public view returns (ZeroUnderwriterLock result) {\n    result = LockForImplLib.lockFor(address(this), underwriterLockImpl, underwriter);\n  }\n\n  function mint(address underwriter, address vault) public virtual {\n    address lock = FactoryLib.deploy(underwriterLockImpl, bytes32(uint256(uint160(underwriter))));\n    ZeroUnderwriterLock(lock).initialize(vault);\n    ownerOf[uint256(uint160(lock))] = msg.sender;\n  }\n\n  function _typedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\n    return keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n  }\n\n  function fallbackMint(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public {\n    ZeroLib.LoanParams memory params = ZeroLib.LoanParams({\n      to: to,\n      asset: asset,\n      amount: amount,\n      nonce: nonce,\n      module: module,\n      data: data\n    });\n    bytes32 digest = toTypedDataHash(params, underwriter);\n    require(loanStatus[digest].status == ZeroLib.LoanStatusCode.UNINITIALIZED, \"loan already exists\");\n    uint256 _actualAmount = IGateway(IGatewayRegistry(gatewayRegistry).getGatewayByToken(asset)).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    delete (loanStatus[digest]);\n    IERC20(asset).safeTransfer(to, _actualAmount);\n  }\n\n  function repay(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public {\n    uint256 _gasBefore = gasleft();\n    ZeroLib.LoanParams memory params = ZeroLib.LoanParams({\n      to: to,\n      asset: asset,\n      amount: amount,\n      nonce: nonce,\n      module: module,\n      data: data\n    });\n    bytes32 digest = toTypedDataHash(params, underwriter);\n    require(loanStatus[digest].status == ZeroLib.LoanStatusCode.UNPAID, \"loan is not in the UNPAID state\");\n\n    ZeroUnderwriterLock lock = ZeroUnderwriterLock(lockFor(msg.sender));\n    lock.trackIn(actualAmount);\n    uint256 _mintAmount = IGateway(IGatewayRegistry(gatewayRegistry).getGatewayByToken(asset)).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    IZeroModule(module).repayLoan(params.to, asset, _mintAmount, nonce, data);\n    depositAll(asset);\n    uint256 _gasRefund = Math.min(_gasBefore.sub(gasleft()), maxGasLoan).mul(maxGasPrice);\n    IStrategy(strategies[params.asset]).permissionedEther(tx.origin, _gasRefund);\n  }\n\n  function depositAll(address _asset) internal {\n    // deposit all of the asset in the vault\n    uint256 _balance = IERC20(_asset).balanceOf(address(this));\n    IERC20(_asset).safeTransfer(strategies[_asset], _balance);\n  }\n\n  function toTypedDataHash(ZeroLib.LoanParams memory params, address underwriter)\n    internal\n    view\n    returns (bytes32 result)\n  {\n    bytes32 digest = _hashTypedDataV4(\n      keccak256(\n        abi.encode(\n          keccak256(\n            \"TransferRequest(address asset,uint256 amount,address underwriter,address module,uint256 nonce,bytes data)\"\n          ),\n          params.asset,\n          params.amount,\n          underwriter,\n          params.module,\n          params.nonce,\n          keccak256(params.data)\n        )\n      )\n    );\n    return digest;\n  }\n\n  function toMetaTypedDataHash(ZeroLib.MetaParams memory params, address underwriter)\n    internal\n    view\n    returns (bytes32 result)\n  {\n    result = _hashTypedDataV4(\n      keccak256(\n        abi.encode(\n          keccak256(\"MetaRequest(address asset,address underwriter,address module,uint256 nonce,bytes data)\"),\n          params.asset,\n          underwriter,\n          params.module,\n          params.nonce,\n          keccak256(params.data)\n        )\n      )\n    );\n  }\n\n  function convertGasUsedToRen(uint256 _gasUsed, address asset) internal view returns (uint256 gasUsedInRen) {\n    address converter = converters[IStrategy(strategies[asset]).nativeWrapper()][\n      IStrategy(strategies[asset]).vaultWant()\n    ];\n    gasUsedInRen = IConverter(converter).estimate(_gasUsed); //convert txGas from ETH to wBTC\n    gasUsedInRen = IConverter(converters[IStrategy(strategies[asset]).vaultWant()][asset]).estimate(gasUsedInRen);\n    // ^convert txGas from wBTC to renBTC\n  }\n\n  function loan(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 nonce,\n    address module,\n    bytes memory data,\n    bytes memory userSignature\n  ) public onlyUnderwriter {\n    require(approvedModules[module], \"!approved\");\n    uint256 _gasBefore = gasleft();\n    ZeroLib.LoanParams memory params = ZeroLib.LoanParams({\n      to: to,\n      asset: asset,\n      amount: amount,\n      nonce: nonce,\n      module: module,\n      data: data\n    });\n    bytes32 digest = toTypedDataHash(params, msg.sender);\n    require(ECDSA.recover(digest, userSignature) == params.to, \"invalid signature\");\n    require(loanStatus[digest].status == ZeroLib.LoanStatusCode.UNINITIALIZED, \"already spent this loan\");\n    loanStatus[digest] = ZeroLib.LoanStatus({ underwriter: msg.sender, status: ZeroLib.LoanStatusCode.UNPAID });\n    uint256 actual = params.amount.sub(params.amount.mul(uint256(25e15)).div(1e18));\n\n    ZeroUnderwriterLock(lockFor(msg.sender)).trackOut(params.module, actual);\n    uint256 _txGas = maxGasPrice.mul(maxGasRepay.add(maxGasLoan));\n    _txGas = convertGasUsedToRen(_txGas, params.asset);\n    // ^convert txGas from ETH to renBTC\n    uint256 _amountSent = IStrategy(strategies[params.asset]).permissionedSend(\n      module,\n      deductFee(params.amount, params.asset).sub(_txGas)\n    );\n    IZeroModule(module).receiveLoan(params.to, params.asset, _amountSent, params.nonce, params.data);\n    uint256 _gasRefund = Math.min(_gasBefore.sub(gasleft()), maxGasLoan).mul(maxGasPrice);\n    IStrategy(strategies[params.asset]).permissionedEther(tx.origin, _gasRefund);\n  }\n\n  struct MetaLocals {\n    uint256 gasUsed;\n    uint256 gasUsedInRen;\n    bytes32 digest;\n    uint256 txGas;\n    uint256 gasAtStart;\n    uint256 gasRefund;\n    uint256 balanceBefore;\n    uint256 renBalanceDiff;\n  }\n\n  function meta(\n    address from,\n    address asset,\n    address module,\n    uint256 nonce,\n    bytes memory data,\n    bytes memory signature\n  ) public onlyUnderwriter returns (uint256 gasValueAndFee) {\n    require(approvedModules[module], \"!approved\");\n    MetaLocals memory locals;\n    locals.gasAtStart = gasleft();\n    ZeroLib.MetaParams memory params = ZeroLib.MetaParams({\n      from: from,\n      asset: asset,\n      module: module,\n      nonce: nonce,\n      data: data\n    });\n\n    ZeroUnderwriterLock lock = ZeroUnderwriterLock(lockFor(msg.sender));\n    locals.digest = toMetaTypedDataHash(params, msg.sender);\n    address recovered = ECDSA.recover(locals.digest, signature);\n    require(recovered == params.from, \"invalid signature\");\n    IZeroMeta(module).receiveMeta(from, asset, nonce, data);\n    address converter = converters[IStrategy(strategies[params.asset]).nativeWrapper()][\n      IStrategy(strategies[params.asset]).vaultWant()\n    ];\n\n    //calculate gas used\n    locals.gasUsed = Math.min(locals.gasAtStart.sub(gasleft()), maxGasLoan);\n    locals.gasRefund = locals.gasUsed.mul(maxGasPrice);\n    locals.gasUsedInRen = convertGasUsedToRen(locals.gasRefund, params.asset);\n    //deduct fee on the gas amount\n    gasValueAndFee = addFee(locals.gasUsedInRen, params.asset);\n    //loan out gas\n    console.log(asset);\n    IStrategy(strategies[params.asset]).permissionedEther(tx.origin, locals.gasRefund);\n    locals.balanceBefore = IERC20(params.asset).balanceOf(address(this));\n    console.log(locals.balanceBefore);\n    lock.trackIn(gasValueAndFee);\n    IZeroMeta(module).repayMeta(gasValueAndFee);\n    locals.renBalanceDiff = IERC20(params.asset).balanceOf(address(this)).sub(locals.balanceBefore);\n    console.log(IERC20(params.asset).balanceOf(address(this)));\n    require(locals.renBalanceDiff >= locals.gasUsedInRen, \"not enough provided for gas\");\n    depositAll(params.asset);\n  }\n\n  function toERC20PermitDigest(\n    address token,\n    address owner,\n    address spender,\n    uint256 value,\n    uint256 deadline\n  ) internal view returns (bytes32 result) {\n    result = keccak256(\n      abi.encodePacked(\n        \"\\x19\\x01\",\n        IERC2612Permit(token).DOMAIN_SEPARATOR(),\n        keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, IERC2612Permit(token).nonces(owner), deadline))\n      )\n    );\n  }\n\n  function computeBurnNonce(\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    uint256 nonce,\n    bytes memory destination\n  ) public view returns (uint256 result) {\n    result = uint256(keccak256(abi.encodePacked(asset, amount, deadline, nonce, destination)));\n    while (result < block.timestamp) {\n      // negligible probability of this\n      result = uint256(keccak256(abi.encodePacked(result)));\n    }\n  }\n\n  function burn(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    bytes memory destination,\n    bytes memory signature\n  ) public onlyUnderwriter {\n    require(block.timestamp < deadline, \"!deadline\");\n    {\n      (uint8 v, bytes32 r, bytes32 s) = SplitSignatureLib.splitSignature(signature);\n      uint256 nonce = IERC2612Permit(asset).nonces(to);\n      IERC2612Permit(asset).permit(\n        to,\n        address(this),\n        nonce,\n        computeBurnNonce(asset, amount, deadline, nonce, destination),\n        true,\n        v,\n        r,\n        s\n      );\n    }\n    IERC20(asset).transferFrom(to, address(this), amount);\n    uint256 gasUsed = maxGasPrice.mul(maxGasRepay.add(maxGasBurn));\n    IStrategy(strategies[asset]).permissionedEther(tx.origin, gasUsed);\n    uint256 gasInRen = convertGasUsedToRen(gasUsed, asset);\n    uint256 actualAmount = deductFee(amount.sub(gasInRen), asset);\n    IGateway gateway = IGatewayRegistry(gatewayRegistry).getGatewayByToken(asset);\n    require(IERC20(asset).approve(address(gateway), actualAmount), \"!approve\");\n    gateway.burn(destination, actualAmount);\n    depositAll(asset);\n  }\n}\n"
    },
    "oz410/token/ERC20/ERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../../utils/Context.sol\";\nimport \"./IERC20.sol\";\nimport \"../../math/SafeMath.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20 {\n    using SafeMath for uint256;\n\n    mapping (address => uint256) private _balances;\n\n    mapping (address => mapping (address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n    uint8 private _decimals;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with\n     * a default value of 18.\n     *\n     * To select a different value for {decimals}, use {_setupDecimals}.\n     *\n     * All three of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor (string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n        _decimals = 18;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\n     * called.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return _decimals;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `recipient` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(_msgSender(), recipient, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        _approve(_msgSender(), spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * Requirements:\n     *\n     * - `sender` and `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``sender``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(sender, recipient, amount);\n        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \"ERC20: transfer amount exceeds allowance\"));\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \"ERC20: decreased allowance below zero\"));\n        return true;\n    }\n\n    /**\n     * @dev Moves tokens `amount` from `sender` to `recipient`.\n     *\n     * This is internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `sender` cannot be the zero address.\n     * - `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     */\n    function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n        require(sender != address(0), \"ERC20: transfer from the zero address\");\n        require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(sender, recipient, amount);\n\n        _balances[sender] = _balances[sender].sub(amount, \"ERC20: transfer amount exceeds balance\");\n        _balances[recipient] = _balances[recipient].add(amount);\n        emit Transfer(sender, recipient, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply = _totalSupply.add(amount);\n        _balances[account] = _balances[account].add(amount);\n        emit Transfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        _balances[account] = _balances[account].sub(amount, \"ERC20: burn amount exceeds balance\");\n        _totalSupply = _totalSupply.sub(amount);\n        emit Transfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Sets {decimals} to a value other than the default one of 18.\n     *\n     * WARNING: This function should only be called from the constructor. Most\n     * applications that interact with token contracts will not expect\n     * {decimals} to ever change, and may work incorrectly if it does.\n     */\n    function _setupDecimals(uint8 decimals_) internal virtual {\n        _decimals = decimals_;\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be to transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n}\n"
    },
    "oz410/token/ERC20/SafeERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"./IERC20.sol\";\nimport \"../../math/SafeMath.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 SafeMath for uint256;\n    using Address for address;\n\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) 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(IERC20 token, address spender, uint256 value) 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        // solhint-disable-next-line max-line-length\n        require((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(IERC20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).add(value);\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 newAllowance = token.allowance(address(this), spender).sub(value, \"SafeERC20: decreased allowance below zero\");\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\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) { // Return data is optional\n            // solhint-disable-next-line max-line-length\n            require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n        }\n    }\n}\n"
    },
    "contracts/interfaces/IZeroMeta.sol": {
      "content": "pragma solidity >=0.6.0;\n\ninterface IZeroMeta {\n  function receiveMeta(\n    address from,\n    address asset,\n    uint256 nonce,\n    bytes memory data\n  ) external;\n\n  function repayMeta(uint256 value) external;\n}\n"
    },
    "contracts/interfaces/IZeroModule.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0;\n\ninterface IZeroModule {\n  function repayLoan(\n    address _to,\n    address _asset,\n    uint256 _actualAmount,\n    uint256 _amount,\n    bytes memory _data\n  ) external;\n\n  function receiveLoan(\n    address _to,\n    address _asset,\n    uint256 _actual,\n    uint256 _nonce,\n    bytes memory _data\n  ) external;\n\n  function computeReserveRequirement(uint256 _in) external view returns (uint256);\n\n  function want() external view returns (address);\n}\n"
    },
    "contracts/underwriter/ZeroUnderwriterLock.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\nimport { Initializable } from \"oz410/proxy/Initializable.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/ERC20.sol\";\nimport { IERC721 } from \"oz410/token/ERC721/IERC721.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { IyVault } from \"../interfaces/IyVault.sol\";\nimport { ZeroController } from \"../controllers/ZeroController.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\n\nimport \"hardhat/console.sol\";\n\n/**\n@title contract to hold locked underwriter funds while the underwriter is active\n@author raymondpulver\n*/\ncontract ZeroUnderwriterLock is Initializable {\n  using SafeMath for *;\n  using SafeERC20 for *;\n  ZeroController public controller;\n  address public vault;\n  ZeroLib.BalanceSheet internal _balanceSheet;\n\n  modifier onlyController() {\n    require(msg.sender == address(controller), \"!controller\");\n    _;\n  }\n\n  modifier onlyOwner() {\n    require(msg.sender == owner(), \"must be called by owner\");\n    _;\n  }\n\n  function balanceSheet()\n    public\n    view\n    returns (\n      uint256 loaned,\n      uint256 required,\n      uint256 repaid\n    )\n  {\n    (loaned, required, repaid) = (uint256(_balanceSheet.loaned), uint256(_balanceSheet.required), _balanceSheet.repaid);\n  }\n\n  function owed() public view returns (uint256 result) {\n    if (_balanceSheet.loaned >= _balanceSheet.repaid) {\n      result = uint256(_balanceSheet.loaned).sub(_balanceSheet.repaid);\n    } else {\n      result = 0;\n    }\n  }\n\n  function reserve() public view returns (uint256 result) {\n    result = IyVault(vault).balanceOf(address(this)).mul(IyVault(vault).getPricePerFullShare()).div(uint256(1 ether));\n  }\n\n  function owner() public view returns (address result) {\n    result = IERC721(address(controller)).ownerOf(uint256(uint160(address(this))));\n  }\n\n  /**\n  @notice sets the owner to the ZeroUnderwriterNFT\n  @param _vault the address of the LP token which will be either burned or redeemed when the NFT is destroyed\n  */\n  function initialize(address _vault) public {\n    controller = ZeroController(msg.sender);\n    vault = _vault;\n  }\n\n  /**\n  @notice send back non vault tokens if they are stuck\n  @param _token the token to send the entire balance of to the sender\n  */\n  function skim(address _token) public {\n    require(address(vault) != _token, \"cannot skim vault token\");\n    IERC20(_token).safeTransfer(msg.sender, IERC20(_token).balanceOf(address(this)));\n  }\n\n  /**\n  @notice destroy this contract and send all vault tokens to NFT contract\n  */\n  function burn(address receiver) public onlyController {\n    require(\n      IyVault(vault).transfer(receiver, IyVault(vault).balanceOf(address(this))),\n      \"failed to transfer vault token to receiver\"\n    );\n    selfdestruct(payable(msg.sender));\n  }\n\n  function trackOut(address module, uint256 amount) public {\n    require(msg.sender == address(controller), \"!controller\");\n    uint256 loanedAfter = uint256(_balanceSheet.loaned).add(amount);\n    uint256 _owed = owed();\n    (_balanceSheet.loaned, _balanceSheet.required) = (\n      uint128(loanedAfter),\n      uint128(\n        uint256(_balanceSheet.required).mul(_owed).div(uint256(1 ether)).add(\n          IZeroModule(module).computeReserveRequirement(amount).mul(uint256(1 ether)).div(_owed.add(amount))\n        )\n      )\n    );\n  }\n\n  function _logSheet() internal view {\n    console.log(\"required\", _balanceSheet.required);\n    console.log(\"loaned\", _balanceSheet.loaned);\n    console.log(\"repaid\", _balanceSheet.repaid);\n  }\n\n  function trackIn(uint256 amount) public {\n    require(msg.sender == address(controller), \"!controller\");\n    uint256 _owed = owed();\n    uint256 _adjusted = uint256(_balanceSheet.required).mul(_owed).div(uint256(1 ether));\n    _balanceSheet.required = _owed < amount || _adjusted < amount\n      ? uint128(0)\n      : uint128(_adjusted.sub(amount).mul(uint256(1 ether)).div(_owed.sub(amount)));\n    _balanceSheet.repaid = _balanceSheet.repaid.add(amount);\n  }\n}\n"
    },
    "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/Initializable.sol\";\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 initializer {\n        __Context_init_unchained();\n        __Ownable_init_unchained();\n    }\n\n    function __Ownable_init_unchained() internal initializer {\n        address msgSender = _msgSender();\n        _owner = msgSender;\n        emit OwnershipTransferred(address(0), msgSender);\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 called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\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        emit OwnershipTransferred(_owner, address(0));\n        _owner = 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        emit OwnershipTransferred(_owner, newOwner);\n        _owner = newOwner;\n    }\n    uint256[49] private __gap;\n}\n"
    },
    "contracts/controllers/ControllerUpgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\nimport \"oz410/token/ERC20/IERC20.sol\";\nimport \"oz410/math/SafeMath.sol\";\nimport \"oz410/utils/Address.sol\";\nimport \"oz410/token/ERC20/SafeERC20.sol\";\nimport \"oz410/proxy/Initializable.sol\";\n\nimport \"../interfaces/IConverter.sol\";\nimport \"../interfaces/IOneSplitAudit.sol\";\nimport \"../interfaces/IStrategy.sol\";\n\ncontract ControllerUpgradeable {\n  using SafeERC20 for IERC20;\n  using Address for address;\n  using SafeMath for uint256;\n\n  address public governance;\n  address public strategist;\n\n  address public onesplit;\n  address public rewards;\n  mapping(address => address) public vaults;\n  mapping(address => address) public strategies;\n  mapping(address => mapping(address => address)) public converters;\n\n  mapping(address => mapping(address => bool)) public approvedStrategies;\n\n  uint256 public split = 500;\n  uint256 public constant max = 10000;\n\n  function __Controller_init_unchained(address _rewards) internal {\n    governance = msg.sender;\n    strategist = msg.sender;\n    onesplit = address(0x50FDA034C0Ce7a8f7EFDAebDA7Aa7cA21CC1267e);\n    rewards = _rewards;\n  }\n\n  function setRewards(address _rewards) public {\n    require(msg.sender == governance, \"!governance\");\n    rewards = _rewards;\n  }\n\n  function setStrategist(address _strategist) public {\n    require(msg.sender == governance, \"!governance\");\n    strategist = _strategist;\n  }\n\n  function setSplit(uint256 _split) public {\n    require(msg.sender == governance, \"!governance\");\n    split = _split;\n  }\n\n  function setOneSplit(address _onesplit) public {\n    require(msg.sender == governance, \"!governance\");\n    onesplit = _onesplit;\n  }\n\n  function setGovernance(address _governance) public {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function setVault(address _token, address _vault) public {\n    require(msg.sender == strategist || msg.sender == governance, \"!strategist\");\n    require(vaults[_token] == address(0), \"vault\");\n    vaults[_token] = _vault;\n  }\n\n  function approveStrategy(address _token, address _strategy) public {\n    require(msg.sender == governance, \"!governance\");\n    approvedStrategies[_token][_strategy] = true;\n  }\n\n  function revokeStrategy(address _token, address _strategy) public {\n    require(msg.sender == governance, \"!governance\");\n    approvedStrategies[_token][_strategy] = false;\n  }\n\n  function setConverter(\n    address _input,\n    address _output,\n    address _converter\n  ) public {\n    require(msg.sender == strategist || msg.sender == governance, \"!strategist\");\n    converters[_input][_output] = _converter;\n  }\n\n  function setStrategy(\n    address _token,\n    address _strategy,\n    bool _abandon\n  ) public {\n    require(msg.sender == strategist || msg.sender == governance, \"!strategist\");\n    require(approvedStrategies[_token][_strategy] == true, \"!approved\");\n\n    address _current = strategies[_token];\n    if (_current != address(0) || _abandon) {\n      IStrategy(_current).withdrawAll();\n    }\n    strategies[_token] = _strategy;\n  }\n\n  function earn(address _token, uint256 _amount) public {\n    address _strategy = strategies[_token];\n    address _want = IStrategy(_strategy).want();\n    if (_want != _token) {\n      address converter = converters[_token][_want];\n      IERC20(_token).safeTransfer(converter, _amount);\n      _amount = IConverter(converter).convert(_strategy);\n      IERC20(_want).safeTransfer(_strategy, _amount);\n    } else {\n      IERC20(_token).safeTransfer(_strategy, _amount);\n    }\n    IStrategy(_strategy).deposit();\n  }\n\n  function _balanceOf(address _token) internal view virtual returns (uint256) {\n    return IStrategy(strategies[_token]).balanceOf();\n  }\n\n  function balanceOf(address _token) public view virtual returns (uint256) {\n    return _balanceOf(_token);\n  }\n\n  function withdrawAll(address _token) public {\n    require(msg.sender == strategist || msg.sender == governance, \"!strategist\");\n    IStrategy(strategies[_token]).withdrawAll();\n  }\n\n  function inCaseTokensGetStuck(address _token, uint256 _amount) public {\n    require(msg.sender == strategist || msg.sender == governance, \"!governance\");\n    IERC20(_token).safeTransfer(msg.sender, _amount);\n  }\n\n  function inCaseStrategyTokenGetStuck(address _strategy, address _token) public {\n    require(msg.sender == strategist || msg.sender == governance, \"!governance\");\n    IStrategy(_strategy).withdraw(_token);\n  }\n\n  function getExpectedReturn(\n    address _strategy,\n    address _token,\n    uint256 parts\n  ) public view returns (uint256 expected) {\n    uint256 _balance = IERC20(_token).balanceOf(_strategy);\n    address _want = IStrategy(_strategy).want();\n    (expected, ) = IOneSplitAudit(onesplit).getExpectedReturn(_token, _want, _balance, parts, 0);\n  }\n\n  // Only allows to withdraw non-core strategy tokens ~ this is over and above normal yield\n  function yearn(\n    address _strategy,\n    address _token,\n    uint256 parts\n  ) public {\n    require(msg.sender == strategist || msg.sender == governance, \"!governance\");\n    // This contract should never have value in it, but just incase since this is a public call\n    uint256 _before = IERC20(_token).balanceOf(address(this));\n    IStrategy(_strategy).withdraw(_token);\n    uint256 _after = IERC20(_token).balanceOf(address(this));\n    if (_after > _before) {\n      uint256 _amount = _after.sub(_before);\n      address _want = IStrategy(_strategy).want();\n      uint256[] memory _distribution;\n      uint256 _expected;\n      _before = IERC20(_want).balanceOf(address(this));\n      IERC20(_token).safeApprove(onesplit, 0);\n      IERC20(_token).safeApprove(onesplit, _amount);\n      (_expected, _distribution) = IOneSplitAudit(onesplit).getExpectedReturn(_token, _want, _amount, parts, 0);\n      IOneSplitAudit(onesplit).swap(_token, _want, _amount, _expected, _distribution, 0);\n      _after = IERC20(_want).balanceOf(address(this));\n      if (_after > _before) {\n        _amount = _after.sub(_before);\n        uint256 _reward = _amount.mul(split).div(max);\n        earn(_want, _amount.sub(_reward));\n        IERC20(_want).safeTransfer(rewards, _reward);\n      }\n    }\n  }\n\n  function _withdraw(address _token, uint256 _amount) internal virtual {\n    IStrategy(strategies[_token]).withdraw(_amount);\n  }\n\n  function withdraw(address _token, uint256 _amount) public {\n    require(msg.sender == vaults[_token], \"!vault\");\n    _withdraw(_token, _amount);\n  }\n}\n"
    },
    "oz410/drafts/EIP712.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,\n * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding\n * they need in their contracts using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * _Available since v3.4._\n */\nabstract contract EIP712 {\n    /* solhint-disable var-name-mixedcase */\n    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to\n    // invalidate the cached domain separator if the chain id changes.\n    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;\n    uint256 private immutable _CACHED_CHAIN_ID;\n\n    bytes32 private immutable _HASHED_NAME;\n    bytes32 private immutable _HASHED_VERSION;\n    bytes32 private immutable _TYPE_HASH;\n    /* solhint-enable var-name-mixedcase */\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    constructor(string memory name, string memory version) {\n        bytes32 hashedName = keccak256(bytes(name));\n        bytes32 hashedVersion = keccak256(bytes(version));\n        bytes32 typeHash = keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n        _HASHED_NAME = hashedName;\n        _HASHED_VERSION = hashedVersion;\n        _CACHED_CHAIN_ID = _getChainId();\n        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);\n        _TYPE_HASH = typeHash;\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view virtual returns (bytes32) {\n        if (_getChainId() == _CACHED_CHAIN_ID) {\n            return _CACHED_DOMAIN_SEPARATOR;\n        } else {\n            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);\n        }\n    }\n\n    function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {\n        return keccak256(\n            abi.encode(\n                typeHash,\n                name,\n                version,\n                _getChainId(),\n                address(this)\n            )\n        );\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19\\x01\", _domainSeparatorV4(), structHash));\n    }\n\n    function _getChainId() private view returns (uint256 chainId) {\n        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            chainId := chainid()\n        }\n    }\n}\n"
    },
    "oz410/cryptography/ECDSA.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        // Check the signature length\n        if (signature.length != 65) {\n            revert(\"ECDSA: invalid signature length\");\n        }\n\n        // Divide the signature in r, s and v variables\n        bytes32 r;\n        bytes32 s;\n        uint8 v;\n\n        // ecrecover takes the signature parameters, and the only way to get them\n        // currently is to use assembly.\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            r := mload(add(signature, 0x20))\n            s := mload(add(signature, 0x40))\n            v := byte(0, mload(add(signature, 0x60)))\n        }\n\n        return recover(hash, v, r, s);\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover-bytes32-bytes-} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, \"ECDSA: invalid signature 's' value\");\n        require(v == 27 || v == 28, \"ECDSA: invalid signature 'v' value\");\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        require(signer != address(0), \"ECDSA: invalid signature\");\n\n        return signer;\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n     * replicates the behavior of the\n     * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]\n     * JSON-RPC method.\n     *\n     * See {recover}.\n     */\n    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n        // 32 is the length in bytes of hash,\n        // enforced by the type signature above\n        return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n    }\n}\n"
    },
    "contracts/libraries/factory/FactoryLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.5.0 <0.8.0;\n\nimport { Implementation } from \"./Implementation.sol\";\nimport { Create2 } from \"oz410/utils/Create2.sol\";\n\n/**\n@title clone factory library\n@notice deploys implementation or clones\n*/\nlibrary FactoryLib {\n  function assembleCreationCode(address implementation) internal pure returns (bytes memory result) {\n    result = new bytes(0x37);\n    bytes20 targetBytes = bytes20(implementation);\n    assembly {\n      let clone := add(result, 0x20)\n      mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n      mstore(add(clone, 0x14), targetBytes)\n      mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n    }\n  }\n\n  function computeAddress(\n    address creator,\n    address implementation,\n    bytes32 salt\n  ) internal pure returns (address result) {\n    result = Create2.computeAddress(salt, keccak256(assembleCreationCode(implementation)), creator);\n  }\n\n  function computeImplementationAddress(\n    address creator,\n    bytes32 bytecodeHash,\n    string memory id\n  ) internal pure returns (address result) {\n    result = Create2.computeAddress(keccak256(abi.encodePacked(id)), bytecodeHash, creator);\n  }\n\n  /// @notice Deploys a given master Contract as a clone.\n  /// Any ETH transferred with this call is forwarded to the new clone.\n  /// Emits `LogDeploy`.\n  /// @param implementation Address of implementation\n  /// @param salt Salt to use\n  /// @return cloneAddress Address of the created clone contract.\n  function deploy(address implementation, bytes32 salt) internal returns (address cloneAddress) {\n    bytes memory creationCode = assembleCreationCode(implementation);\n    assembly {\n      cloneAddress := create2(0, add(0x20, creationCode), 0x37, salt)\n    }\n  }\n\n  function deployImplementation(bytes memory creationCode, string memory id) internal returns (address implementation) {\n    bytes32 salt = keccak256(abi.encodePacked(id));\n    assembly {\n      implementation := create2(0, add(0x20, creationCode), mload(creationCode), salt)\n    }\n  }\n}\n"
    },
    "contracts/libraries/bytecode/ZeroUnderwriterLockBytecodeLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\nimport { ZeroUnderwriterLock } from \"../../underwriter/ZeroUnderwriterLock.sol\";\n\nlibrary ZeroUnderwriterLockBytecodeLib {\n  function get() external pure returns (bytes memory result) {\n    result = type(ZeroUnderwriterLock).creationCode;\n  }\n}\n"
    },
    "contracts/interfaces/IGatewayRegistry.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\n\nimport \"./IGateway.sol\";\n\n/// @notice GatewayRegistry is a mapping from assets to their associated\n/// RenERC20 and Gateway contracts.\ninterface IGatewayRegistry {\n  /// @dev The symbol is included twice because strings have to be hashed\n  /// first in order to be used as a log index/topic.\n  event LogGatewayRegistered(\n    string _symbol,\n    string indexed _indexedSymbol,\n    address indexed _tokenAddress,\n    address indexed _gatewayAddress\n  );\n  event LogGatewayDeregistered(\n    string _symbol,\n    string indexed _indexedSymbol,\n    address indexed _tokenAddress,\n    address indexed _gatewayAddress\n  );\n  event LogGatewayUpdated(\n    address indexed _tokenAddress,\n    address indexed _currentGatewayAddress,\n    address indexed _newGatewayAddress\n  );\n\n  /// @dev To get all the registered gateways use count = 0.\n  function getGateways(address _start, uint256 _count) external view returns (address[] memory);\n\n  /// @dev To get all the registered RenERC20s use count = 0.\n  function getRenTokens(address _start, uint256 _count) external view returns (address[] memory);\n\n  /// @notice Returns the Gateway contract for the given RenERC20\n  ///         address.\n  ///\n  /// @param _tokenAddress The address of the RenERC20 contract.\n  function getGatewayByToken(address _tokenAddress) external view returns (IGateway);\n\n  /// @notice Returns the Gateway contract for the given RenERC20\n  ///         symbol.\n  ///\n  /// @param _tokenSymbol The symbol of the RenERC20 contract.\n  function getGatewayBySymbol(string calldata _tokenSymbol) external view returns (IGateway);\n\n  /// @notice Returns the RenERC20 address for the given token symbol.\n  ///\n  /// @param _tokenSymbol The symbol of the RenERC20 contract to\n  ///        lookup.\n  function getTokenBySymbol(string calldata _tokenSymbol) external view returns (IERC20);\n}\n"
    },
    "contracts/interfaces/IStrategy.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\ninterface StrategyAPI {\n  function name() external view returns (string memory);\n\n  function vault() external view returns (address);\n\n  function nativeWrapper() external view returns (address);\n\n  function want() external view returns (address);\n\n  function vaultWant() external view returns (address);\n\n  function apiVersion() external pure returns (string memory);\n\n  function keeper() external view returns (address);\n\n  function isActive() external view returns (bool);\n\n  function delegatedAssets() external view returns (uint256);\n\n  function estimatedTotalAssets() external view returns (uint256);\n\n  function tendTrigger(uint256 callCost) external view returns (bool);\n\n  function tend() external;\n\n  function harvestTrigger(uint256 callCost) external view returns (bool);\n\n  function harvest() external;\n\n  event Harvested(uint256 profit, uint256 loss, uint256 debtPayment, uint256 debtOutstanding);\n}\n\nabstract contract IStrategy is StrategyAPI {\n  function permissionedSend(address _module, uint256 _amount) external virtual returns (uint256);\n\n  function withdrawAll() external virtual;\n\n  function deposit() external virtual;\n\n  function balanceOf() external view virtual returns (uint256);\n\n  function withdraw(uint256) external virtual;\n\n  function withdraw(address) external virtual;\n\n  function permissionedEther(address, uint256) external virtual;\n}\n"
    },
    "oz410/math/SafeMath.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        uint256 c = a + b;\n        if (c < a) return (false, 0);\n        return (true, c);\n    }\n\n    /**\n     * @dev Returns the substraction of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b > a) return (false, 0);\n        return (true, a - b);\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) return (true, 0);\n        uint256 c = a * b;\n        if (c / a != b) return (false, 0);\n        return (true, c);\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b == 0) return (false, 0);\n        return (true, a / b);\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b == 0) return (false, 0);\n        return (true, a % b);\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, \"SafeMath: addition overflow\");\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b <= a, \"SafeMath: subtraction overflow\");\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (a == 0) return 0;\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n        return c;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b > 0, \"SafeMath: division by zero\");\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b > 0, \"SafeMath: modulo by zero\");\n        return a % b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {trySub}.\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryDiv}.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b > 0, errorMessage);\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting with custom message when dividing by zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryMod}.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b > 0, errorMessage);\n        return a % b;\n    }\n}\n"
    },
    "contracts/libraries/LockForImplLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.5.0 <0.8.0;\n\nimport { FactoryLib } from \"./factory/FactoryLib.sol\";\nimport { ZeroUnderwriterLock } from \"../underwriter/ZeroUnderwriterLock.sol\";\n\n/**\n@title lockFor implementation\n@author raymondpulver\n*/\nlibrary LockForImplLib {\n  function lockFor(\n    address nft,\n    address underwriterLockImpl,\n    address underwriter\n  ) internal view returns (ZeroUnderwriterLock result) {\n    result = ZeroUnderwriterLock(\n      FactoryLib.computeAddress(nft, underwriterLockImpl, bytes32(uint256(uint160(underwriter))))\n    );\n  }\n}\n"
    },
    "contracts/interfaces/IConverter.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.5.0 <0.8.0;\n\ninterface IConverter {\n  function convert(address) external returns (uint256);\n\n  function estimate(uint256) external view returns (uint256);\n}\n"
    },
    "contracts/controllers/ZeroControllerTemplate.sol": {
      "content": "pragma solidity >=0.6.0;\nimport { OwnableUpgradeable } from \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\nimport { ControllerUpgradeable } from \"./ControllerUpgradeable.sol\";\nimport { EIP712Upgradeable } from \"@openzeppelin/contracts-upgradeable/drafts/EIP712Upgradeable.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\n\ncontract ZeroControllerTemplate is ControllerUpgradeable, OwnableUpgradeable, EIP712Upgradeable {\n  uint256 internal maxGasPrice = 100e9;\n  uint256 internal maxGasRepay = 250000;\n  uint256 internal maxGasLoan = 500000;\n  string internal constant UNDERWRITER_LOCK_IMPLEMENTATION_ID = \"zero.underwriter.lock-implementation\";\n  address internal underwriterLockImpl;\n  mapping(bytes32 => ZeroLib.LoanStatus) public loanStatus;\n  bytes32 internal constant ZERO_DOMAIN_SALT = 0xb225c57bf2111d6955b97ef0f55525b5a400dc909a5506e34b102e193dd53406;\n  bytes32 internal constant ZERO_DOMAIN_NAME_HASH = keccak256(\"ZeroController.RenVMBorrowMessage\");\n  bytes32 internal constant ZERO_DOMAIN_VERSION_HASH = keccak256(\"v2\");\n  bytes32 internal constant ZERO_RENVM_BORROW_MESSAGE_TYPE_HASH =\n    keccak256(\"RenVMBorrowMessage(address module,uint256 amount,address underwriter,uint256 pNonce,bytes pData)\");\n  bytes32 internal constant TYPE_HASH = keccak256(\"TransferRequest(address asset,uint256 amount)\");\n  bytes32 internal ZERO_DOMAIN_SEPARATOR;\n  bytes32 internal constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;\n  mapping(uint256 => address) public ownerOf;\n\n  uint256 public fee;\n  address public gatewayRegistry;\n  mapping(address => uint256) public baseFeeByAsset;\n  mapping(address => bool) public approvedModules;\n  uint256 internal maxGasBurn = 500000;\n}\n"
    },
    "hardhat/console.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >= 0.4.22 <0.9.0;\n\nlibrary console {\n\taddress constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);\n\n\tfunction _sendLogPayload(bytes memory payload) private view {\n\t\tuint256 payloadLength = payload.length;\n\t\taddress consoleAddress = CONSOLE_ADDRESS;\n\t\tassembly {\n\t\t\tlet payloadStart := add(payload, 32)\n\t\t\tlet r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)\n\t\t}\n\t}\n\n\tfunction log() internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log()\"));\n\t}\n\n\tfunction logInt(int p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(int)\", p0));\n\t}\n\n\tfunction logUint(uint p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint)\", p0));\n\t}\n\n\tfunction logString(string memory p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n\t}\n\n\tfunction logBool(bool p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n\t}\n\n\tfunction logAddress(address p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n\t}\n\n\tfunction logBytes(bytes memory p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n\t}\n\n\tfunction logBytes1(bytes1 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n\t}\n\n\tfunction logBytes2(bytes2 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n\t}\n\n\tfunction logBytes3(bytes3 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n\t}\n\n\tfunction logBytes4(bytes4 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n\t}\n\n\tfunction logBytes5(bytes5 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n\t}\n\n\tfunction logBytes6(bytes6 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n\t}\n\n\tfunction logBytes7(bytes7 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n\t}\n\n\tfunction logBytes8(bytes8 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n\t}\n\n\tfunction logBytes9(bytes9 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n\t}\n\n\tfunction logBytes10(bytes10 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n\t}\n\n\tfunction logBytes11(bytes11 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n\t}\n\n\tfunction logBytes12(bytes12 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n\t}\n\n\tfunction logBytes13(bytes13 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n\t}\n\n\tfunction logBytes14(bytes14 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n\t}\n\n\tfunction logBytes15(bytes15 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n\t}\n\n\tfunction logBytes16(bytes16 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n\t}\n\n\tfunction logBytes17(bytes17 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n\t}\n\n\tfunction logBytes18(bytes18 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n\t}\n\n\tfunction logBytes19(bytes19 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n\t}\n\n\tfunction logBytes20(bytes20 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n\t}\n\n\tfunction logBytes21(bytes21 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n\t}\n\n\tfunction logBytes22(bytes22 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n\t}\n\n\tfunction logBytes23(bytes23 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n\t}\n\n\tfunction logBytes24(bytes24 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n\t}\n\n\tfunction logBytes25(bytes25 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n\t}\n\n\tfunction logBytes26(bytes26 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n\t}\n\n\tfunction logBytes27(bytes27 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n\t}\n\n\tfunction logBytes28(bytes28 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n\t}\n\n\tfunction logBytes29(bytes29 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n\t}\n\n\tfunction logBytes30(bytes30 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n\t}\n\n\tfunction logBytes31(bytes31 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n\t}\n\n\tfunction logBytes32(bytes32 p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n\t}\n\n\tfunction log(uint p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint)\", p0));\n\t}\n\n\tfunction log(string memory p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n\t}\n\n\tfunction log(bool p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n\t}\n\n\tfunction log(address p0) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n\t}\n\n\tfunction log(uint p0, uint p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint)\", p0, p1));\n\t}\n\n\tfunction log(uint p0, string memory p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string)\", p0, p1));\n\t}\n\n\tfunction log(uint p0, bool p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool)\", p0, p1));\n\t}\n\n\tfunction log(uint p0, address p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address)\", p0, p1));\n\t}\n\n\tfunction log(string memory p0, uint p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint)\", p0, p1));\n\t}\n\n\tfunction log(string memory p0, string memory p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n\t}\n\n\tfunction log(string memory p0, bool p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n\t}\n\n\tfunction log(string memory p0, address p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n\t}\n\n\tfunction log(bool p0, uint p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint)\", p0, p1));\n\t}\n\n\tfunction log(bool p0, string memory p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n\t}\n\n\tfunction log(bool p0, bool p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n\t}\n\n\tfunction log(bool p0, address p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n\t}\n\n\tfunction log(address p0, uint p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint)\", p0, p1));\n\t}\n\n\tfunction log(address p0, string memory p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n\t}\n\n\tfunction log(address p0, bool p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n\t}\n\n\tfunction log(address p0, address p1) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n\t}\n\n\tfunction log(uint p0, uint p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, uint p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, uint p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, uint p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, string memory p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, string memory p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, string memory p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, string memory p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, bool p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, bool p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, bool p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, bool p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, address p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, address p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, address p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, address p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, uint p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, uint p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, uint p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, uint p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, string memory p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, string memory p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, string memory p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, string memory p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, bool p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, bool p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, bool p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, bool p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, address p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, address p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, address p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(string memory p0, address p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, uint p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, uint p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, uint p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, uint p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, string memory p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, string memory p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, string memory p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, string memory p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, bool p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, bool p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, bool p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, bool p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, address p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, address p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, address p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(bool p0, address p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, uint p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, uint p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, uint p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, uint p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, string memory p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, string memory p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, string memory p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, string memory p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, bool p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, bool p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, bool p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, bool p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, address p1, uint p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, address p1, string memory p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, address p1, bool p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n\t}\n\n\tfunction log(address p0, address p1, address p2) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n\t}\n\n\tfunction log(uint p0, uint p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, uint p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,uint,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, string memory p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,string,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, bool p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,bool,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(uint p0, address p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(uint,address,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, uint p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,uint,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, string memory p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, bool p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(string memory p0, address p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, uint p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,uint,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, string memory p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, bool p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(bool p0, address p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, uint p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,uint,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, string memory p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, bool p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, uint p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, uint p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, uint p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, uint p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, string memory p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, string memory p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, string memory p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, string memory p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, bool p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, bool p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, bool p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, bool p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, address p2, uint p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, address p2, string memory p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, address p2, bool p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n\t}\n\n\tfunction log(address p0, address p1, address p2, address p3) internal view {\n\t\t_sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n\t}\n\n}\n"
    },
    "oz410/utils/Context.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\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 GSN 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 Context {\n    function _msgSender() internal view virtual returns (address payable) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes memory) {\n        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n        return msg.data;\n    }\n}\n"
    },
    "oz410/utils/Address.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\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    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        // solhint-disable-next-line no-inline-assembly\n        assembly { size := extcodesize(account) }\n        return size > 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        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\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 functionCall(target, data, \"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(address target, bytes memory data, string memory errorMessage) 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(address target, bytes memory data, uint256 value) 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(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.call{ value: value }(data);\n        return _verifyCallResult(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(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return _verifyCallResult(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(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n        require(isContract(target), \"Address: delegate call to non-contract\");\n\n        // solhint-disable-next-line avoid-low-level-calls\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return _verifyCallResult(success, returndata, errorMessage);\n    }\n\n    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\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\n                // solhint-disable-next-line no-inline-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}\n"
    },
    "oz410/proxy/Initializable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\n// solhint-disable-next-line compiler-version\npragma solidity >=0.4.24 <0.8.0;\n\nimport \"../utils/Address.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 a proxied contract can't have 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 * 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 {UpgradeableProxy-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 */\nabstract contract Initializable {\n\n    /**\n     * @dev Indicates that the contract has been initialized.\n     */\n    bool 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 Modifier to protect an initializer function from being invoked twice.\n     */\n    modifier initializer() {\n        require(_initializing || _isConstructor() || !_initialized, \"Initializable: contract is already initialized\");\n\n        bool isTopLevelCall = !_initializing;\n        if (isTopLevelCall) {\n            _initializing = true;\n            _initialized = true;\n        }\n\n        _;\n\n        if (isTopLevelCall) {\n            _initializing = false;\n        }\n    }\n\n    /// @dev Returns true if and only if the function is running in the constructor\n    function _isConstructor() private view returns (bool) {\n        return !Address.isContract(address(this));\n    }\n}\n"
    },
    "oz410/token/ERC721/IERC721.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../../introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\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    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 tokenId) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the caller.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool _approved) external;\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n    /**\n      * @dev Safely transfers `tokenId` token from `from` to `to`.\n      *\n      * Requirements:\n      *\n      * - `from` cannot be the zero address.\n      * - `to` cannot be the zero address.\n      * - `tokenId` token must exist and be owned by `from`.\n      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n      *\n      * Emits a {Transfer} event.\n      */\n    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;\n}\n"
    },
    "oz410/introspection/IERC165.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"
    },
    "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\nimport \"../proxy/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 GSN 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 initializer {\n        __Context_init_unchained();\n    }\n\n    function __Context_init_unchained() internal initializer {\n    }\n    function _msgSender() internal view virtual returns (address payable) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes memory) {\n        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n        return msg.data;\n    }\n    uint256[50] private __gap;\n}\n"
    },
    "contracts/interfaces/IOneSplitAudit.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.5.0 <0.8.0;\n\ninterface IOneSplitAudit {\n  function swap(\n    address fromToken,\n    address destToken,\n    uint256 amount,\n    uint256 minReturn,\n    uint256[] calldata distribution,\n    uint256 flags\n  ) external payable returns (uint256 returnAmount);\n\n  function getExpectedReturn(\n    address fromToken,\n    address destToken,\n    uint256 amount,\n    uint256 parts,\n    uint256 flags // See constants in IOneSplit.sol\n  ) external view returns (uint256 returnAmount, uint256[] memory distribution);\n}\n"
    },
    "contracts/libraries/factory/Implementation.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.5.0 <0.8.0;\n\n/**\n@title must be inherited by a contract that will be deployed with ZeroFactoryLib\n@author raymondpulver\n*/\nabstract contract Implementation {\n  /**\n  @notice ensure the contract cannot be initialized twice\n  */\n  function lock() public virtual {\n    // no other logic\n  }\n}\n"
    },
    "oz410/utils/Create2.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\n * `CREATE2` can be used to compute in advance the address where a smart\n * contract will be deployed, which allows for interesting new mechanisms known\n * as 'counterfactual interactions'.\n *\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\n * information.\n */\nlibrary Create2 {\n    /**\n     * @dev Deploys a contract using `CREATE2`. The address where the contract\n     * will be deployed can be known in advance via {computeAddress}.\n     *\n     * The bytecode for a contract can be obtained from Solidity with\n     * `type(contractName).creationCode`.\n     *\n     * Requirements:\n     *\n     * - `bytecode` must not be empty.\n     * - `salt` must have not been used for `bytecode` already.\n     * - the factory must have a balance of at least `amount`.\n     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\n     */\n    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) {\n        address addr;\n        require(address(this).balance >= amount, \"Create2: insufficient balance\");\n        require(bytecode.length != 0, \"Create2: bytecode length is zero\");\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\n        }\n        require(addr != address(0), \"Create2: Failed on deploy\");\n        return addr;\n    }\n\n    /**\n     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\n     * `bytecodeHash` or `salt` will result in a new destination address.\n     */\n    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\n        return computeAddress(salt, bytecodeHash, address(this));\n    }\n\n    /**\n     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\n     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\n     */\n    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address) {\n        bytes32 _data = keccak256(\n            abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash)\n        );\n        return address(uint160(uint256(_data)));\n    }\n}\n"
    },
    "contracts/underwriter/TrivialUnderwriter.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\nimport { Ownable } from \"oz410/access/Ownable.sol\";\nimport { ZeroController } from \"../controllers/ZeroController.sol\";\n\n/**\n@title contract that is the simplest underwriter, just a proxy with an owner tag\n@author raymondpulver\n*/\ncontract TrivialUnderwriter is Ownable {\n  address payable public immutable controller;\n\n  constructor(address payable _controller) Ownable() {\n    controller = _controller;\n  }\n\n  function bubble(bool success, bytes memory response) internal pure {\n    assembly {\n      if iszero(success) {\n        revert(add(0x20, response), mload(response))\n      }\n      return(add(0x20, response), mload(response))\n    }\n  }\n\n  /**\n  @notice proxy a regular call to an arbitrary contract\n  @param target the to address of the transaction\n  @param data the calldata for the transaction\n  */\n  function proxy(address payable target, bytes memory data) public payable onlyOwner {\n    (bool success, bytes memory response) = target.call{ value: msg.value }(data);\n    bubble(success, response);\n  }\n\n  function loan(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 nonce,\n    address module,\n    bytes memory data,\n    bytes memory userSignature\n  ) public {\n    require(msg.sender == owner(), \"must be called by owner\");\n    ZeroController(controller).loan(to, asset, amount, nonce, module, data, userSignature);\n  }\n\n  function repay(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public {\n    require(msg.sender == owner(), \"must be called by owner\");\n    ZeroController(controller).repay(\n      underwriter,\n      to,\n      asset,\n      amount,\n      actualAmount,\n      nonce,\n      module,\n      nHash,\n      data,\n      signature\n    );\n  }\n\n  /**\n  @notice handles any other call and forwards to the controller\n  */\n  fallback() external payable {\n    require(msg.sender == owner(), \"must be called by owner\");\n    (bool success, bytes memory response) = controller.call{ value: msg.value }(msg.data);\n    bubble(success, response);\n  }\n}\n"
    },
    "oz410/access/Ownable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../utils/Context.sol\";\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 Ownable is Context {\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    constructor () {\n        address msgSender = _msgSender();\n        _owner = msgSender;\n        emit OwnershipTransferred(address(0), msgSender);\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 called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\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        emit OwnershipTransferred(_owner, address(0));\n        _owner = 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        emit OwnershipTransferred(_owner, newOwner);\n        _owner = newOwner;\n    }\n}\n"
    },
    "contracts/vendor/yearn/vaults/yVaultUpgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.7.0 <0.8.0;\n\nimport \"oz410/token/ERC20/IERC20.sol\";\nimport \"oz410/math/SafeMath.sol\";\nimport \"oz410/utils/Address.sol\";\nimport \"oz410/token/ERC20/SafeERC20.sol\";\nimport \"oz410/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\";\nimport \"oz410/access/Ownable.sol\";\n\nimport \"../interfaces/yearn/IController.sol\";\n\ncontract yVaultUpgradeable is ERC20Upgradeable {\n  using SafeERC20 for IERC20;\n  using Address for address;\n  using SafeMath for uint256;\n\n  IERC20 public token;\n\n  uint256 public min = 25;\n  uint256 public constant max = 30;\n\n  address public governance;\n  address public controller;\n\n  mapping(address => bool) public whitelist;\n\n  modifier isWhitelisted() {\n    require(whitelist[msg.sender], \"!whitelist\");\n    _;\n  }\n\n  modifier onlyGovernance() {\n    require(msg.sender == governance);\n    _;\n  }\n\n  function addToWhitelist(address[] calldata entries) external onlyGovernance {\n    for (uint256 i = 0; i < entries.length; i++) {\n      address entry = entries[i];\n      require(entry != address(0));\n\n      whitelist[entry] = true;\n    }\n  }\n\n  function removeFromWhitelist(address[] calldata entries) external onlyGovernance {\n    for (uint256 i = 0; i < entries.length; i++) {\n      address entry = entries[i];\n      whitelist[entry] = false;\n    }\n  }\n\n  function __yVault_init_unchained(\n    address _token,\n    address _controller,\n    string memory _name,\n    string memory _symbol\n  ) public initializer {\n    __ERC20_init_unchained(_name, _symbol);\n    token = IERC20(_token);\n    governance = msg.sender;\n    controller = _controller;\n  }\n\n  function decimals() public view override returns (uint8) {\n    return ERC20(address(token)).decimals();\n  }\n\n  function balance() public view returns (uint256) {\n    return token.balanceOf(address(this)).add(IController(controller).balanceOf(address(token)));\n  }\n\n  function setMin(uint256 _min) external {\n    require(msg.sender == governance, \"!governance\");\n    min = _min;\n  }\n\n  function setGovernance(address _governance) public {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function setController(address _controller) public {\n    require(msg.sender == governance, \"!governance\");\n    controller = _controller;\n  }\n\n  // Custom logic in here for how much the vault allows to be borrowed\n  // Sets minimum required on-hand to keep small withdrawals cheap\n  function available() public view returns (uint256) {\n    return token.balanceOf(address(this)).mul(min).div(max);\n  }\n\n  function earn() public {\n    uint256 _bal = available();\n    token.safeTransfer(controller, _bal);\n    IController(controller).earn(address(token), _bal);\n  }\n\n  function depositAll() external {\n    deposit(token.balanceOf(msg.sender));\n  }\n\n  function deposit(uint256 _amount) public {\n    uint256 _pool = balance();\n    uint256 _before = token.balanceOf(address(this));\n    token.safeTransferFrom(msg.sender, address(this), _amount);\n    uint256 _after = token.balanceOf(address(this));\n    _amount = _after.sub(_before); // Additional check for deflationary tokens\n    uint256 shares = 0;\n    if (totalSupply() == 0) {\n      shares = _amount;\n    } else {\n      shares = (_amount.mul(totalSupply())).div(_pool);\n    }\n    _mint(msg.sender, shares);\n  }\n\n  function withdrawAll() external {\n    withdraw(balanceOf(msg.sender));\n  }\n\n  // Used to swap any borrowed reserve over the debt limit to liquidate to 'token'\n  function harvest(address reserve, uint256 amount) external {\n    require(msg.sender == controller, \"!controller\");\n    require(reserve != address(token), \"token\");\n    IERC20(reserve).safeTransfer(controller, amount);\n  }\n\n  // No rebalance implementation for lower fees and faster swaps\n  function withdraw(uint256 _shares) public {\n    uint256 r = (balance().mul(_shares)).div(totalSupply());\n    _burn(msg.sender, _shares);\n\n    // Check balance\n    uint256 b = token.balanceOf(address(this));\n    if (b < r) {\n      uint256 _withdraw = r.sub(b);\n      IController(controller).withdraw(address(token), _withdraw);\n      uint256 _after = token.balanceOf(address(this));\n      uint256 _diff = _after.sub(b);\n      if (_diff < _withdraw) {\n        r = b.add(_diff);\n      }\n    }\n\n    token.safeTransfer(msg.sender, r);\n  }\n\n  function getPricePerFullShare() public view returns (uint256) {\n    return balance().mul(1e18).div(totalSupply());\n  }\n}\n"
    },
    "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"./IERC20Upgradeable.sol\";\nimport \"../../math/SafeMathUpgradeable.sol\";\nimport \"../../proxy/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable {\n    using SafeMathUpgradeable for uint256;\n\n    mapping (address => uint256) private _balances;\n\n    mapping (address => mapping (address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n    uint8 private _decimals;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with\n     * a default value of 18.\n     *\n     * To select a different value for {decimals}, use {_setupDecimals}.\n     *\n     * All three of these values are immutable: they can only be set once during\n     * construction.\n     */\n    function __ERC20_init(string memory name_, string memory symbol_) internal initializer {\n        __Context_init_unchained();\n        __ERC20_init_unchained(name_, symbol_);\n    }\n\n    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal initializer {\n        _name = name_;\n        _symbol = symbol_;\n        _decimals = 18;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\n     * called.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return _decimals;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `recipient` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(_msgSender(), recipient, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        _approve(_msgSender(), spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * Requirements:\n     *\n     * - `sender` and `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``sender``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(sender, recipient, amount);\n        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \"ERC20: transfer amount exceeds allowance\"));\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \"ERC20: decreased allowance below zero\"));\n        return true;\n    }\n\n    /**\n     * @dev Moves tokens `amount` from `sender` to `recipient`.\n     *\n     * This is internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `sender` cannot be the zero address.\n     * - `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     */\n    function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n        require(sender != address(0), \"ERC20: transfer from the zero address\");\n        require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(sender, recipient, amount);\n\n        _balances[sender] = _balances[sender].sub(amount, \"ERC20: transfer amount exceeds balance\");\n        _balances[recipient] = _balances[recipient].add(amount);\n        emit Transfer(sender, recipient, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply = _totalSupply.add(amount);\n        _balances[account] = _balances[account].add(amount);\n        emit Transfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        _balances[account] = _balances[account].sub(amount, \"ERC20: burn amount exceeds balance\");\n        _totalSupply = _totalSupply.sub(amount);\n        emit Transfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Sets {decimals} to a value other than the default one of 18.\n     *\n     * WARNING: This function should only be called from the constructor. Most\n     * applications that interact with token contracts will not expect\n     * {decimals} to ever change, and may work incorrectly if it does.\n     */\n    function _setupDecimals(uint8 decimals_) internal virtual {\n        _decimals = decimals_;\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be to transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n    uint256[44] private __gap;\n}\n"
    },
    "contracts/vendor/yearn/interfaces/yearn/IController.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.5.0 <0.8.0;\n\ninterface IController {\n  function withdraw(address, uint256) external;\n\n  function balanceOf(address) external view returns (uint256);\n\n  function earn(address, uint256) external;\n\n  function want(address) external view returns (address);\n\n  function rewards() external view returns (address);\n\n  function vaults(address) external view returns (address);\n\n  function strategies(address) external view returns (address);\n\n  function approvedStrategies(address, address) external view returns (bool);\n}\n"
    },
    "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\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 `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, 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 `sender` to `recipient` 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(address sender, address recipient, uint256 amount) external returns (bool);\n\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"
    },
    "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMathUpgradeable {\n    /**\n     * @dev Returns the addition of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        uint256 c = a + b;\n        if (c < a) return (false, 0);\n        return (true, c);\n    }\n\n    /**\n     * @dev Returns the substraction of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b > a) return (false, 0);\n        return (true, a - b);\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) return (true, 0);\n        uint256 c = a * b;\n        if (c / a != b) return (false, 0);\n        return (true, c);\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b == 0) return (false, 0);\n        return (true, a / b);\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\n     *\n     * _Available since v3.4._\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\n        if (b == 0) return (false, 0);\n        return (true, a % b);\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, \"SafeMath: addition overflow\");\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b <= a, \"SafeMath: subtraction overflow\");\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (a == 0) return 0;\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n        return c;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b > 0, \"SafeMath: division by zero\");\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        require(b > 0, \"SafeMath: modulo by zero\");\n        return a % b;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {trySub}.\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        return a - b;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers, reverting with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryDiv}.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b > 0, errorMessage);\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * reverting with custom message when dividing by zero.\n     *\n     * CAUTION: This function is deprecated because it requires allocating memory for the error\n     * message unnecessarily. For custom revert reasons use {tryMod}.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b > 0, errorMessage);\n        return a % b;\n    }\n}\n"
    },
    "contracts/vendor/yearn/vaults/yVault.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.7.0 <0.8.0;\n\nimport \"oz410/token/ERC20/IERC20.sol\";\nimport \"oz410/math/SafeMath.sol\";\nimport \"oz410/utils/Address.sol\";\nimport \"oz410/token/ERC20/SafeERC20.sol\";\nimport \"oz410/token/ERC20/ERC20.sol\";\nimport \"oz410/access/Ownable.sol\";\n\nimport \"../interfaces/yearn/IController.sol\";\n\ncontract yVault is ERC20 {\n  using SafeERC20 for IERC20;\n  using Address for address;\n  using SafeMath for uint256;\n\n  IERC20 public token;\n\n  uint256 public min = 25;\n  uint256 public constant max = 30;\n\n  address public governance;\n  address public controller;\n\n  constructor(\n    address _token,\n    address _controller,\n    string memory _name,\n    string memory _symbol\n  ) ERC20(_name, _symbol) {\n    token = IERC20(_token);\n    governance = msg.sender;\n    controller = _controller;\n  }\n\n  function decimals() public view override returns (uint8) {\n    return ERC20(address(token)).decimals();\n  }\n\n  function balance() public view returns (uint256) {\n    return token.balanceOf(address(this)).add(IController(controller).balanceOf(address(token)));\n  }\n\n  function setMin(uint256 _min) external {\n    require(msg.sender == governance, \"!governance\");\n    min = _min;\n  }\n\n  function setGovernance(address _governance) public {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function setController(address _controller) public {\n    require(msg.sender == governance, \"!governance\");\n    controller = _controller;\n  }\n\n  // Custom logic in here for how much the vault allows to be borrowed\n  // Sets minimum required on-hand to keep small withdrawals cheap\n  function available() public view returns (uint256) {\n    return token.balanceOf(address(this)).mul(min).div(max);\n  }\n\n  function earn() public {\n    uint256 _bal = available();\n    token.safeTransfer(controller, _bal);\n    IController(controller).earn(address(token), _bal);\n  }\n\n  function depositAll() external {\n    deposit(token.balanceOf(msg.sender));\n  }\n\n  function deposit(uint256 _amount) public {\n    uint256 _pool = balance();\n    uint256 _before = token.balanceOf(address(this));\n    token.safeTransferFrom(msg.sender, address(this), _amount);\n    uint256 _after = token.balanceOf(address(this));\n    _amount = _after.sub(_before); // Additional check for deflationary tokens\n    uint256 shares = 0;\n    if (totalSupply() == 0) {\n      shares = _amount;\n    } else {\n      shares = (_amount.mul(totalSupply())).div(_pool);\n    }\n    _mint(msg.sender, shares);\n  }\n\n  function withdrawAll() external {\n    withdraw(balanceOf(msg.sender));\n  }\n\n  // Used to swap any borrowed reserve over the debt limit to liquidate to 'token'\n  function harvest(address reserve, uint256 amount) external {\n    require(msg.sender == controller, \"!controller\");\n    require(reserve != address(token), \"token\");\n    IERC20(reserve).safeTransfer(controller, amount);\n  }\n\n  // No rebalance implementation for lower fees and faster swaps\n  function withdraw(uint256 _shares) public {\n    uint256 r = (balance().mul(_shares)).div(totalSupply());\n    _burn(msg.sender, _shares);\n\n    // Check balance\n    uint256 b = token.balanceOf(address(this));\n    if (b < r) {\n      uint256 _withdraw = r.sub(b);\n      IController(controller).withdraw(address(token), _withdraw);\n      uint256 _after = token.balanceOf(address(this));\n      uint256 _diff = _after.sub(b);\n      if (_diff < _withdraw) {\n        r = b.add(_diff);\n      }\n    }\n\n    token.safeTransfer(msg.sender, r);\n  }\n\n  function getPricePerFullShare() public view returns (uint256) {\n    return balance().mul(1e18).div(totalSupply());\n  }\n}\n"
    },
    "contracts/test/DummyVault.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.7.0 <0.8.0;\n\nimport { yVault } from \"../vendor/yearn/vaults/yVault.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { ERC20 } from \"oz410/token/ERC20/ERC20.sol\";\n\ncontract DummyVault is ERC20 {\n  address public immutable want;\n  address public immutable controller;\n\n  constructor(\n    address _want,\n    address _controller,\n    string memory _name,\n    string memory _symbol\n  ) ERC20(_name, _symbol) {\n    want = _want;\n    controller = _controller;\n  }\n\n  function estimateShares(uint256 _amount) external view returns (uint256) {\n    return _amount;\n  }\n\n  function deposit(uint256 _amount) public returns (uint256) {\n    IERC20(want).transferFrom(msg.sender, address(this), _amount);\n    _mint(msg.sender, _amount);\n    return _amount;\n  }\n\n  function withdraw(uint256 _amount) public returns (uint256) {\n    _burn(msg.sender, _amount);\n    IERC20(want).transfer(msg.sender, _amount);\n    return _amount;\n  }\n\n  function pricePerShare() public pure returns (uint256) {\n    return uint256(1e18);\n  }\n}\n"
    },
    "contracts/strategies/StrategyRenVMEthereum.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"oz410/token/ERC20/IERC20.sol\";\nimport \"oz410/math/SafeMath.sol\";\nimport \"oz410/utils/Address.sol\";\nimport \"oz410/token/ERC20/SafeERC20.sol\";\nimport \"../interfaces/IStrategy.sol\";\nimport \"../interfaces/IyVault.sol\";\nimport \"../interfaces/IWETH.sol\";\nimport \"../interfaces/IConverter.sol\";\nimport { StrategyAPI } from \"../interfaces/IStrategy.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { ICurvePool } from \"../interfaces/ICurvePool.sol\";\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\n\ncontract StrategyRenVMEthereum {\n  using SafeERC20 for IERC20;\n  using Address for address;\n  using SafeMath for uint256;\n\n  address public immutable vault;\n  address public immutable nativeWrapper;\n  address public immutable want;\n  int128 public constant wantIndex = 0;\n\n  address public immutable vaultWant;\n  int128 public constant vaultWantIndex = 1;\n\n  string public constant name = \"0confirmation RenVM Strategy\";\n  bool public constant isActive = true;\n\n  uint256 public constant wantReserve = 1000000;\n  uint256 public constant gasReserve = uint256(1e17);\n  address public immutable controller;\n  address public governance;\n  address public strategist;\n\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  constructor(\n    address _controller,\n    address _want,\n    address _nativeWrapper,\n    address _vault,\n    address _vaultWant\n  ) {\n    nativeWrapper = _nativeWrapper;\n    want = _want;\n    vault = _vault;\n    vaultWant = _vaultWant;\n    governance = msg.sender;\n    strategist = msg.sender;\n    controller = _controller;\n    IERC20(_vaultWant).safeApprove(address(_vault), type(uint256).max);\n  }\n\n  receive() external payable {}\n\n  function deposit() external virtual {\n    //First conditional handles having too much of want in the Strategy\n    uint256 _want = IERC20(want).balanceOf(address(this)); //amount of tokens we want\n    if (_want > wantReserve) {\n      // Then we can deposit excess tokens into the vault\n      address converter = IController(controller).converters(want, vaultWant);\n      require(converter != address(0x0), \"!converter\");\n      uint256 _excess = _want.sub(wantReserve);\n      require(IERC20(want).transfer(converter, _excess), \"!transfer\");\n      uint256 _amountOut = IConverter(converter).convert(address(0x0));\n      IyVault(vault).deposit(_amountOut);\n    }\n    //Second conditional handles having too little of gasWant in the Strategy\n\n    uint256 _gasWant = address(this).balance; //ETH balance\n    if (_gasWant < gasReserve) {\n      // if ETH balance < ETH reserve\n      _gasWant = gasReserve.sub(_gasWant);\n      address _converter = IController(controller).converters(nativeWrapper, vaultWant);\n      uint256 _vaultWant = IConverter(_converter).estimate(_gasWant); //_gasWant is estimated from wETH to wBTC\n      uint256 _sharesDeficit = estimateShares(_vaultWant); //Estimate shares of wBTC\n      // Works up to this point\n      require(IERC20(vault).balanceOf(address(this)) > _sharesDeficit, \"!enough\"); //revert if shares needed > shares held\n      uint256 _amountOut = IyVault(vault).withdraw(_sharesDeficit);\n      address converter = IController(controller).converters(vaultWant, nativeWrapper);\n      IERC20(vaultWant).transfer(converter, _amountOut);\n      _amountOut = IConverter(converter).convert(address(this));\n      address _unwrapper = IController(controller).converters(nativeWrapper, address(0x0));\n      IERC20(nativeWrapper).transfer(_unwrapper, _amountOut);\n      IConverter(_unwrapper).convert(address(this));\n    }\n  }\n\n  function _withdraw(uint256 _amount, address _asset) private returns (uint256) {\n    require(_asset == want || _asset == vaultWant, \"asset not supported\");\n    if (_amount == 0) {\n      return 0;\n    }\n    address converter = IController(controller).converters(want, vaultWant);\n    // _asset is wBTC and want is renBTC\n    if (_asset == want) {\n      // if asset is what the strategy wants\n      //then we can't directly withdraw it\n      _amount = IConverter(converter).estimate(_amount);\n    }\n    uint256 _shares = estimateShares(_amount);\n    _amount = IyVault(vault).withdraw(_shares);\n    if (_asset == want) {\n      // if asset is what the strategy wants\n      IConverter toWant = IConverter(IController(controller).converters(vaultWant, want));\n      IERC20(vaultWant).transfer(address(toWant), _amount);\n      _amount = toWant.convert(address(0x0));\n    }\n    return _amount;\n  }\n\n  function permissionedEther(address payable _target, uint256 _amount) external virtual onlyController {\n    // _amount is the amount of ETH to refund\n    if (_amount > gasReserve) {\n      _amount = IConverter(IController(controller).converters(nativeWrapper, vaultWant)).estimate(_amount);\n      uint256 _sharesDeficit = estimateShares(_amount);\n      uint256 _amountOut = IyVault(vault).withdraw(_sharesDeficit);\n      address _vaultConverter = IController(controller).converters(vaultWant, nativeWrapper);\n      address _converter = IController(controller).converters(nativeWrapper, address(0x0));\n      IERC20(vaultWant).transfer(_vaultConverter, _amountOut);\n      _amount = IConverter(_vaultConverter).convert(address(this));\n      IERC20(nativeWrapper).transfer(_converter, _amount);\n      _amount = IConverter(_converter).convert(address(this));\n    }\n    _target.transfer(_amount);\n  }\n\n  function withdraw(uint256 _amount) external virtual onlyController {\n    IERC20(want).safeTransfer(address(controller), _withdraw(_amount, want));\n  }\n\n  function withdrawAll() external virtual onlyController {\n    IERC20(want).safeTransfer(address(controller), _withdraw(IERC20(vault).balanceOf(address(this)), want));\n  }\n\n  function balanceOf() external view virtual returns (uint256) {\n    return IyVault(vault).balanceOf(address(this));\n  }\n\n  function estimateShares(uint256 _amount) internal virtual returns (uint256) {\n    return _amount.mul(10**IyVault(vault).decimals()).div(IyVault(vault).pricePerShare());\n  }\n\n  function permissionedSend(address _module, uint256 _amount) external virtual onlyController returns (uint256) {\n    uint256 _reserve = IERC20(want).balanceOf(address(this));\n    address _want = IZeroModule(_module).want();\n    if (_amount > _reserve || _want != want) {\n      _amount = _withdraw(_amount, _want);\n    }\n    IERC20(_want).safeTransfer(_module, _amount);\n    return _amount;\n  }\n}\n"
    },
    "contracts/interfaces/IController.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.7.0 <0.8.0;\n\ninterface IController {\n  function governance() external view returns (address);\n\n  function rewards() external view returns (address);\n\n  function withdraw(address, uint256) external;\n\n  function balanceOf(address) external view returns (uint256);\n\n  function earn(address, uint256) external;\n\n  function want(address) external view returns (address);\n\n  function vaults(address) external view returns (address);\n\n  function strategies(address) external view returns (address);\n\n  function approvedStrategies(address, address) external view returns (bool);\n\n  function converters(address, address) external view returns (address);\n}\n"
    },
    "contracts/interfaces/ICurvePool.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurvePool {\n  function get_dy(\n    int128,\n    int128,\n    uint256\n  ) external view returns (uint256);\n\n  function get_dy(\n    uint256,\n    uint256,\n    uint256\n  ) external view returns (uint256);\n\n  function get_dy_underlying(\n    int128,\n    int128,\n    uint256\n  ) external view returns (uint256);\n\n  function get_dy_underlying(\n    uint256,\n    uint256,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange(\n    int128,\n    int128,\n    uint256,\n    uint256\n  ) external;\n\n  function exchange(\n    uint256,\n    uint256,\n    uint256,\n    uint256\n  ) external;\n\n  function exchange_underlying(\n    int128,\n    int128,\n    uint256,\n    uint256\n  ) external;\n\n  function exchange_underlying(\n    uint256,\n    uint256,\n    uint256,\n    uint256\n  ) external;\n\n  function coins(int128) external view returns (address);\n\n  function coins(int256) external view returns (address);\n\n  function coins(uint128) external view returns (address);\n\n  function coins(uint256) external view returns (address);\n\n  function underlying_coins(int128) external view returns (address);\n\n  function underlying_coins(uint128) external view returns (address);\n\n  function underlying_coins(int256) external view returns (address);\n\n  function underlying_coins(uint256) external view returns (address);\n}\n"
    },
    "contracts/strategies/StrategyRenVMArbitrum.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"oz410/token/ERC20/IERC20.sol\";\nimport \"oz410/math/SafeMath.sol\";\nimport \"oz410/utils/Address.sol\";\nimport \"oz410/token/ERC20/SafeERC20.sol\";\nimport \"../interfaces/IStrategy.sol\";\nimport \"../interfaces/IyVault.sol\";\nimport \"../interfaces/IWETH.sol\";\nimport \"../interfaces/IConverter.sol\";\nimport { StrategyAPI } from \"../interfaces/IStrategy.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { ICurvePool } from \"../interfaces/ICurvePool.sol\";\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\n\ncontract StrategyRenVMArbitrum {\n  using SafeERC20 for IERC20;\n  using Address for address;\n  using SafeMath for uint256;\n\n  address public immutable vault;\n  address public immutable nativeWrapper;\n  address public immutable want;\n  int128 public constant wantIndex = 0;\n\n  address public immutable vaultWant;\n  int128 public constant vaultWantIndex = 1;\n\n  string public constant name = \"0confirmation RenVM Strategy\";\n  bool public constant isActive = true;\n\n  uint256 public constant wantReserve = 1000000;\n  uint256 public constant gasReserve = uint256(1e17);\n  address public immutable controller;\n  address public governance;\n  address public strategist;\n\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  constructor(\n    address _controller,\n    address _want,\n    address _nativeWrapper,\n    address _vault,\n    address _vaultWant\n  ) {\n    nativeWrapper = _nativeWrapper;\n    want = _want;\n    vault = _vault;\n    vaultWant = _vaultWant;\n    governance = msg.sender;\n    strategist = msg.sender;\n    controller = _controller;\n    IERC20(_vaultWant).safeApprove(address(_vault), type(uint256).max);\n  }\n\n  receive() external payable {}\n\n  function deposit() external virtual {\n    //First conditional handles having too much of want in the Strategy\n    uint256 _want = IERC20(want).balanceOf(address(this)); //amount of tokens we want\n    if (_want > wantReserve) {\n      // Then we can deposit excess tokens into the vault\n      address converter = IController(controller).converters(want, vaultWant);\n      require(converter != address(0x0), \"!converter\");\n      uint256 _excess = _want.sub(wantReserve);\n      require(IERC20(want).transfer(converter, _excess), \"!transfer\");\n      uint256 _amountOut = IConverter(converter).convert(address(0x0));\n      IyVault(vault).deposit(_amountOut);\n    }\n    //Second conditional handles having too little of gasWant in the Strategy\n\n    uint256 _gasWant = address(this).balance; //ETH balance\n    if (_gasWant < gasReserve) {\n      // if ETH balance < ETH reserve\n      _gasWant = gasReserve.sub(_gasWant);\n      address _converter = IController(controller).converters(nativeWrapper, vaultWant);\n      uint256 _vaultWant = IConverter(_converter).estimate(_gasWant); //_gasWant is estimated from wETH to wBTC\n      uint256 _sharesDeficit = estimateShares(_vaultWant); //Estimate shares of wBTC\n      // Works up to this point\n      require(IERC20(vault).balanceOf(address(this)) > _sharesDeficit, \"!enough\"); //revert if shares needed > shares held\n      uint256 _amountOut = IyVault(vault).withdraw(_sharesDeficit);\n      address converter = IController(controller).converters(vaultWant, nativeWrapper);\n      IERC20(vaultWant).transfer(converter, _amountOut);\n      _amountOut = IConverter(converter).convert(address(this));\n      address _unwrapper = IController(controller).converters(nativeWrapper, address(0x0));\n      IERC20(nativeWrapper).transfer(_unwrapper, _amountOut);\n      IConverter(_unwrapper).convert(address(this));\n    }\n  }\n\n  function _withdraw(uint256 _amount, address _asset) private returns (uint256) {\n    require(_asset == want || _asset == vaultWant, \"asset not supported\");\n    if (_amount == 0) {\n      return 0;\n    }\n    address converter = IController(controller).converters(want, vaultWant);\n    // _asset is wBTC and want is renBTC\n    if (_asset == want) {\n      // if asset is what the strategy wants\n      //then we can't directly withdraw it\n      _amount = IConverter(converter).estimate(_amount);\n    }\n    uint256 _shares = estimateShares(_amount);\n    _amount = IyVault(vault).withdraw(_shares);\n    if (_asset == want) {\n      // if asset is what the strategy wants\n      IConverter toWant = IConverter(IController(controller).converters(vaultWant, want));\n      IERC20(vaultWant).transfer(address(toWant), _amount);\n      _amount = toWant.convert(address(0x0));\n    }\n    return _amount;\n  }\n\n  function permissionedEther(address payable _target, uint256 _amount) external virtual onlyController {\n    // _amount is the amount of ETH to refund\n    if (_amount > gasReserve) {\n      _amount = IConverter(IController(controller).converters(nativeWrapper, vaultWant)).estimate(_amount);\n      uint256 _sharesDeficit = estimateShares(_amount);\n      uint256 _amountOut = IyVault(vault).withdraw(_sharesDeficit);\n      address _vaultConverter = IController(controller).converters(vaultWant, nativeWrapper);\n      address _converter = IController(controller).converters(nativeWrapper, address(0x0));\n      IERC20(vaultWant).transfer(_vaultConverter, _amountOut);\n      _amount = IConverter(_vaultConverter).convert(address(this));\n      IERC20(nativeWrapper).transfer(_converter, _amount);\n      _amount = IConverter(_converter).convert(address(this));\n    }\n    _target.transfer(_amount);\n  }\n\n  function withdraw(uint256 _amount) external virtual onlyController {\n    IERC20(want).safeTransfer(address(controller), _withdraw(_amount, want));\n  }\n\n  function withdrawAll() external virtual onlyController {\n    IERC20(want).safeTransfer(address(controller), _withdraw(IERC20(vault).balanceOf(address(this)), want));\n  }\n\n  function balanceOf() external view virtual returns (uint256) {\n    return IyVault(vault).balanceOf(address(this));\n  }\n\n  function estimateShares(uint256 _amount) internal virtual returns (uint256) {\n    return _amount.mul(10**IyVault(vault).decimals()).div(IyVault(vault).pricePerShare());\n  }\n\n  function permissionedSend(address _module, uint256 _amount) external virtual onlyController returns (uint256) {\n    uint256 _reserve = IERC20(want).balanceOf(address(this));\n    address _want = IZeroModule(_module).want();\n    if (_amount > _reserve || _want != want) {\n      _amount = _withdraw(_amount, _want);\n    }\n    IERC20(_want).safeTransfer(_module, _amount);\n    return _amount;\n  }\n}\n"
    },
    "contracts/strategies/StrategyRenVM.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"oz410/token/ERC20/IERC20.sol\";\nimport \"oz410/math/SafeMath.sol\";\nimport \"oz410/utils/Address.sol\";\nimport \"oz410/token/ERC20/SafeERC20.sol\";\nimport \"../interfaces/IStrategy.sol\";\nimport \"../interfaces/IyVault.sol\";\nimport \"../interfaces/IWETH.sol\";\nimport \"../interfaces/IConverter.sol\";\nimport { StrategyAPI } from \"../interfaces/IStrategy.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { ICurvePool } from \"../interfaces/ICurvePool.sol\";\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\n\ncontract StrategyRenVM {\n  using SafeERC20 for IERC20;\n  using Address for address;\n  using SafeMath for uint256;\n\n  address public immutable vault;\n  address public immutable nativeWrapper;\n  address public immutable want;\n  int128 public constant wantIndex = 0;\n\n  address public immutable vaultWant;\n  int128 public constant vaultWantIndex = 1;\n\n  string public constant name = \"0confirmation RenVM Strategy\";\n  bool public constant isActive = true;\n\n  uint256 public constant wantReserve = 1000000;\n  uint256 public constant gasReserve = uint256(5 ether);\n  address public immutable controller;\n  address public governance;\n  address public strategist;\n\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  constructor(\n    address _controller,\n    address _want,\n    address _nativeWrapper,\n    address _vault,\n    address _vaultWant\n  ) {\n    nativeWrapper = _nativeWrapper;\n    want = _want;\n    vault = _vault;\n    vaultWant = _vaultWant;\n    governance = msg.sender;\n    strategist = msg.sender;\n    controller = _controller;\n    IERC20(_vaultWant).safeApprove(address(_vault), type(uint256).max);\n  }\n\n  receive() external payable {}\n\n  function deposit() external virtual {\n    //First conditional handles having too much of want in the Strategy\n    uint256 _want = IERC20(want).balanceOf(address(this)); //amount of tokens we want\n    if (_want > wantReserve) {\n      // Then we can deposit excess tokens into the vault\n      address converter = IController(controller).converters(want, vaultWant);\n      require(converter != address(0x0), \"!converter\");\n      uint256 _excess = _want.sub(wantReserve);\n      require(IERC20(want).transfer(converter, _excess), \"!transfer\");\n      uint256 _amountOut = IConverter(converter).convert(address(0x0));\n      IyVault(vault).deposit(_amountOut);\n    }\n    //Second conditional handles having too little of gasWant in the Strategy\n\n    uint256 _gasWant = address(this).balance; //ETH balance\n    if (_gasWant < gasReserve) {\n      // if ETH balance < ETH reserve\n      _gasWant = gasReserve.sub(_gasWant);\n      address _converter = IController(controller).converters(nativeWrapper, vaultWant);\n      uint256 _vaultWant = IConverter(_converter).estimate(_gasWant); //_gasWant is estimated from wETH to wBTC\n      uint256 _sharesDeficit = estimateShares(_vaultWant); //Estimate shares of wBTC\n      // Works up to this point\n      require(IERC20(vault).balanceOf(address(this)) > _sharesDeficit, \"!enough\"); //revert if shares needed > shares held\n      uint256 _amountOut = IyVault(vault).withdraw(_sharesDeficit);\n      address converter = IController(controller).converters(vaultWant, nativeWrapper);\n      IERC20(vaultWant).transfer(converter, _amountOut);\n      _amountOut = IConverter(converter).convert(address(this));\n      address _unwrapper = IController(controller).converters(nativeWrapper, address(0x0));\n      IERC20(nativeWrapper).transfer(_unwrapper, _amountOut);\n      IConverter(_unwrapper).convert(address(this));\n    }\n  }\n\n  function _withdraw(uint256 _amount, address _asset) private returns (uint256) {\n    require(_asset == want || _asset == vaultWant, \"asset not supported\");\n    if (_amount == 0) {\n      return 0;\n    }\n    address converter = IController(controller).converters(want, vaultWant);\n    // _asset is wBTC and want is renBTC\n    if (_asset == want) {\n      // if asset is what the strategy wants\n      //then we can't directly withdraw it\n      _amount = IConverter(converter).estimate(_amount);\n    }\n    uint256 _shares = estimateShares(_amount);\n    _amount = IyVault(vault).withdraw(_shares);\n    if (_asset == want) {\n      // if asset is what the strategy wants\n      IConverter toWant = IConverter(IController(controller).converters(vaultWant, want));\n      IERC20(vaultWant).transfer(address(toWant), _amount);\n      _amount = toWant.convert(address(0x0));\n    }\n    return _amount;\n  }\n\n  function permissionedEther(address payable _target, uint256 _amount) external virtual onlyController {\n    // _amount is the amount of ETH to refund\n    if (_amount > gasReserve) {\n      _amount = IConverter(IController(controller).converters(nativeWrapper, vaultWant)).estimate(_amount);\n      uint256 _sharesDeficit = estimateShares(_amount);\n      uint256 _amountOut = IyVault(vault).withdraw(_sharesDeficit);\n      address _vaultConverter = IController(controller).converters(vaultWant, nativeWrapper);\n      address _converter = IController(controller).converters(nativeWrapper, address(0x0));\n      IERC20(vaultWant).transfer(_vaultConverter, _amountOut);\n      _amount = IConverter(_vaultConverter).convert(address(this));\n      IERC20(nativeWrapper).transfer(_converter, _amount);\n      _amount = IConverter(_converter).convert(address(this));\n    }\n    _target.transfer(_amount);\n  }\n\n  function withdraw(uint256 _amount) external virtual onlyController {\n    IERC20(want).safeTransfer(address(controller), _withdraw(_amount, want));\n  }\n\n  function withdrawAll() external virtual onlyController {\n    IERC20(want).safeTransfer(address(controller), _withdraw(IERC20(vault).balanceOf(address(this)), want));\n  }\n\n  function balanceOf() external view virtual returns (uint256) {\n    return IyVault(vault).balanceOf(address(this));\n  }\n\n  function estimateShares(uint256 _amount) internal virtual returns (uint256) {\n    return _amount.mul(10**IyVault(vault).decimals()).div(IyVault(vault).pricePerShare());\n  }\n\n  function permissionedSend(address _module, uint256 _amount) external virtual onlyController returns (uint256) {\n    uint256 _reserve = IERC20(want).balanceOf(address(this));\n    address _want = IZeroModule(_module).want();\n    if (_amount > _reserve || _want != want) {\n      _amount = _withdraw(_amount, _want);\n    }\n    IERC20(_want).safeTransfer(_module, _amount);\n    return _amount;\n  }\n}\n"
    },
    "contracts/modules/Swap.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport { SwapLib } from \"./SwapLib.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\n\ncontract Swap is IZeroModule {\n  using SafeERC20 for *;\n  using SafeMath for *;\n  mapping(uint256 => SwapLib.SwapRecord) public outstanding;\n  address public immutable controller;\n  address public immutable governance;\n  uint256 public blockTimeout;\n  address public immutable fiat; //USDC\n  address public immutable wNative; //wETH\n  address public immutable override want; //wBTC\n  address public immutable router; //Sushi V2\n  address public immutable controllerWant; // Controller want (renBTC)\n\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  constructor(\n    address _controller,\n    address _wNative,\n    address _want,\n    address _router,\n    address _fiat,\n    address _controllerWant\n  ) {\n    controller = _controller;\n    wNative = _wNative;\n    want = _want;\n    router = _router;\n    fiat = _fiat;\n    controllerWant = _controllerWant;\n    governance = IController(_controller).governance();\n    IERC20(_want).safeApprove(_router, ~uint256(0));\n    IERC20(_fiat).safeApprove(_router, ~uint256(0));\n  }\n\n  function setBlockTimeout(uint256 _ct) public {\n    require(msg.sender == governance, \"!governance\");\n    blockTimeout = _ct;\n  }\n\n  function defaultLoan(uint256 _nonce) public {\n    require(block.number >= outstanding[_nonce].when + blockTimeout);\n    require(outstanding[_nonce].qty != 0, \"!outstanding\");\n    uint256 _amountSwapped = swapTokens(fiat, controllerWant, outstanding[_nonce].qty);\n    IERC20(controllerWant).safeTransfer(controller, _amountSwapped);\n    delete outstanding[_nonce];\n  }\n\n  function receiveLoan(\n    address _to,\n    address _asset,\n    uint256 _actual,\n    uint256 _nonce,\n    bytes memory _data\n  ) public override onlyController {\n    uint256 amountSwapped = swapTokens(want, fiat, _actual);\n    outstanding[_nonce] = SwapLib.SwapRecord({ qty: amountSwapped, when: uint64(block.timestamp), token: _asset });\n  }\n\n  function swapTokens(\n    address _tokenIn,\n    address _tokenOut,\n    uint256 _amountIn\n  ) internal returns (uint256) {\n    address[] memory _path = new address[](3);\n    _path[0] = _tokenIn;\n    _path[1] = wNative;\n    _path[2] = _tokenOut;\n    IERC20(_tokenIn).approve(router, _amountIn);\n    uint256 _amountOut = IUniswapV2Router02(router).swapExactTokensForTokens(\n      _amountIn,\n      1,\n      _path,\n      address(this),\n      block.timestamp\n    )[_path.length - 1];\n    return _amountOut;\n  }\n\n  function repayLoan(\n    address _to,\n    address _asset,\n    uint256 _actualAmount,\n    uint256 _nonce,\n    bytes memory _data\n  ) public override onlyController {\n    require(outstanding[_nonce].qty != 0, \"!outstanding\");\n    IERC20(fiat).safeTransfer(_to, outstanding[_nonce].qty);\n    delete outstanding[_nonce];\n  }\n\n  function computeReserveRequirement(uint256 _in) external view override returns (uint256) {\n    return _in.mul(uint256(1e17)).div(uint256(1 ether));\n  }\n}\n"
    },
    "contracts/modules/SwapLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\nlibrary SwapLib {\n  struct SwapRecord {\n    address token;\n    uint64 when;\n    uint256 qty;\n  }\n}\n"
    },
    "contracts/test/SwapRelease.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\nimport { Swap } from \"../modules/Swap.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\ncontract SwapRelease {\n  address constant swap = 0x129F31e121B0A8C05bf10347F34976238F1f15DC;\n  address constant wbtc = 0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6;\n  address constant governance = 0x12fBc372dc2f433392CC6caB29CFBcD5082EF494;\n  address constant usdc = 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174;\n\n  fallback() external {\n    IERC20(wbtc).transfer(swap, IERC20(wbtc).balanceOf(address(this)));\n    Swap(swap).receiveLoan(address(0), address(0), IERC20(wbtc).balanceOf(swap), 1, hex\"\");\n    Swap(swap).repayLoan(governance, address(0), IERC20(usdc).balanceOf(swap), uint256(1), hex\"\");\n  }\n}\n"
    },
    "contracts/token/ZeroDistributor.sol": {
      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/cryptography/MerkleProof.sol\";\nimport { IMerkleDistributor } from \"../interfaces/IMerkleDistributor.sol\";\n\ncontract ZeroDistributor is IMerkleDistributor {\n  address public immutable override token;\n  bytes32 public immutable override merkleRoot;\n  address public immutable treasury;\n\n  // This is a packed array of booleans.\n  mapping(uint256 => uint256) private claimedBitMap;\n\n  constructor(\n    address token_,\n    address treasury_,\n    bytes32 merkleRoot_\n  ) {\n    token = token_;\n    treasury = treasury_;\n    merkleRoot = merkleRoot_;\n  }\n\n  function isClaimed(uint256 index) public view override returns (bool) {\n    uint256 claimedWordIndex = index / 256;\n    uint256 claimedBitIndex = index % 256;\n    uint256 claimedWord = claimedBitMap[claimedWordIndex];\n    uint256 mask = (1 << claimedBitIndex);\n    return claimedWord & mask == mask;\n  }\n\n  function _setClaimed(uint256 index) private {\n    uint256 claimedWordIndex = index / 256;\n    uint256 claimedBitIndex = index % 256;\n    claimedBitMap[claimedWordIndex] = claimedBitMap[claimedWordIndex] | (1 << claimedBitIndex);\n  }\n\n  function claim(\n    uint256 index,\n    address account,\n    uint256 amount,\n    bytes32[] calldata merkleProof\n  ) external override {\n    require(!isClaimed(index), \"MerkleDistributor: Drop already claimed.\");\n\n    // Verify the merkle proof.\n    bytes32 node = keccak256(abi.encodePacked(index, account, amount));\n    require(MerkleProof.verify(merkleProof, merkleRoot, node), \"MerkleDistributor: Invalid proof.\");\n\n    // Mark it claimed and send the token.\n    _setClaimed(index);\n    require(IERC20(token).transferFrom(treasury, account, amount), \"MerkleDistributor: Transfer failed.\");\n\n    emit Claimed(index, account, amount);\n  }\n}\n"
    },
    "@openzeppelin/contracts/cryptography/MerkleProof.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle trees (hash trees),\n */\nlibrary MerkleProof {\n    /**\n     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n     * defined by `root`. For this, a `proof` must be provided, containing\n     * sibling hashes on the branch from the leaf to the root of the tree. Each\n     * pair of leaves and each pair of pre-images are assumed to be sorted.\n     */\n    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n        bytes32 computedHash = leaf;\n\n        for (uint256 i = 0; i < proof.length; i++) {\n            bytes32 proofElement = proof[i];\n\n            if (computedHash <= proofElement) {\n                // Hash(current computed hash + current element of the proof)\n                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\n            } else {\n                // Hash(current element of the proof + current computed hash)\n                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\n            }\n        }\n\n        // Check if the computed hash (root) is equal to the provided root\n        return computedHash == root;\n    }\n}\n"
    },
    "contracts/interfaces/IMerkleDistributor.sol": {
      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.5.0 <0.8.0;\n\n// Allows anyone to claim a token if they exist in a merkle root.\ninterface IMerkleDistributor {\n  // Returns the address of the token distributed by this contract.\n  function token() external view returns (address);\n\n  // Returns the merkle root of the merkle tree containing account balances available to claim.\n  function merkleRoot() external view returns (bytes32);\n\n  // Returns true if the index has been marked claimed.\n  function isClaimed(uint256 index) external view returns (bool);\n\n  // Claim the given amount of the token to the given address. Reverts if the inputs are invalid.\n  function claim(\n    uint256 index,\n    address account,\n    uint256 amount,\n    bytes32[] calldata merkleProof\n  ) external;\n\n  // This event is triggered whenever a call to #claim succeeds.\n  event Claimed(uint256 index, address account, uint256 amount);\n}\n"
    },
    "@openzeppelin/contracts/token/ERC20/ERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"../../utils/Context.sol\";\nimport \"./IERC20.sol\";\nimport \"../../math/SafeMath.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20 {\n    using SafeMath for uint256;\n\n    mapping (address => uint256) private _balances;\n\n    mapping (address => mapping (address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n    uint8 private _decimals;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with\n     * a default value of 18.\n     *\n     * To select a different value for {decimals}, use {_setupDecimals}.\n     *\n     * All three of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor (string memory name_, string memory symbol_) public {\n        _name = name_;\n        _symbol = symbol_;\n        _decimals = 18;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\n     * called.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return _decimals;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `recipient` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(_msgSender(), recipient, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        _approve(_msgSender(), spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * Requirements:\n     *\n     * - `sender` and `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``sender``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(sender, recipient, amount);\n        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, \"ERC20: transfer amount exceeds allowance\"));\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, \"ERC20: decreased allowance below zero\"));\n        return true;\n    }\n\n    /**\n     * @dev Moves tokens `amount` from `sender` to `recipient`.\n     *\n     * This is internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `sender` cannot be the zero address.\n     * - `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     */\n    function _transfer(address sender, address recipient, uint256 amount) internal virtual {\n        require(sender != address(0), \"ERC20: transfer from the zero address\");\n        require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(sender, recipient, amount);\n\n        _balances[sender] = _balances[sender].sub(amount, \"ERC20: transfer amount exceeds balance\");\n        _balances[recipient] = _balances[recipient].add(amount);\n        emit Transfer(sender, recipient, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply = _totalSupply.add(amount);\n        _balances[account] = _balances[account].add(amount);\n        emit Transfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        _balances[account] = _balances[account].sub(amount, \"ERC20: burn amount exceeds balance\");\n        _totalSupply = _totalSupply.sub(amount);\n        emit Transfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Sets {decimals} to a value other than the default one of 18.\n     *\n     * WARNING: This function should only be called from the constructor. Most\n     * applications that interact with token contracts will not expect\n     * {decimals} to ever change, and may work incorrectly if it does.\n     */\n    function _setupDecimals(uint8 decimals_) internal virtual {\n        _decimals = decimals_;\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be to transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }\n}\n"
    },
    "@openzeppelin/contracts/utils/Context.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\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 GSN 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 Context {\n    function _msgSender() internal view virtual returns (address payable) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes memory) {\n        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n        return msg.data;\n    }\n}\n"
    },
    "@openzeppelin/contracts/access/Ownable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"../utils/Context.sol\";\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 Ownable is Context {\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    constructor () internal {\n        address msgSender = _msgSender();\n        _owner = msgSender;\n        emit OwnershipTransferred(address(0), msgSender);\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 called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\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        emit OwnershipTransferred(_owner, address(0));\n        _owner = 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        emit OwnershipTransferred(_owner, newOwner);\n        _owner = newOwner;\n    }\n}\n"
    },
    "@openzeppelin/contracts/proxy/ProxyAdmin.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"../access/Ownable.sol\";\nimport \"./TransparentUpgradeableProxy.sol\";\n\n/**\n * @dev This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an\n * explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}.\n */\ncontract ProxyAdmin is Ownable {\n\n    /**\n     * @dev Returns the current implementation of `proxy`.\n     *\n     * Requirements:\n     *\n     * - This contract must be the admin of `proxy`.\n     */\n    function getProxyImplementation(TransparentUpgradeableProxy proxy) public view virtual returns (address) {\n        // We need to manually run the static call since the getter cannot be flagged as view\n        // bytes4(keccak256(\"implementation()\")) == 0x5c60da1b\n        (bool success, bytes memory returndata) = address(proxy).staticcall(hex\"5c60da1b\");\n        require(success);\n        return abi.decode(returndata, (address));\n    }\n\n    /**\n     * @dev Returns the current admin of `proxy`.\n     *\n     * Requirements:\n     *\n     * - This contract must be the admin of `proxy`.\n     */\n    function getProxyAdmin(TransparentUpgradeableProxy proxy) public view virtual returns (address) {\n        // We need to manually run the static call since the getter cannot be flagged as view\n        // bytes4(keccak256(\"admin()\")) == 0xf851a440\n        (bool success, bytes memory returndata) = address(proxy).staticcall(hex\"f851a440\");\n        require(success);\n        return abi.decode(returndata, (address));\n    }\n\n    /**\n     * @dev Changes the admin of `proxy` to `newAdmin`.\n     *\n     * Requirements:\n     *\n     * - This contract must be the current admin of `proxy`.\n     */\n    function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {\n        proxy.changeAdmin(newAdmin);\n    }\n\n    /**\n     * @dev Upgrades `proxy` to `implementation`. See {TransparentUpgradeableProxy-upgradeTo}.\n     *\n     * Requirements:\n     *\n     * - This contract must be the admin of `proxy`.\n     */\n    function upgrade(TransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {\n        proxy.upgradeTo(implementation);\n    }\n\n    /**\n     * @dev Upgrades `proxy` to `implementation` and calls a function on the new implementation. See\n     * {TransparentUpgradeableProxy-upgradeToAndCall}.\n     *\n     * Requirements:\n     *\n     * - This contract must be the admin of `proxy`.\n     */\n    function upgradeAndCall(TransparentUpgradeableProxy proxy, address implementation, bytes memory data) public payable virtual onlyOwner {\n        proxy.upgradeToAndCall{value: msg.value}(implementation, data);\n    }\n}\n"
    },
    "@openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"./UpgradeableProxy.sol\";\n\n/**\n * @dev This contract implements a proxy that is upgradeable by an admin.\n *\n * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector\n * clashing], which can potentially be used in an attack, this contract uses the\n * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two\n * things that go hand in hand:\n *\n * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if\n * that call matches one of the admin functions exposed by the proxy itself.\n * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the\n * implementation. If the admin tries to call a function on the implementation it will fail with an error that says\n * \"admin cannot fallback to proxy target\".\n *\n * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing\n * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due\n * to sudden errors when trying to call a function from the proxy implementation.\n *\n * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,\n * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.\n */\ncontract TransparentUpgradeableProxy is UpgradeableProxy {\n    /**\n     * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and\n     * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.\n     */\n    constructor(address _logic, address admin_, bytes memory _data) public payable UpgradeableProxy(_logic, _data) {\n        assert(_ADMIN_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.admin\")) - 1));\n        _setAdmin(admin_);\n    }\n\n    /**\n     * @dev Emitted when the admin account has changed.\n     */\n    event AdminChanged(address previousAdmin, address newAdmin);\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 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n    /**\n     * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.\n     */\n    modifier ifAdmin() {\n        if (msg.sender == _admin()) {\n            _;\n        } else {\n            _fallback();\n        }\n    }\n\n    /**\n     * @dev Returns the current admin.\n     *\n     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.\n     *\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\n     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n     */\n    function admin() external ifAdmin returns (address admin_) {\n        admin_ = _admin();\n    }\n\n    /**\n     * @dev Returns the current implementation.\n     *\n     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.\n     *\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\n     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n     * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\n     */\n    function implementation() external ifAdmin returns (address implementation_) {\n        implementation_ = _implementation();\n    }\n\n    /**\n     * @dev Changes the admin of the proxy.\n     *\n     * Emits an {AdminChanged} event.\n     *\n     * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.\n     */\n    function changeAdmin(address newAdmin) external virtual ifAdmin {\n        require(newAdmin != address(0), \"TransparentUpgradeableProxy: new admin is the zero address\");\n        emit AdminChanged(_admin(), newAdmin);\n        _setAdmin(newAdmin);\n    }\n\n    /**\n     * @dev Upgrade the implementation of the proxy.\n     *\n     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\n     */\n    function upgradeTo(address newImplementation) external virtual ifAdmin {\n        _upgradeTo(newImplementation);\n    }\n\n    /**\n     * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified\n     * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the\n     * proxied contract.\n     *\n     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\n     */\n    function upgradeToAndCall(address newImplementation, bytes calldata data) external payable virtual ifAdmin {\n        _upgradeTo(newImplementation);\n        Address.functionDelegateCall(newImplementation, data);\n    }\n\n    /**\n     * @dev Returns the current admin.\n     */\n    function _admin() internal view virtual returns (address adm) {\n        bytes32 slot = _ADMIN_SLOT;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            adm := sload(slot)\n        }\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 admin slot.\n     */\n    function _setAdmin(address newAdmin) private {\n        bytes32 slot = _ADMIN_SLOT;\n\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            sstore(slot, newAdmin)\n        }\n    }\n\n    /**\n     * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.\n     */\n    function _beforeFallback() internal virtual override {\n        require(msg.sender != _admin(), \"TransparentUpgradeableProxy: admin cannot fallback to proxy target\");\n        super._beforeFallback();\n    }\n}\n"
    },
    "@openzeppelin/contracts/proxy/UpgradeableProxy.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"./Proxy.sol\";\nimport \"../utils/Address.sol\";\n\n/**\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\n * implementation address that can be changed. This address is stored in storage in the location specified by\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\n * implementation behind the proxy.\n *\n * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see\n * {TransparentUpgradeableProxy}.\n */\ncontract UpgradeableProxy is Proxy {\n    /**\n     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\n     *\n     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\n     * function call, and allows initializating the storage of the proxy like a Solidity constructor.\n     */\n    constructor(address _logic, bytes memory _data) public payable {\n        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.implementation\")) - 1));\n        _setImplementation(_logic);\n        if(_data.length > 0) {\n            Address.functionDelegateCall(_logic, _data);\n        }\n    }\n\n    /**\n     * @dev Emitted when the implementation is upgraded.\n     */\n    event Upgraded(address indexed implementation);\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 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function _implementation() internal view virtual override returns (address impl) {\n        bytes32 slot = _IMPLEMENTATION_SLOT;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            impl := sload(slot)\n        }\n    }\n\n    /**\n     * @dev Upgrades the proxy to a new implementation.\n     *\n     * Emits an {Upgraded} event.\n     */\n    function _upgradeTo(address newImplementation) internal virtual {\n        _setImplementation(newImplementation);\n        emit Upgraded(newImplementation);\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), \"UpgradeableProxy: new implementation is not a contract\");\n\n        bytes32 slot = _IMPLEMENTATION_SLOT;\n\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            sstore(slot, newImplementation)\n        }\n    }\n}\n"
    },
    "@openzeppelin/contracts/proxy/Proxy.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n    /**\n     * @dev Delegates the current call to `implementation`.\n     *\n     * This function does not return to its internall call site, it will return directly to the external caller.\n     */\n    function _delegate(address implementation) internal virtual {\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            // Copy msg.data. We take full control of memory in this inline assembly\n            // block because it will not return to Solidity code. We overwrite the\n            // Solidity scratch pad at memory position 0.\n            calldatacopy(0, 0, calldatasize())\n\n            // Call the implementation.\n            // out and outsize are 0 because we don't know the size yet.\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n            // Copy the returned data.\n            returndatacopy(0, 0, returndatasize())\n\n            switch result\n            // delegatecall returns 0 on error.\n            case 0 { revert(0, returndatasize()) }\n            default { return(0, returndatasize()) }\n        }\n    }\n\n    /**\n     * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\n     * and {_fallback} should delegate.\n     */\n    function _implementation() internal view virtual returns (address);\n\n    /**\n     * @dev Delegates the current call to the address returned by `_implementation()`.\n     *\n     * This function does not return to its internall call site, it will return directly to the external caller.\n     */\n    function _fallback() internal virtual {\n        _beforeFallback();\n        _delegate(_implementation());\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n     * function in the contract matches the call data.\n     */\n    fallback () external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n     * is empty.\n     */\n    receive () external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n     * call, or as part of the Solidity `fallback` or `receive` functions.\n     *\n     * If overriden should call `super._beforeFallback()`.\n     */\n    function _beforeFallback() internal virtual {\n    }\n}\n"
    },
    "contracts/proxy/BadgerBridgeZeroControllerDeployer.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0;\n\nimport { BadgerBridgeZeroControllerMatic } from \"../controllers/BadgerBridgeZeroControllerMatic.sol\";\nimport { TransparentUpgradeableProxy } from \"@openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol\";\nimport { ProxyAdmin } from \"@openzeppelin/contracts/proxy/ProxyAdmin.sol\";\n\ncontract BadgerBridgeZeroControllerDeployer {\n  address constant governance = 0x4A423AB37d70c00e8faA375fEcC4577e3b376aCa;\n  event Deployment(address indexed proxy);\n\n  constructor() {\n    address logic = address(new BadgerBridgeZeroControllerMatic());\n    ProxyAdmin proxy = new ProxyAdmin();\n    ProxyAdmin(proxy).transferOwnership(governance);\n    emit Deployment(\n      address(\n        new TransparentUpgradeableProxy(\n          logic,\n          address(proxy),\n          abi.encodeWithSelector(BadgerBridgeZeroControllerMatic.initialize.selector, governance, governance)\n        )\n      )\n    );\n    selfdestruct(msg.sender);\n  }\n}\n"
    },
    "contracts/controllers/BadgerBridgeZeroControllerMatic.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0;\npragma abicoder v2;\n\nimport { ISwapRouter } from \"@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol\";\nimport { UniswapV2Library } from \"../libraries/UniswapV2Library.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\nimport { IERC2612Permit } from \"../interfaces/IERC2612Permit.sol\";\nimport { ICurveInt128 } from \"../interfaces/CurvePools/ICurveInt128.sol\";\nimport { SplitSignatureLib } from \"../libraries/SplitSignatureLib.sol\";\nimport { IBadgerSettPeak } from \"../interfaces/IBadgerSettPeak.sol\";\nimport { ICurveFi } from \"../interfaces/ICurveFi.sol\";\nimport { IGateway } from \"../interfaces/IGateway.sol\";\nimport { IWETH9 } from \"@uniswap/v3-periphery/contracts/interfaces/external/IWETH9.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { IyVault } from \"../interfaces/IyVault.sol\";\nimport { ISett } from \"../interfaces/ISett.sol\";\nimport { Math } from \"@openzeppelin/contracts/math/Math.sol\";\nimport { SafeMath } from \"@openzeppelin/contracts/math/SafeMath.sol\";\nimport { IQuoter } from \"@uniswap/v3-periphery/contracts/interfaces/IQuoter.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts/token/ERC20/SafeERC20.sol\";\nimport { ECDSA } from \"@openzeppelin/contracts/cryptography/ECDSA.sol\";\nimport { EIP712Upgradeable } from \"@openzeppelin/contracts-upgradeable/drafts/EIP712Upgradeable.sol\";\n\ncontract BadgerBridgeZeroControllerMatic is EIP712Upgradeable {\n  using SafeERC20 for IERC20;\n  using SafeMath for *;\n  uint256 public fee;\n  address public governance;\n  address public strategist;\n\n  address constant btcGateway = 0x05Cadbf3128BcB7f2b89F3dD55E5B0a036a49e20;\n  address constant routerv3 = 0xE592427A0AEce92De3Edee1F18E0157C05861564;\n  address constant usdc = 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174;\n  address constant weth = 0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619;\n  address constant wbtc = 0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6;\n  address constant renbtc = 0xDBf31dF14B66535aF65AaC99C32e9eA844e14501;\n  address constant renCrv = 0xC2d95EEF97Ec6C17551d45e77B590dc1F9117C67;\n  address constant tricrypto = 0x960ea3e3C7FB317332d990873d354E18d7645590;\n  address constant wmatic = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270;\n  address constant quoter = 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6;\n  address constant renCrvLp = 0xf8a57c1d3b9629b77b6726a042ca48990A84Fb49;\n  uint24 constant wethWbtcFee = 500;\n  uint24 constant wethMaticFee = 500;\n  uint24 constant usdcWethFee = 500;\n  uint256 public governanceFee;\n  bytes32 constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;\n  bytes32 constant LOCK_SLOT = keccak256(\"upgrade-lock-v2\");\n  uint256 constant GAS_COST = uint256(642e3);\n  uint256 constant ETH_RESERVE = uint256(5 ether);\n  uint256 internal renbtcForOneETHPrice;\n  uint256 internal burnFee;\n  uint256 public keeperReward;\n  uint256 public constant REPAY_GAS_DIFF = 41510;\n  uint256 public constant BURN_GAS_DIFF = 41118;\n  mapping(address => uint256) public nonces;\n  bytes32 internal PERMIT_DOMAIN_SEPARATOR_WBTC;\n\n  function setStrategist(address _strategist) public {\n    require(msg.sender == governance, \"!governance\");\n    strategist = _strategist;\n  }\n\n  function setGovernance(address _governance) public {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function computeCalldataGasDiff() internal pure returns (uint256 diff) {\n    if (true) return 0; // TODO: implement exact gas metering\n    // EVM charges less for zero bytes, we must compute the offset for refund\n    // TODO make this efficient\n    uint256 sz;\n    assembly {\n      sz := calldatasize()\n    }\n    diff = sz.mul(uint256(68));\n    bytes memory slice;\n    for (uint256 i = 0; i < sz; i += 0x20) {\n      uint256 word;\n      assembly {\n        word := calldataload(i)\n      }\n      for (uint256 i = 0; i < 256 && ((uint256(~0) << i) & word) != 0; i += 8) {\n        if ((word >> i) & 0xff != 0) diff -= 64;\n      }\n    }\n  }\n\n  function getChainId() internal pure returns (uint256 result) {\n    assembly {\n      result := chainid()\n    }\n  }\n\n  function setParameters(\n    uint256 _governanceFee,\n    uint256 _fee,\n    uint256 _burnFee,\n    uint256 _keeperReward\n  ) public {\n    require(governance == msg.sender, \"!governance\");\n    governanceFee = _governanceFee;\n    fee = _fee;\n    burnFee = _burnFee;\n    keeperReward = _keeperReward;\n  }\n\n  function initialize(address _governance, address _strategist) public initializer {\n    fee = uint256(25e14);\n    burnFee = uint256(4e15);\n    governanceFee = uint256(5e17);\n    governance = _governance;\n    strategist = _strategist;\n    keeperReward = uint256(1 ether).div(1000);\n    //IERC20(renbtc).safeApprove(btcGateway, ~uint256(0) >> 2);\n    IERC20(renbtc).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(tricrypto, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(routerv3, ~uint256(0) >> 2);\n    IERC20(usdc).safeApprove(routerv3, ~uint256(0) >> 2);\n    PERMIT_DOMAIN_SEPARATOR_WBTC = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"WBTC\"),\n        keccak256(\"1\"),\n        getChainId(),\n        wbtc\n      )\n    );\n  }\n\n  function applyRatio(uint256 v, uint256 n) internal pure returns (uint256 result) {\n    result = v.mul(n).div(uint256(1 ether));\n  }\n\n  function toWBTC(uint256 amount) internal returns (uint256 amountOut) {\n    return ICurveInt128(renCrv).exchange_underlying(1, 0, amount, 1);\n  }\n\n  function toUSDC(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    uint256 wbtcAmountIn = toWBTC(amountIn);\n    bytes memory path = abi.encodePacked(wbtc, wethWbtcFee, weth, usdcWethFee, usdc);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: out,\n      deadline: block.timestamp + 1,\n      amountIn: wbtcAmountIn,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput(params);\n  }\n\n  function quote() internal {\n    bytes memory path = abi.encodePacked(wmatic, wethMaticFee, weth, wethWbtcFee, wbtc);\n    uint256 amountOut = IQuoter(quoter).quoteExactInput(path, 1 ether);\n    renbtcForOneETHPrice = ICurveInt128(renCrv).get_dy_underlying(1, 0, amountOut);\n  }\n\n  function renBTCtoETH(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    uint256 wbtcAmountOut = toWBTC(amountIn);\n    bytes memory path = abi.encodePacked(wbtc, wethWbtcFee, weth, wethMaticFee, wmatic);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: wbtcAmountOut,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput(params);\n    address payable to = address(uint160(out));\n    IWETH9(wmatic).withdraw(amountOut);\n    to.transfer(amountOut);\n  }\n\n  function fromUSDC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    bytes memory path = abi.encodePacked(usdc, usdcWethFee, weth, wethWbtcFee, wbtc);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: amountIn,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput(params);\n    amountOut = toRenBTC(amountOut);\n  }\n\n  function toRenBTC(uint256 amountIn) internal returns (uint256 amountOut) {\n    return ICurveInt128(renCrv).exchange_underlying(0, 1, amountIn, 1);\n  }\n\n  function fromETHToRenBTC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    bytes memory path = abi.encodePacked(wmatic, wethMaticFee, weth, wethWbtcFee, wbtc);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: amountIn,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput{ value: amountIn }(params);\n    return toRenBTC(amountOut);\n  }\n\n  function toETH() internal returns (uint256 amountOut) {\n    uint256 wbtcStart = IERC20(wbtc).balanceOf(address(this));\n\n    uint256 amountStart = address(this).balance;\n    (bool success, ) = tricrypto.call(\n      abi.encodeWithSelector(ICurveETHUInt256.exchange.selector, 1, 2, wbtcStart, 0, true)\n    );\n    amountOut = address(this).balance.sub(amountStart);\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function earn() public {\n    quote();\n    toWBTC(IERC20(renbtc).balanceOf(address(this)));\n    toETH();\n    uint256 balance = address(this).balance;\n    if (balance > ETH_RESERVE) {\n      uint256 output = balance - ETH_RESERVE;\n      uint256 toGovernance = applyRatio(output, governanceFee);\n      address payable governancePayable = address(uint160(governance));\n      require(governancePayable.send(toGovernance), \"error on send\");\n      address payable strategistPayable = address(uint160(strategist));\n      require(strategistPayable.send(output.sub(toGovernance)), \"error on send\");\n    }\n  }\n\n  function computeRenBTCGasFee(uint256 gasCost, uint256 gasPrice) internal view returns (uint256 result) {\n    result = gasCost.mul(tx.gasprice).mul(renbtcForOneETHPrice).div(uint256(1 ether));\n  }\n\n  function deductMintFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, fee, multiplier));\n  }\n\n  function deductBurnFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, burnFee, multiplier));\n  }\n\n  function applyFee(\n    uint256 amountIn,\n    uint256 _fee,\n    uint256 multiplier\n  ) internal view returns (uint256 amount) {\n    amount = computeRenBTCGasFee(GAS_COST.add(keeperReward.div(tx.gasprice)), tx.gasprice).add(\n      applyRatio(amountIn, _fee)\n    );\n  }\n\n  struct LoanParams {\n    address to;\n    address asset;\n    uint256 nonce;\n    uint256 amount;\n    address module;\n    address underwriter;\n    bytes data;\n    uint256 minOut;\n    uint256 _mintAmount;\n    uint256 gasDiff;\n  }\n\n  function toTypedDataHash(LoanParams memory params) internal view returns (bytes32 result) {\n    bytes32 digest = _hashTypedDataV4(\n      keccak256(\n        abi.encode(\n          keccak256(\n            \"TransferRequest(address asset,uint256 amount,address underwriter,address module,uint256 nonce,bytes data)\"\n          ),\n          params.asset,\n          params.amount,\n          params.underwriter,\n          params.module,\n          params.nonce,\n          keccak256(params.data)\n        )\n      )\n    );\n    return digest;\n  }\n\n  function repay(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public returns (uint256 amountOut) {\n    require(msg.data.length <= 516, \"too much calldata\");\n    uint256 _gasBefore = gasleft();\n    LoanParams memory params;\n    {\n      require(module == wbtc || module == usdc || module == renbtc || module == address(0x0), \"!approved-module\");\n      params = LoanParams({\n        to: to,\n        asset: asset,\n        amount: amount,\n        nonce: nonce,\n        module: module,\n        underwriter: underwriter,\n        data: data,\n        minOut: 1,\n        _mintAmount: 0,\n        gasDiff: computeCalldataGasDiff()\n      });\n      if (data.length > 0) (params.minOut) = abi.decode(data, (uint256));\n    }\n    bytes32 digest = toTypedDataHash(params);\n\n    params._mintAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    {\n      amountOut = module == wbtc ? toWBTC(deductMintFee(params._mintAmount, 1)) : module == address(0x0)\n        ? renBTCtoETH(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : module == usdc\n        ? toUSDC(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : deductMintFee(params._mintAmount, 1);\n    }\n    {\n      if (module != usdc && module != address(0x0)) IERC20(module).safeTransfer(to, amountOut);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          _gasBefore.sub(gasleft()).add(REPAY_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function computeBurnNonce(BurnLocals memory params) internal view returns (uint256 result) {\n    result = uint256(\n      keccak256(\n        abi.encodePacked(params.asset, params.amount, params.deadline, params.nonce, params.data, params.destination)\n      )\n    );\n    while (result < block.timestamp) {\n      // negligible probability of this\n      result = uint256(keccak256(abi.encodePacked(result)));\n    }\n  }\n\n  function computeERC20PermitDigest(bytes32 domainSeparator, BurnLocals memory params)\n    internal\n    view\n    returns (bytes32 result)\n  {\n    result = keccak256(\n      abi.encodePacked(\n        \"\\x19\\x01\",\n        domainSeparator,\n        keccak256(abi.encode(PERMIT_TYPEHASH, params.to, address(this), params.nonce, computeBurnNonce(params), true))\n      )\n    );\n  }\n\n  struct BurnLocals {\n    address to;\n    address asset;\n    uint256 amount;\n    uint256 deadline;\n    uint256 nonce;\n    bytes data;\n    uint256 minOut;\n    uint256 burnNonce;\n    uint256 gasBefore;\n    uint256 gasDiff;\n    uint8 v;\n    bytes32 r;\n    bytes32 s;\n    bytes destination;\n    bytes signature;\n  }\n\n  function burn(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    bytes memory data,\n    bytes memory destination,\n    bytes memory signature\n  ) public returns (uint256 amountToBurn) {\n    require(msg.data.length <= 580, \"too much calldata\");\n    BurnLocals memory params = BurnLocals({\n      to: to,\n      asset: asset,\n      amount: amount,\n      deadline: deadline,\n      data: data,\n      nonce: 0,\n      burnNonce: 0,\n      v: uint8(0),\n      r: bytes32(0),\n      s: bytes32(0),\n      destination: destination,\n      signature: signature,\n      gasBefore: gasleft(),\n      minOut: 1,\n      gasDiff: 0\n    });\n    {\n      params.gasDiff = computeCalldataGasDiff();\n      if (params.data.length > 0) (params.minOut) = abi.decode(params.data, (uint256));\n    }\n    require(block.timestamp < params.deadline, \"!deadline\");\n\n    if (params.asset == wbtc) {\n      params.nonce = nonces[to];\n      nonces[params.to]++;\n      require(\n        params.to == ECDSA.recover(computeERC20PermitDigest(PERMIT_DOMAIN_SEPARATOR_WBTC, params), params.signature),\n        \"!signature\"\n      ); //  wbtc does not implement ERC20Permit\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n        amountToBurn = toRenBTC(deductBurnFee(params.amount, 1));\n      }\n    } else if (params.asset == renbtc) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.nonce,\n          params.burnNonce,\n          true,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(params.amount, 1);\n    } else if (params.asset == usdc) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.amount,\n          params.burnNonce,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(fromUSDC(params.minOut, params.amount), 1);\n    } else revert(\"!supported-asset\");\n    {\n      IGateway(btcGateway).burn(params.destination, amountToBurn);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          params.gasBefore.sub(gasleft()).add(BURN_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function burnETH(uint256 minOut, bytes memory destination) public payable returns (uint256 amountToBurn) {\n    amountToBurn = fromETHToRenBTC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(btcGateway).burn(destination, amountToBurn);\n  }\n\n  function burnApproved(\n    address from,\n    address asset,\n    uint256 amount,\n    uint256 minOut,\n    bytes memory destination\n  ) public payable returns (uint256 amountToBurn) {\n    require(asset == wbtc || asset == usdc || asset == renbtc || asset == address(0x0), \"!approved-module\");\n    if (asset != address(0x0)) IERC20(asset).transferFrom(msg.sender, address(this), amount);\n    amountToBurn = asset == wbtc ? toRenBTC(amount.sub(applyRatio(amount, burnFee))) : asset == usdc\n      ? fromUSDC(minOut, amount.sub(applyRatio(amount, burnFee)))\n      : asset == renbtc\n      ? amount\n      : fromETHToRenBTC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(btcGateway).burn(destination, amountToBurn);\n  }\n\n  function fallbackMint(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public {\n    LoanParams memory params = LoanParams({\n      to: to,\n      asset: asset,\n      amount: amount,\n      nonce: nonce,\n      module: module,\n      underwriter: underwriter,\n      data: data,\n      minOut: 1,\n      _mintAmount: 0,\n      gasDiff: 0\n    });\n    bytes32 digest = toTypedDataHash(params);\n    uint256 _actualAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    IERC20(asset).safeTransfer(to, _actualAmount);\n  }\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveInt128.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurveInt128 {\n  function get_dy(\n    int128,\n    int128,\n    uint256\n  ) external view returns (uint256);\n\n  function get_dy_underlying(\n    int128,\n    int128,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange(\n    int128,\n    int128,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function exchange_underlying(\n    int128,\n    int128,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function coins(int128) external view returns (address);\n}\n"
    },
    "@uniswap/v3-periphery/contracts/interfaces/external/IWETH9.sol": {
      "content": "// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity =0.7.6;\n\nimport '@openzeppelin/contracts/token/ERC20/IERC20.sol';\n\n/// @title Interface for WETH9\ninterface IWETH9 is IERC20 {\n    /// @notice Deposit ether to get wrapped ether\n    function deposit() external payable;\n\n    /// @notice Withdraw wrapped ether to get ether\n    function withdraw(uint256) external;\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveETHUInt256.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\n\ninterface ICurveETHUInt256 {\n  function exchange(\n    uint256 i,\n    uint256 j,\n    uint256 dx,\n    uint256 min_dy,\n    bool use_eth\n  ) external payable returns (uint256);\n}\n"
    },
    "@uniswap/v3-periphery/contracts/interfaces/IQuoter.sol": {
      "content": "// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.7.5;\npragma abicoder v2;\n\n/// @title Quoter Interface\n/// @notice Supports quoting the calculated amounts from exact input or exact output swaps\n/// @dev These functions are not marked view because they rely on calling non-view functions and reverting\n/// to compute the result. They are also not gas efficient and should not be called on-chain.\ninterface IQuoter {\n    /// @notice Returns the amount out received for a given exact input swap without executing the swap\n    /// @param path The path of the swap, i.e. each token pair and the pool fee\n    /// @param amountIn The amount of the first token to swap\n    /// @return amountOut The amount of the last token that would be received\n    function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut);\n\n    /// @notice Returns the amount out received for a given exact input but for a swap of a single pool\n    /// @param tokenIn The token being swapped in\n    /// @param tokenOut The token being swapped out\n    /// @param fee The fee of the token pool to consider for the pair\n    /// @param amountIn The desired input amount\n    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap\n    /// @return amountOut The amount of `tokenOut` that would be received\n    function quoteExactInputSingle(\n        address tokenIn,\n        address tokenOut,\n        uint24 fee,\n        uint256 amountIn,\n        uint160 sqrtPriceLimitX96\n    ) external returns (uint256 amountOut);\n\n    /// @notice Returns the amount in required for a given exact output swap without executing the swap\n    /// @param path The path of the swap, i.e. each token pair and the pool fee. Path must be provided in reverse order\n    /// @param amountOut The amount of the last token to receive\n    /// @return amountIn The amount of first token required to be paid\n    function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn);\n\n    /// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool\n    /// @param tokenIn The token being swapped in\n    /// @param tokenOut The token being swapped out\n    /// @param fee The fee of the token pool to consider for the pair\n    /// @param amountOut The desired output amount\n    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap\n    /// @return amountIn The amount required as the input for the swap in order to receive `amountOut`\n    function quoteExactOutputSingle(\n        address tokenIn,\n        address tokenOut,\n        uint24 fee,\n        uint256 amountOut,\n        uint160 sqrtPriceLimitX96\n    ) external returns (uint256 amountIn);\n}\n"
    },
    "contracts/test/ZeroControllerTest.sol": {
      "content": "pragma solidity >=0.6.0;\n\nimport { ZeroControllerTemplate } from \"../controllers/ZeroControllerTemplate.sol\";\n\ncontract ZeroControllerTest is ZeroControllerTemplate {\n  function approveModule(address module, bool flag) public {\n    approvedModules[module] = flag;\n  }\n}\n"
    },
    "contracts/test/ControllerFundsReleaser.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport { ZeroController } from \"../controllers/ZeroController.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\n\ncontract ControllerFundsRelease {\n  address public governance;\n  address public strategist;\n\n  address public onesplit;\n  address public rewards;\n  mapping(address => address) public vaults;\n  mapping(address => address) public strategies;\n  mapping(address => mapping(address => bool)) public approvedStrategies;\n\n  uint256 public split = 500;\n  uint256 public constant max = 10000;\n  uint256 internal maxGasPrice = 100e9;\n  uint256 internal maxGasRepay = 250000;\n  uint256 internal maxGasLoan = 500000;\n  string internal constant UNDERWRITER_LOCK_IMPLEMENTATION_ID = \"zero.underwriter.lock-implementation\";\n  address internal underwriterLockImpl;\n  mapping(bytes32 => ZeroLib.LoanStatus) public loanStatus;\n  bytes32 internal constant ZERO_DOMAIN_SALT = 0xb225c57bf2111d6955b97ef0f55525b5a400dc909a5506e34b102e193dd53406;\n  bytes32 internal constant ZERO_DOMAIN_NAME_HASH = keccak256(\"ZeroController.RenVMBorrowMessage\");\n  bytes32 internal constant ZERO_DOMAIN_VERSION_HASH = keccak256(\"v2\");\n  bytes32 internal constant ZERO_RENVM_BORROW_MESSAGE_TYPE_HASH =\n    keccak256(\"RenVMBorrowMessage(address module,uint256 amount,address underwriter,uint256 pNonce,bytes pData)\");\n  bytes32 internal constant TYPE_HASH = keccak256(\"TransferRequest(address asset,uint256 amount)\");\n  bytes32 internal ZERO_DOMAIN_SEPARATOR;\n\n  function converters(address, address) public view returns (address) {\n    return address(this);\n  }\n\n  function estimate(uint256 amount) public view returns (uint256) {\n    return amount;\n  }\n\n  function convert(address) public returns (uint256) {\n    return 5000000;\n  }\n\n  function proxy(\n    address to,\n    bytes memory data,\n    uint256 value\n  ) public returns (bool) {\n    require(governance == msg.sender, \"!governance\");\n    (bool success, bytes memory result) = to.call{ value: value }(data);\n    if (!success)\n      assembly {\n        revert(add(0x20, result), mload(result))\n      }\n  }\n}\n"
    },
    "contracts/libraries/LockForLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.5.0 <0.8.0;\n\nimport { ZeroUnderwriterLock } from \"../underwriter/ZeroUnderwriterLock.sol\";\nimport { LockForImplLib } from \"./LockForImplLib.sol\";\n\n/**\n@title lockFor for external linking\n@author raymondpulver\n*/\nlibrary LockForLib {\n  function lockFor(\n    address nft,\n    address underwriterLockImpl,\n    address underwriter\n  ) external view returns (ZeroUnderwriterLock result) {\n    result = LockForImplLib.lockFor(nft, underwriterLockImpl, underwriter);\n  }\n}\n"
    },
    "contracts/libraries/factory/FactoryImplLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.5.0 <0.8.0;\n\nimport { Implementation } from \"./Implementation.sol\";\nimport { Create2 } from \"oz410/utils/Create2.sol\";\n\n/**\n@title clone factory library\n@notice deploys implementation or clones\n*/\nlibrary FactoryImplLib {\n  function assembleCreationCode(address implementation) internal pure returns (bytes memory result) {\n    result = new bytes(0x37);\n    bytes20 targetBytes = bytes20(implementation);\n    assembly {\n      let clone := add(result, 0x20)\n      mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)\n      mstore(add(clone, 0x14), targetBytes)\n      mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)\n    }\n  }\n\n  function computeAddress(\n    address creator,\n    address implementation,\n    bytes32 salt\n  ) internal pure returns (address result) {\n    result = Create2.computeAddress(salt, keccak256(assembleCreationCode(implementation)), creator);\n  }\n\n  function computeImplementationAddress(\n    address creator,\n    bytes32 bytecodeHash,\n    string memory id\n  ) internal pure returns (address result) {\n    result = Create2.computeAddress(keccak256(abi.encodePacked(id)), bytecodeHash, creator);\n  }\n\n  /// @notice Deploys a given master Contract as a clone.\n  /// Any ETH transferred with this call is forwarded to the new clone.\n  /// Emits `LogDeploy`.\n  /// @param implementation Address of implementation\n  /// @param salt Salt to use\n  /// @return cloneAddress Address of the created clone contract.\n  function deploy(address implementation, bytes32 salt) internal returns (address cloneAddress) {\n    bytes memory creationCode = assembleCreationCode(implementation);\n    assembly {\n      cloneAddress := create2(0, add(0x20, creationCode), 0x37, salt)\n    }\n  }\n\n  function deployImplementation(bytes memory creationCode, string memory id) internal returns (address implementation) {\n    bytes32 salt = keccak256(abi.encodePacked(id));\n    assembly {\n      implementation := create2(0, add(0x20, creationCode), mload(creationCode), salt)\n    }\n  }\n}\n"
    },
    "contracts/modules/MetaExecutorEthereum.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\nimport { ArbitrumConvertLib } from \"./ArbitrumConvertLib.sol\";\nimport { IZeroMeta } from \"../interfaces/IZeroMeta.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { IRenCrvArbitrum } from \"../interfaces/CurvePools/IRenCrvArbitrum.sol\";\nimport \"hardhat/console.sol\";\n\ncontract MetaExecutorEthereum is IZeroMeta {\n  using SafeERC20 for *;\n  using SafeMath for *;\n  mapping(uint256 => ArbitrumConvertLib.ConvertRecord) public outstanding;\n  address public immutable controller;\n  uint256 public blockTimeout;\n  address public constant weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n  address public constant wbtc = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;\n  address public constant want = 0xEB4C2781e4ebA804CE9a9803C67d0893436bB27D;\n  address public constant renCrvArbitrum = 0x93054188d876f558f4a66B2EF1d97d16eDf0895B;\n  address public constant tricryptoArbitrum = 0x80466c64868E1ab14a1Ddf27A676C3fcBE638Fe5;\n  uint256 public capacity;\n  struct ConvertRecord {\n    uint128 volume;\n    uint128 when;\n  }\n  mapping(uint256 => ConvertRecord) public records;\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  function governance() public view returns (address) {\n    return IController(controller).governance();\n  }\n\n  function setBlockTimeout(uint256 _amount) public {\n    require(msg.sender == governance(), \"!governance\");\n    blockTimeout = _amount;\n  }\n\n  constructor(\n    address _controller,\n    uint256 _capacity,\n    uint256 _blockTimeout\n  ) {\n    controller = _controller;\n    capacity = _capacity;\n    blockTimeout = _blockTimeout;\n    IERC20(want).safeApprove(renCrvArbitrum, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(tricryptoArbitrum, ~uint256(0) >> 2);\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function receiveMeta(\n    address from,\n    address asset,\n    uint256 nonce,\n    bytes memory data\n  ) public override onlyController {\n    // stuff here\n  }\n\n  function repayMeta(uint256 value) public override onlyController {\n    // stuff here\n    console.log(IERC20(want).balanceOf(address(this)));\n    IERC20(want).safeTransfer(controller, value);\n    console.log(want, value);\n  }\n\n  function computeReserveRequirement(uint256 _in) external view returns (uint256) {\n    return _in.mul(12e17).div(1e18); // 120% collateralized\n  }\n}\n"
    },
    "contracts/modules/ArbitrumConvertLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\nlibrary ArbitrumConvertLib {\n  struct ConvertRecord {\n    uint256 when;\n    uint256 qty;\n    uint256 qtyETH;\n  }\n}\n"
    },
    "contracts/interfaces/CurvePools/IRenCrvArbitrum.sol": {
      "content": "interface IRenCrvArbitrum {\n  function exchange(\n    int128 i,\n    int128 j,\n    uint256 dx,\n    uint256 min_dy,\n    address recipient\n  ) external returns (uint256);\n}\n"
    },
    "contracts/modules/MetaExecutor.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\nimport { ArbitrumConvertLib } from \"./ArbitrumConvertLib.sol\";\nimport { IZeroMeta } from \"../interfaces/IZeroMeta.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { IRenCrvArbitrum } from \"../interfaces/CurvePools/IRenCrvArbitrum.sol\";\nimport \"hardhat/console.sol\";\n\ncontract MetaExecutor is IZeroMeta {\n  using SafeERC20 for *;\n  using SafeMath for *;\n  mapping(uint256 => ArbitrumConvertLib.ConvertRecord) public outstanding;\n  address public immutable controller;\n  uint256 public blockTimeout;\n  address public constant weth = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;\n  address public constant wbtc = 0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f;\n  address public constant want = 0xDBf31dF14B66535aF65AaC99C32e9eA844e14501;\n  address public constant renCrvArbitrum = 0x3E01dD8a5E1fb3481F0F589056b428Fc308AF0Fb;\n  address public constant tricryptoArbitrum = 0x960ea3e3C7FB317332d990873d354E18d7645590;\n  uint256 public capacity;\n  struct ConvertRecord {\n    uint128 volume;\n    uint128 when;\n  }\n  mapping(uint256 => ConvertRecord) public records;\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  function governance() public view returns (address) {\n    return IController(controller).governance();\n  }\n\n  function setBlockTimeout(uint256 _amount) public {\n    require(msg.sender == governance(), \"!governance\");\n    blockTimeout = _amount;\n  }\n\n  constructor(\n    address _controller,\n    uint256 _capacity,\n    uint256 _blockTimeout\n  ) {\n    controller = _controller;\n    capacity = _capacity;\n    blockTimeout = _blockTimeout;\n    IERC20(want).safeApprove(renCrvArbitrum, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(tricryptoArbitrum, ~uint256(0) >> 2);\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function receiveMeta(\n    address from,\n    address asset,\n    uint256 nonce,\n    bytes memory data\n  ) public override onlyController {\n    // stuff here\n  }\n\n  function repayMeta(uint256 value) public override onlyController {\n    // stuff here\n    console.log(IERC20(want).balanceOf(address(this)));\n    IERC20(want).safeTransfer(controller, value);\n    console.log(want, value);\n  }\n\n  function computeReserveRequirement(uint256 _in) external view returns (uint256) {\n    return _in.mul(12e17).div(1e18); // 120% collateralized\n  }\n}\n"
    },
    "contracts/modules/BadgerBridge.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\nimport { BadgerBridgeLib } from \"./BadgerBridgeLib.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { IRenCrv } from \"../interfaces/CurvePools/IRenCrv.sol\";\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\n\ncontract BadgerBridge is IZeroModule {\n  using SafeERC20 for *;\n  using SafeMath for *;\n  mapping(uint256 => BadgerBridgeLib.ConvertRecord) public outstanding;\n  address public immutable controller;\n  address public immutable governance;\n  uint256 public blockTimeout;\n  address public constant weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n  address public constant wbtc = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;\n  address public constant override want = wbtc;\n  address public constant renCrv = 0x93054188d876f558f4a66B2EF1d97d16eDf0895B;\n  address public constant tricrypto = 0x80466c64868E1ab14a1Ddf27A676C3fcBE638Fe5;\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  constructor(address _controller) {\n    controller = _controller;\n    governance = IController(_controller).governance();\n    IERC20(want).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(tricrypto, ~uint256(0) >> 2);\n  }\n\n  function setBlockTimeout(uint256 _ct) public {\n    require(msg.sender == governance, \"!governance\");\n    blockTimeout = _ct;\n  }\n\n  function isActive(BadgerBridgeLib.ConvertRecord storage record) internal view returns (bool) {\n    return record.qty != 0;\n  }\n\n  function defaultLoan(uint256 _nonce) public {\n    require(block.number >= outstanding[_nonce].when + blockTimeout);\n    require(isActive(outstanding[_nonce]), \"!outstanding\");\n    uint256 _amountSwappedBack = outstanding[_nonce].qty;\n    IERC20(want).safeTransfer(controller, _amountSwappedBack);\n    delete outstanding[_nonce];\n  }\n\n  function receiveLoan(\n    address _to,\n    address, /* _asset */\n    uint256 _actual,\n    uint256 _nonce,\n    bytes memory /* _data */\n  ) public override onlyController {\n    outstanding[_nonce] = BadgerBridgeLib.ConvertRecord({ qty: uint128(_actual), when: uint128(block.timestamp) });\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function repayLoan(\n    address _to,\n    address, /* _asset */\n    uint256, /* _actualAmount */\n    uint256 _nonce,\n    bytes memory /* _data */\n  ) public override onlyController {\n    require(outstanding[_nonce].qty != 0, \"!outstanding\");\n    IERC20(want).safeTransfer(_to, outstanding[_nonce].qty);\n    delete outstanding[_nonce];\n  }\n\n  function computeReserveRequirement(uint256 _in) external view override returns (uint256) {\n    return _in.mul(uint256(1e17)).div(uint256(1 ether));\n  }\n}\n"
    },
    "contracts/modules/BadgerBridgeLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\nlibrary BadgerBridgeLib {\n  struct ConvertRecord {\n    uint128 when;\n    uint128 qty;\n  }\n}\n"
    },
    "contracts/controllers/BadgerBridgeZeroControllerAvax.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.5.0;\npragma abicoder v2;\n\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { ISwapRouter } from \"@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol\";\nimport { JoeLibrary } from \"../libraries/JoeLibrary.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\nimport { IERC2612Permit } from \"../interfaces/IERC2612Permit.sol\";\nimport { IRenCrv } from \"../interfaces/CurvePools/IRenCrv.sol\";\nimport { SplitSignatureLib } from \"../libraries/SplitSignatureLib.sol\";\nimport { IBadgerSettPeak } from \"../interfaces/IBadgerSettPeak.sol\";\nimport { ICurveFi } from \"../interfaces/ICurveFiAvax.sol\";\nimport { IGateway } from \"../interfaces/IGateway.sol\";\nimport { ICurveUInt256 } from \"../interfaces/CurvePools/ICurveUInt256.sol\";\nimport { ICurveInt128 } from \"../interfaces/CurvePools/ICurveInt128Avax.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { IyVault } from \"../interfaces/IyVault.sol\";\nimport { ISett } from \"../interfaces/ISett.sol\";\nimport { Math } from \"@openzeppelin/contracts/math/Math.sol\";\nimport { SafeMath } from \"@openzeppelin/contracts/math/SafeMath.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts/token/ERC20/SafeERC20.sol\";\nimport { ECDSA } from \"@openzeppelin/contracts/cryptography/ECDSA.sol\";\nimport { EIP712Upgradeable } from \"@openzeppelin/contracts-upgradeable/drafts/EIP712Upgradeable.sol\";\nimport { ICurveFi as ICurveFiRen } from \"../interfaces/ICurveFi.sol\";\nimport { IJoeRouter02 } from \"@traderjoe-xyz/core/contracts/traderjoe/interfaces/IJoeRouter02.sol\";\n\ncontract BadgerBridgeZeroControllerAvax is EIP712Upgradeable {\n  using SafeERC20 for IERC20;\n  using SafeMath for *;\n  uint256 public fee;\n  address public governance;\n  address public strategist;\n\n  address constant btcGateway = 0x05Cadbf3128BcB7f2b89F3dD55E5B0a036a49e20;\n  address constant factory = 0x9Ad6C38BE94206cA50bb0d90783181662f0Cfa10;\n  address constant crvUsd = 0x7f90122BF0700F9E7e1F688fe926940E8839F353;\n  address constant av3Crv = 0x1337BedC9D22ecbe766dF105c9623922A27963EC;\n  address constant usdc = 0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664;\n  address constant usdc_native = 0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E;\n  address constant usdcpool = 0x3a43A5851A3e3E0e25A3c1089670269786be1577;\n  address constant wavax = 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7;\n  address constant weth = 0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB;\n  address constant wbtc = 0x50b7545627a5162F82A992c33b87aDc75187B218;\n  address constant avWbtc = 0x686bEF2417b6Dc32C50a3cBfbCC3bb60E1e9a15D;\n  address constant renbtc = 0xDBf31dF14B66535aF65AaC99C32e9eA844e14501;\n  address constant renCrv = 0x16a7DA911A4DD1d83F3fF066fE28F3C792C50d90;\n  address constant tricrypto = 0xB755B949C126C04e0348DD881a5cF55d424742B2;\n  address constant renCrvLp = 0xC2b1DF84112619D190193E48148000e3990Bf627;\n  address constant joeRouter = 0x60aE616a2155Ee3d9A68541Ba4544862310933d4;\n  address constant bCrvRen = 0x6dEf55d2e18486B9dDfaA075bc4e4EE0B28c1545;\n  address constant settPeak = 0x41671BA1abcbA387b9b2B752c205e22e916BE6e3;\n  address constant ibbtc = 0xc4E15973E6fF2A35cC804c2CF9D2a1b817a8b40F;\n  uint256 public governanceFee;\n  bytes32 constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;\n  uint256 constant GAS_COST = uint256(124e4);\n  uint256 constant IBBTC_GAS_COST = uint256(7e5);\n  uint256 constant ETH_RESERVE = uint256(5 ether);\n  bytes32 constant LOCK_SLOT = keccak256(\"upgrade-lock-v1-avax\");\n  uint256 internal renbtcForOneETHPrice;\n  uint256 internal burnFee;\n  uint256 public keeperReward;\n  uint256 public constant REPAY_GAS_DIFF = 41510;\n  uint256 public constant BURN_GAS_DIFF = 41118;\n  mapping(address => uint256) public nonces;\n  mapping(address => uint256) public noncesUsdc;\n  bytes32 internal PERMIT_DOMAIN_SEPARATOR_WBTC;\n  bytes32 internal PERMIT_DOMAIN_SEPARATOR_IBBTC;\n  bytes32 internal PERMIT_DOMAIN_SEPARATOR_USDC;\n\n  function setStrategist(address _strategist) public {\n    require(msg.sender == governance, \"!governance\");\n    strategist = _strategist;\n  }\n\n  function postUpgrade() public {\n    bool isLocked;\n    bytes32 upgradeSlot = LOCK_SLOT;\n\n    assembly {\n      isLocked := sload(upgradeSlot)\n    }\n    require(!isLocked, \"already upgraded\");\n    IERC20(usdc).safeApprove(usdcpool, ~uint256(0) >> 2);\n    IERC20(usdc_native).safeApprove(usdcpool, ~uint256(0) >> 2);\n    isLocked = true;\n    assembly {\n      sstore(upgradeSlot, isLocked)\n    }\n  }\n\n  function setGovernance(address _governance) public {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function computeCalldataGasDiff() internal pure returns (uint256 diff) {\n    if (true) return 0; // TODO: implement exact gas metering\n    // EVM charges less for zero bytes, we must compute the offset for refund\n    // TODO make this efficient\n    uint256 sz;\n    assembly {\n      sz := calldatasize()\n    }\n    diff = sz.mul(uint256(68));\n    bytes memory slice;\n    for (uint256 i = 0; i < sz; i += 0x20) {\n      uint256 word;\n      assembly {\n        word := calldataload(i)\n      }\n      for (uint256 i = 0; i < 256 && ((uint256(~0) << i) & word) != 0; i += 8) {\n        if ((word >> i) & 0xff != 0) diff -= 64;\n      }\n    }\n  }\n\n  function getChainId() internal pure returns (uint256 result) {\n    assembly {\n      result := chainid()\n    }\n  }\n\n  function setParameters(\n    uint256 _governanceFee,\n    uint256 _fee,\n    uint256 _burnFee,\n    uint256 _keeperReward\n  ) public {\n    require(governance == msg.sender, \"!governance\");\n    governanceFee = _governanceFee;\n    fee = _fee;\n    burnFee = _burnFee;\n    keeperReward = _keeperReward;\n  }\n\n  function initialize(address _governance, address _strategist) public initializer {\n    fee = uint256(25e14);\n    burnFee = uint256(4e15);\n    governanceFee = uint256(5e17);\n    governance = _governance;\n    strategist = _strategist;\n    keeperReward = uint256(1 ether).div(1000);\n    //IERC20(renbtc).safeApprove(btcGateway, ~uint256(0) >> 2);\n    IERC20(renbtc).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(avWbtc).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(avWbtc).safeApprove(tricrypto, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(joeRouter, ~uint256(0) >> 2);\n    IERC20(weth).safeApprove(tricrypto, ~uint256(0) >> 2);\n    IERC20(weth).safeApprove(joeRouter, ~uint256(0) >> 2);\n    IERC20(wavax).safeApprove(joeRouter, ~uint256(0) >> 2);\n    IERC20(av3Crv).safeApprove(crvUsd, ~uint256(0) >> 2);\n    IERC20(av3Crv).safeApprove(tricrypto, ~uint256(0) >> 2);\n    IERC20(usdc).safeApprove(crvUsd, ~uint256(0) >> 2);\n    IERC20(usdc).safeApprove(usdcpool, ~uint256(0) >> 2);\n    IERC20(usdc_native).safeApprove(usdcpool, ~uint256(0) >> 2);\n    IERC20(renCrvLp).safeApprove(bCrvRen, ~uint256(0) >> 2);\n    //IERC20(bCrvRen).safeApprove(settPeak, ~uint256(0) >> 2);\n    PERMIT_DOMAIN_SEPARATOR_WBTC = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"WBTC\"),\n        keccak256(\"1\"),\n        getChainId(),\n        wbtc\n      )\n    );\n    PERMIT_DOMAIN_SEPARATOR_USDC = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"USD Coin\"),\n        keccak256(\"1\"),\n        getChainId(),\n        usdc\n      )\n    );\n    PERMIT_DOMAIN_SEPARATOR_IBBTC = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"ibBTC\"),\n        keccak256(\"1\"),\n        getChainId(),\n        ibbtc\n      )\n    );\n  }\n\n  function applyRatio(uint256 v, uint256 n) internal pure returns (uint256 result) {\n    result = v.mul(n).div(uint256(1 ether));\n  }\n\n  function toWBTC(uint256 amount, bool useUnderlying) internal returns (uint256 amountOut) {\n    if (useUnderlying) amountOut = ICurveInt128(renCrv).exchange_underlying(1, 0, amount, 1);\n    else amountOut = ICurveInt128(renCrv).exchange(1, 0, amount, 1);\n  }\n\n  function toIBBTC(uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256[2] memory amounts;\n    amounts[0] = amountIn;\n    ICurveFiRen(renCrv).add_liquidity(amounts, 0);\n    ISett(bCrvRen).deposit(IERC20(renCrvLp).balanceOf(address(this)));\n    amountOut = IBadgerSettPeak(settPeak).mint(0, IERC20(bCrvRen).balanceOf(address(this)), new bytes32[](0));\n  }\n\n  function toUSDC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 usdAmount = IERC20(av3Crv).balanceOf(address(this));\n    uint256 wbtcAmount = toWBTC(amountIn, false);\n    ICurveUInt256(tricrypto).exchange(1, 0, wbtcAmount, 1);\n    usdAmount = IERC20(av3Crv).balanceOf(address(this)).sub(usdAmount);\n    amountOut = ICurveFi(crvUsd).remove_liquidity_one_coin(usdAmount, 1, 1, true);\n  }\n\n  function toUSDCNative(uint256 amountIn) internal returns (uint256 amountOut) {\n    amountOut = toUSDC(1, amountIn);\n    amountOut = ICurveInt128(usdcpool).exchange(0, 1, amountOut, 1, address(this));\n  }\n\n  function quote() internal {\n    (uint256 amountWavax, uint256 amountWBTC) = JoeLibrary.getReserves(factory, wavax, wbtc);\n    uint256 amount = JoeLibrary.quote(1 ether, amountWavax, amountWBTC);\n    renbtcForOneETHPrice = ICurveInt128(renCrv).get_dy(1, 0, amount);\n  }\n\n  function toRenBTC(uint256 amountIn, bool useUnderlying) internal returns (uint256 amountOut) {\n    if (useUnderlying) amountOut = ICurveInt128(renCrv).exchange_underlying(0, 1, amountIn, 1);\n    else amountOut = ICurveInt128(renCrv).exchange(0, 1, amountIn, 1);\n  }\n\n  function renBTCtoETH(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    uint256 wbtcAmount = toWBTC(amountIn, true);\n    address[] memory path = new address[](2);\n    path[0] = wbtc;\n    path[1] = wavax;\n    uint256[] memory amounts = IJoeRouter02(joeRouter).swapExactTokensForAVAX(\n      wbtcAmount,\n      minOut,\n      path,\n      out,\n      block.timestamp + 1\n    );\n    amountOut = amounts[1];\n  }\n\n  function fromIBBTC(uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 amountStart = IERC20(renbtc).balanceOf(address(this));\n    IBadgerSettPeak(settPeak).redeem(0, amountIn);\n    ISett(bCrvRen).withdraw(IERC20(bCrvRen).balanceOf(address(this)));\n    ICurveFiRen(renCrv).remove_liquidity_one_coin(IERC20(renCrvLp).balanceOf(address(this)), 0, 0);\n    amountOut = IERC20(renbtc).balanceOf(address(this)).sub(amountStart);\n  }\n\n  function fromUSDC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 wbtcAmount = IERC20(avWbtc).balanceOf(address(this));\n    uint256[3] memory amounts;\n    amounts[1] = amountIn;\n    amountOut = ICurveFi(crvUsd).add_liquidity(amounts, 1, true);\n    ICurveUInt256(tricrypto).exchange(0, 1, amountOut, 1);\n    wbtcAmount = IERC20(avWbtc).balanceOf(address(this)).sub(wbtcAmount);\n    amountOut = toRenBTC(wbtcAmount, false);\n  }\n\n  function fromUSDCNative(uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 usdceAmountIn = ICurveInt128(usdcpool).exchange(1, 0, amountIn, 1, address(this));\n    return fromUSDC(1, usdceAmountIn);\n  }\n\n  function fromETHToRenBTC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    address[] memory path = new address[](2);\n    path[0] = wavax;\n    path[1] = wbtc;\n\n    uint256[] memory amounts = IJoeRouter02(joeRouter).swapExactAVAXForTokens{ value: amountIn }(\n      minOut,\n      path,\n      address(this),\n      block.timestamp + 1\n    );\n    amountOut = toRenBTC(amounts[1], true);\n  }\n\n  function toETH() internal returns (uint256 amountOut) {\n    uint256 wbtcAmount = IERC20(wbtc).balanceOf(address(this));\n    address[] memory path = new address[](2);\n    path[0] = wbtc;\n    path[1] = wavax;\n    uint256[] memory amounts = IJoeRouter02(joeRouter).swapExactTokensForAVAX(\n      wbtcAmount,\n      1,\n      path,\n      address(this),\n      block.timestamp + 1\n    );\n    amountOut = amounts[1];\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function earn() public {\n    quote();\n    toWBTC(IERC20(renbtc).balanceOf(address(this)), true);\n    toETH();\n    uint256 balance = address(this).balance;\n    if (balance > ETH_RESERVE) {\n      uint256 output = balance - ETH_RESERVE;\n      uint256 toGovernance = applyRatio(output, governanceFee);\n      address payable governancePayable = address(uint160(governance));\n      require(governancePayable.send(toGovernance), \"error on send\");\n      address payable strategistPayable = address(uint160(strategist));\n      require(strategistPayable.send(output.sub(toGovernance)), \"error on send\");\n    }\n  }\n\n  function computeRenBTCGasFee(uint256 gasCost, uint256 gasPrice) internal view returns (uint256 result) {\n    result = gasCost.mul(tx.gasprice).mul(renbtcForOneETHPrice).div(uint256(1 ether));\n  }\n\n  function deductMintFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, fee, multiplier));\n  }\n\n  function deductIBBTCMintFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyIBBTCFee(amountIn, fee, multiplier));\n  }\n\n  function deductBurnFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, burnFee, multiplier));\n  }\n\n  function deductIBBTCBurnFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyIBBTCFee(amountIn, burnFee, multiplier));\n  }\n\n  function applyFee(\n    uint256 amountIn,\n    uint256 _fee,\n    uint256 multiplier\n  ) internal view returns (uint256 amount) {\n    amount = computeRenBTCGasFee(GAS_COST.add(keeperReward.div(tx.gasprice)), tx.gasprice).add(\n      applyRatio(amountIn, _fee)\n    );\n  }\n\n  function applyIBBTCFee(\n    uint256 amountIn,\n    uint256 _fee,\n    uint256 multiplier\n  ) internal view returns (uint256 amount) {\n    amount = computeRenBTCGasFee(IBBTC_GAS_COST.add(keeperReward.div(tx.gasprice)), tx.gasprice).add(\n      applyRatio(amountIn, _fee)\n    );\n  }\n\n  struct LoanParams {\n    address to;\n    address asset;\n    uint256 nonce;\n    uint256 amount;\n    address module;\n    address underwriter;\n    bytes data;\n    uint256 minOut;\n    uint256 _mintAmount;\n    uint256 gasDiff;\n  }\n\n  function toTypedDataHash(LoanParams memory params) internal view returns (bytes32 result) {\n    bytes32 digest = _hashTypedDataV4(\n      keccak256(\n        abi.encode(\n          keccak256(\n            \"TransferRequest(address asset,uint256 amount,address underwriter,address module,uint256 nonce,bytes data)\"\n          ),\n          params.asset,\n          params.amount,\n          params.underwriter,\n          params.module,\n          params.nonce,\n          keccak256(params.data)\n        )\n      )\n    );\n    return digest;\n  }\n\n  function repay(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public returns (uint256 amountOut) {\n    require(msg.data.length <= 516, \"too much calldata\");\n    uint256 _gasBefore = gasleft();\n    LoanParams memory params;\n    {\n      require(\n        module == wbtc || module == usdc || module == renbtc || module == address(0x0) || module == usdc_native,\n        \"!approved-module\"\n      );\n      params = LoanParams({\n        to: to,\n        asset: asset,\n        amount: amount,\n        nonce: nonce,\n        module: module,\n        underwriter: underwriter,\n        data: data,\n        minOut: 1,\n        _mintAmount: 0,\n        gasDiff: computeCalldataGasDiff()\n      });\n      if (data.length > 0) (params.minOut) = abi.decode(data, (uint256));\n    }\n    bytes32 digest = toTypedDataHash(params);\n\n    params._mintAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    {\n      amountOut = module == wbtc ? toWBTC(deductMintFee(params._mintAmount, 1), true) : module == address(0x0)\n        ? renBTCtoETH(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : module == usdc\n        ? toUSDC(params.minOut, deductMintFee(params._mintAmount, 1))\n        : module == usdc_native\n        ? toUSDCNative(deductMintFee(params._mintAmount, 1))\n        : deductMintFee(params._mintAmount, 1);\n    }\n    {\n      if (module != address(0x0)) IERC20(module).safeTransfer(to, amountOut);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          _gasBefore.sub(gasleft()).add(REPAY_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function computeBurnNonce(BurnLocals memory params) internal view returns (uint256 result) {\n    result = uint256(\n      keccak256(\n        abi.encodePacked(params.asset, params.amount, params.deadline, params.nonce, params.data, params.destination)\n      )\n    );\n    while (result < block.timestamp) {\n      // negligible probability of this\n      result = uint256(keccak256(abi.encodePacked(result)));\n    }\n  }\n\n  function computeERC20PermitDigest(bytes32 domainSeparator, BurnLocals memory params)\n    internal\n    view\n    returns (bytes32 result)\n  {\n    result = keccak256(\n      abi.encodePacked(\n        \"\\x19\\x01\",\n        domainSeparator,\n        keccak256(abi.encode(PERMIT_TYPEHASH, params.to, address(this), params.nonce, computeBurnNonce(params), true))\n      )\n    );\n  }\n\n  struct BurnLocals {\n    address to;\n    address asset;\n    uint256 amount;\n    uint256 deadline;\n    uint256 nonce;\n    bytes data;\n    uint256 minOut;\n    uint256 burnNonce;\n    uint256 gasBefore;\n    uint256 gasDiff;\n    uint8 v;\n    bytes32 r;\n    bytes32 s;\n    bytes destination;\n    bytes signature;\n  }\n\n  function burn(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    bytes memory data,\n    bytes memory destination,\n    bytes memory signature\n  ) public returns (uint256 amountToBurn) {\n    require(msg.data.length <= 580, \"too much calldata\");\n    BurnLocals memory params = BurnLocals({\n      to: to,\n      asset: asset,\n      amount: amount,\n      deadline: deadline,\n      data: data,\n      nonce: 0,\n      burnNonce: 0,\n      v: uint8(0),\n      r: bytes32(0),\n      s: bytes32(0),\n      destination: destination,\n      signature: signature,\n      gasBefore: gasleft(),\n      minOut: 1,\n      gasDiff: 0\n    });\n    {\n      params.gasDiff = computeCalldataGasDiff();\n      if (params.data.length > 0) (params.minOut) = abi.decode(params.data, (uint256));\n    }\n    require(block.timestamp < params.deadline, \"!deadline\");\n\n    if (params.asset == wbtc) {\n      params.nonce = nonces[to];\n      nonces[params.to]++;\n      require(\n        params.to == ECDSA.recover(computeERC20PermitDigest(PERMIT_DOMAIN_SEPARATOR_WBTC, params), params.signature),\n        \"!signature\"\n      ); //  wbtc does not implement ERC20Permit\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n        amountToBurn = toRenBTC(deductBurnFee(params.amount, 1), true);\n      }\n    } else if (asset == usdc_native) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.amount,\n          params.burnNonce,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n        amountToBurn = deductBurnFee(fromUSDCNative(params.amount), 1);\n      }\n    } else if (params.asset == renbtc) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.nonce,\n          params.burnNonce,\n          true,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(params.amount, 1);\n    } else if (params.asset == usdc) {\n      params.nonce = noncesUsdc[to];\n      noncesUsdc[params.to]++;\n      require(\n        params.to == ECDSA.recover(computeERC20PermitDigest(PERMIT_DOMAIN_SEPARATOR_USDC, params), params.signature),\n        \"!signature\"\n      ); //  usdc.e does not implement ERC20Permit\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(fromUSDC(params.minOut, params.amount), 1);\n    } else revert(\"!supported-asset\");\n    {\n      IGateway(btcGateway).burn(params.destination, amountToBurn);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          params.gasBefore.sub(gasleft()).add(BURN_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function burnETH(uint256 minOut, bytes memory destination) public payable returns (uint256 amountToBurn) {\n    amountToBurn = fromETHToRenBTC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(btcGateway).burn(destination, amountToBurn);\n  }\n\n  function burnApproved(\n    address from,\n    address asset,\n    uint256 amount,\n    uint256 minOut,\n    bytes memory destination\n  ) public payable returns (uint256 amountToBurn) {\n    require(asset == wbtc || asset == usdc || asset == renbtc || asset == address(0x0), \"!approved-module\");\n    if (asset != address(0x0)) IERC20(asset).transferFrom(msg.sender, address(this), amount);\n    amountToBurn = asset == wbtc ? toRenBTC(amount.sub(applyRatio(amount, burnFee)), true) : asset == usdc\n      ? fromUSDC(minOut, amount.sub(applyRatio(amount, burnFee)))\n      : asset == renbtc\n      ? amount\n      : fromETHToRenBTC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(btcGateway).burn(destination, amountToBurn);\n  }\n\n  function fallbackMint(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public {\n    LoanParams memory params = LoanParams({\n      to: to,\n      asset: asset,\n      amount: amount,\n      nonce: nonce,\n      module: module,\n      underwriter: underwriter,\n      data: data,\n      minOut: 1,\n      _mintAmount: 0,\n      gasDiff: 0\n    });\n    bytes32 digest = toTypedDataHash(params);\n    uint256 _actualAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    IERC20(asset).safeTransfer(to, _actualAmount);\n  }\n}\n"
    },
    "contracts/libraries/JoeLibrary.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0\n\npragma solidity >=0.5.0;\n\nimport \"@traderjoe-xyz/core/contracts/traderjoe/interfaces/IJoePair.sol\";\n\nimport \"oz410/math/SafeMath.sol\";\n\nlibrary JoeLibrary {\n  using SafeMath for uint256;\n\n  // returns sorted token addresses, used to handle return values from pairs sorted in this order\n  function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {\n    require(tokenA != tokenB, \"JoeLibrary: IDENTICAL_ADDRESSES\");\n    (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);\n    require(token0 != address(0), \"JoeLibrary: ZERO_ADDRESS\");\n  }\n\n  // calculates the CREATE2 address for a pair without making any external calls\n  function pairFor(\n    address factory,\n    address tokenA,\n    address tokenB\n  ) internal pure returns (address pair) {\n    (address token0, address token1) = sortTokens(tokenA, tokenB);\n    pair = address(\n      uint256(\n        keccak256(\n          abi.encodePacked(\n            hex\"ff\",\n            factory,\n            keccak256(abi.encodePacked(token0, token1)),\n            hex\"0bbca9af0511ad1a1da383135cf3a8d2ac620e549ef9f6ae3a4c33c2fed0af91\" // init code fuji\n          )\n        )\n      )\n    );\n  }\n\n  // fetches and sorts the reserves for a pair\n  function getReserves(\n    address factory,\n    address tokenA,\n    address tokenB\n  ) internal view returns (uint256 reserveA, uint256 reserveB) {\n    (address token0, ) = sortTokens(tokenA, tokenB);\n    (uint256 reserve0, uint256 reserve1, ) = IJoePair(pairFor(factory, tokenA, tokenB)).getReserves();\n    (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);\n  }\n\n  // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset\n  function quote(\n    uint256 amountA,\n    uint256 reserveA,\n    uint256 reserveB\n  ) internal pure returns (uint256 amountB) {\n    require(amountA > 0, \"JoeLibrary: INSUFFICIENT_AMOUNT\");\n    require(reserveA > 0 && reserveB > 0, \"JoeLibrary: INSUFFICIENT_LIQUIDITY\");\n    amountB = amountA.mul(reserveB) / reserveA;\n  }\n\n  // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset\n  function getAmountOut(\n    uint256 amountIn,\n    uint256 reserveIn,\n    uint256 reserveOut\n  ) internal pure returns (uint256 amountOut) {\n    require(amountIn > 0, \"JoeLibrary: INSUFFICIENT_INPUT_AMOUNT\");\n    require(reserveIn > 0 && reserveOut > 0, \"JoeLibrary: INSUFFICIENT_LIQUIDITY\");\n    uint256 amountInWithFee = amountIn.mul(997);\n    uint256 numerator = amountInWithFee.mul(reserveOut);\n    uint256 denominator = reserveIn.mul(1000).add(amountInWithFee);\n    amountOut = numerator / denominator;\n  }\n\n  // given an output amount of an asset and pair reserves, returns a required input amount of the other asset\n  function getAmountIn(\n    uint256 amountOut,\n    uint256 reserveIn,\n    uint256 reserveOut\n  ) internal pure returns (uint256 amountIn) {\n    require(amountOut > 0, \"JoeLibrary: INSUFFICIENT_OUTPUT_AMOUNT\");\n    require(reserveIn > 0 && reserveOut > 0, \"JoeLibrary: INSUFFICIENT_LIQUIDITY\");\n    uint256 numerator = reserveIn.mul(amountOut).mul(1000);\n    uint256 denominator = reserveOut.sub(amountOut).mul(997);\n    amountIn = (numerator / denominator).add(1);\n  }\n\n  // performs chained getAmountOut calculations on any number of pairs\n  function getAmountsOut(\n    address factory,\n    uint256 amountIn,\n    address[] memory path\n  ) internal view returns (uint256[] memory amounts) {\n    require(path.length >= 2, \"JoeLibrary: INVALID_PATH\");\n    amounts = new uint256[](path.length);\n    amounts[0] = amountIn;\n    for (uint256 i; i < path.length - 1; i++) {\n      (uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i], path[i + 1]);\n      amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);\n    }\n  }\n\n  // performs chained getAmountIn calculations on any number of pairs\n  function getAmountsIn(\n    address factory,\n    uint256 amountOut,\n    address[] memory path\n  ) internal view returns (uint256[] memory amounts) {\n    require(path.length >= 2, \"JoeLibrary: INVALID_PATH\");\n    amounts = new uint256[](path.length);\n    amounts[amounts.length - 1] = amountOut;\n    for (uint256 i = path.length - 1; i > 0; i--) {\n      (uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i - 1], path[i]);\n      amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);\n    }\n  }\n}\n"
    },
    "contracts/interfaces/ICurveFiAvax.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0;\n\ninterface ICurveFi {\n  function add_liquidity(\n    uint256[3] calldata amounts,\n    uint256 min_amount,\n    bool use_underlying\n  ) external returns (uint256);\n\n  function remove_liquidity_one_coin(\n    uint256,\n    int128,\n    uint256,\n    bool\n  ) external returns (uint256);\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveUInt256.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurveUInt256 {\n  function get_dy(\n    uint256,\n    uint256,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange(\n    uint256,\n    uint256,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function coins(uint256) external view returns (address);\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveInt128Avax.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurveInt128 {\n  function get_dy(\n    int128,\n    int128,\n    uint256\n  ) external view returns (uint256);\n\n  function get_dy_underlying(\n    int128,\n    int128,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange(\n    int128,\n    int128,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function exchange(\n    int128,\n    int128,\n    uint256,\n    uint256,\n    address\n  ) external returns (uint256);\n\n  function exchange_underlying(\n    int128,\n    int128,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function coins(int128) external view returns (address);\n}\n"
    },
    "@traderjoe-xyz/core/contracts/traderjoe/interfaces/IJoeRouter02.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0\n\npragma solidity >=0.6.2;\n\nimport \"./IJoeRouter01.sol\";\n\ninterface IJoeRouter02 is IJoeRouter01 {\n    function removeLiquidityAVAXSupportingFeeOnTransferTokens(\n        address token,\n        uint256 liquidity,\n        uint256 amountTokenMin,\n        uint256 amountAVAXMin,\n        address to,\n        uint256 deadline\n    ) external returns (uint256 amountAVAX);\n\n    function removeLiquidityAVAXWithPermitSupportingFeeOnTransferTokens(\n        address token,\n        uint256 liquidity,\n        uint256 amountTokenMin,\n        uint256 amountAVAXMin,\n        address to,\n        uint256 deadline,\n        bool approveMax,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external returns (uint256 amountAVAX);\n\n    function swapExactTokensForTokensSupportingFeeOnTransferTokens(\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external;\n\n    function swapExactAVAXForTokensSupportingFeeOnTransferTokens(\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external payable;\n\n    function swapExactTokensForAVAXSupportingFeeOnTransferTokens(\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external;\n}\n"
    },
    "@traderjoe-xyz/core/contracts/traderjoe/interfaces/IJoePair.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0\n\npragma solidity >=0.5.0;\n\ninterface IJoePair {\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    function name() external pure returns (string memory);\n\n    function symbol() external pure returns (string memory);\n\n    function decimals() external pure returns (uint8);\n\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address owner) external view returns (uint256);\n\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    function approve(address spender, uint256 value) external returns (bool);\n\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function transferFrom(\n        address from,\n        address to,\n        uint256 value\n    ) external returns (bool);\n\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n\n    function PERMIT_TYPEHASH() external pure returns (bytes32);\n\n    function nonces(address owner) external view returns (uint256);\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    event Mint(address indexed sender, uint256 amount0, uint256 amount1);\n    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);\n    event Swap(\n        address indexed sender,\n        uint256 amount0In,\n        uint256 amount1In,\n        uint256 amount0Out,\n        uint256 amount1Out,\n        address indexed to\n    );\n    event Sync(uint112 reserve0, uint112 reserve1);\n\n    function MINIMUM_LIQUIDITY() external pure returns (uint256);\n\n    function factory() external view returns (address);\n\n    function token0() external view returns (address);\n\n    function token1() external view returns (address);\n\n    function getReserves()\n        external\n        view\n        returns (\n            uint112 reserve0,\n            uint112 reserve1,\n            uint32 blockTimestampLast\n        );\n\n    function price0CumulativeLast() external view returns (uint256);\n\n    function price1CumulativeLast() external view returns (uint256);\n\n    function kLast() external view returns (uint256);\n\n    function mint(address to) external returns (uint256 liquidity);\n\n    function burn(address to) external returns (uint256 amount0, uint256 amount1);\n\n    function swap(\n        uint256 amount0Out,\n        uint256 amount1Out,\n        address to,\n        bytes calldata data\n    ) external;\n\n    function skim(address to) external;\n\n    function sync() external;\n\n    function initialize(address, address) external;\n}\n"
    },
    "@traderjoe-xyz/core/contracts/traderjoe/interfaces/IJoeRouter01.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0\n\npragma solidity >=0.6.2;\n\ninterface IJoeRouter01 {\n    function factory() external pure returns (address);\n\n    function WAVAX() external pure returns (address);\n\n    function addLiquidity(\n        address tokenA,\n        address tokenB,\n        uint256 amountADesired,\n        uint256 amountBDesired,\n        uint256 amountAMin,\n        uint256 amountBMin,\n        address to,\n        uint256 deadline\n    )\n        external\n        returns (\n            uint256 amountA,\n            uint256 amountB,\n            uint256 liquidity\n        );\n\n    function addLiquidityAVAX(\n        address token,\n        uint256 amountTokenDesired,\n        uint256 amountTokenMin,\n        uint256 amountAVAXMin,\n        address to,\n        uint256 deadline\n    )\n        external\n        payable\n        returns (\n            uint256 amountToken,\n            uint256 amountAVAX,\n            uint256 liquidity\n        );\n\n    function removeLiquidity(\n        address tokenA,\n        address tokenB,\n        uint256 liquidity,\n        uint256 amountAMin,\n        uint256 amountBMin,\n        address to,\n        uint256 deadline\n    ) external returns (uint256 amountA, uint256 amountB);\n\n    function removeLiquidityAVAX(\n        address token,\n        uint256 liquidity,\n        uint256 amountTokenMin,\n        uint256 amountAVAXMin,\n        address to,\n        uint256 deadline\n    ) external returns (uint256 amountToken, uint256 amountAVAX);\n\n    function removeLiquidityWithPermit(\n        address tokenA,\n        address tokenB,\n        uint256 liquidity,\n        uint256 amountAMin,\n        uint256 amountBMin,\n        address to,\n        uint256 deadline,\n        bool approveMax,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external returns (uint256 amountA, uint256 amountB);\n\n    function removeLiquidityAVAXWithPermit(\n        address token,\n        uint256 liquidity,\n        uint256 amountTokenMin,\n        uint256 amountAVAXMin,\n        address to,\n        uint256 deadline,\n        bool approveMax,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external returns (uint256 amountToken, uint256 amountAVAX);\n\n    function swapExactTokensForTokens(\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external returns (uint256[] memory amounts);\n\n    function swapTokensForExactTokens(\n        uint256 amountOut,\n        uint256 amountInMax,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external returns (uint256[] memory amounts);\n\n    function swapExactAVAXForTokens(\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external payable returns (uint256[] memory amounts);\n\n    function swapTokensForExactAVAX(\n        uint256 amountOut,\n        uint256 amountInMax,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external returns (uint256[] memory amounts);\n\n    function swapExactTokensForAVAX(\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external returns (uint256[] memory amounts);\n\n    function swapAVAXForExactTokens(\n        uint256 amountOut,\n        address[] calldata path,\n        address to,\n        uint256 deadline\n    ) external payable returns (uint256[] memory amounts);\n\n    function quote(\n        uint256 amountA,\n        uint256 reserveA,\n        uint256 reserveB\n    ) external pure returns (uint256 amountB);\n\n    function getAmountOut(\n        uint256 amountIn,\n        uint256 reserveIn,\n        uint256 reserveOut\n    ) external pure returns (uint256 amountOut);\n\n    function getAmountIn(\n        uint256 amountOut,\n        uint256 reserveIn,\n        uint256 reserveOut\n    ) external pure returns (uint256 amountIn);\n\n    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);\n\n    function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);\n}\n"
    },
    "contracts/controllers/BadgerBridgeZeroControllerOptimism.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0;\npragma abicoder v2;\n\nimport { ISwapRouter } from \"@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol\";\nimport { UniswapV2Library } from \"../libraries/UniswapV2Library.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\nimport { IERC2612Permit } from \"../interfaces/IERC2612Permit.sol\";\nimport { ICurveInt128 } from \"../interfaces/CurvePools/ICurveInt128.sol\";\nimport { SplitSignatureLib } from \"../libraries/SplitSignatureLib.sol\";\nimport { IBadgerSettPeak } from \"../interfaces/IBadgerSettPeak.sol\";\nimport { ICurveFi } from \"../interfaces/ICurveFi.sol\";\nimport { IGateway } from \"../interfaces/IGateway.sol\";\nimport { IWETH9 } from \"@uniswap/v3-periphery/contracts/interfaces/external/IWETH9.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { IyVault } from \"../interfaces/IyVault.sol\";\nimport { ISett } from \"../interfaces/ISett.sol\";\nimport { Math } from \"@openzeppelin/contracts/math/Math.sol\";\nimport { SafeMath } from \"@openzeppelin/contracts/math/SafeMath.sol\";\nimport { IQuoter } from \"@uniswap/v3-periphery/contracts/interfaces/IQuoter.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts/token/ERC20/SafeERC20.sol\";\nimport { ECDSA } from \"@openzeppelin/contracts/cryptography/ECDSA.sol\";\nimport { EIP712Upgradeable } from \"@openzeppelin/contracts-upgradeable/drafts/EIP712Upgradeable.sol\";\n\ncontract BadgerBridgeZeroControllerOptimism is EIP712Upgradeable {\n  using SafeERC20 for IERC20;\n  using SafeMath for *;\n  uint256 public fee;\n  address public governance;\n  address public strategist;\n\n  address constant btcGateway = 0xB538901719936e628A9b9AF64A5a4Dbc273305cd;\n  address constant renbtc = 0x85f6583762Bc76d775eAB9A7456db344f12409F7;\n  uint256 public governanceFee;\n  bytes32 constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;\n  bytes32 constant LOCK_SLOT = keccak256(\"upgrade-lock-v2\");\n  uint256 constant GAS_COST = uint256(642e3);\n  uint256 constant ETH_RESERVE = uint256(5 ether);\n  uint256 internal renbtcForOneETHPrice;\n  uint256 internal burnFee;\n  uint256 public keeperReward;\n  uint256 public constant REPAY_GAS_DIFF = 41510;\n  uint256 public constant BURN_GAS_DIFF = 41118;\n\n  function setStrategist(address _strategist) public {\n    require(msg.sender == governance, \"!governance\");\n    strategist = _strategist;\n  }\n\n  function setGovernance(address _governance) public {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function computeCalldataGasDiff() internal pure returns (uint256 diff) {\n    if (true) return 0; // TODO: implement exact gas metering\n    // EVM charges less for zero bytes, we must compute the offset for refund\n    // TODO make this efficient\n    uint256 sz;\n    assembly {\n      sz := calldatasize()\n    }\n    diff = sz.mul(uint256(68));\n    bytes memory slice;\n    for (uint256 i = 0; i < sz; i += 0x20) {\n      uint256 word;\n      assembly {\n        word := calldataload(i)\n      }\n      for (uint256 i = 0; i < 256 && ((uint256(~0) << i) & word) != 0; i += 8) {\n        if ((word >> i) & 0xff != 0) diff -= 64;\n      }\n    }\n  }\n\n  function getChainId() internal pure returns (uint256 result) {\n    assembly {\n      result := chainid()\n    }\n  }\n\n  function setParameters(\n    uint256 _governanceFee,\n    uint256 _fee,\n    uint256 _burnFee,\n    uint256 _keeperReward\n  ) public {\n    require(governance == msg.sender, \"!governance\");\n    governanceFee = _governanceFee;\n    fee = _fee;\n    burnFee = _burnFee;\n    keeperReward = _keeperReward;\n  }\n\n  function initialize(address _governance, address _strategist) public initializer {\n    fee = uint256(25e14);\n    burnFee = uint256(4e15);\n    governanceFee = uint256(5e17);\n    governance = _governance;\n    strategist = _strategist;\n    keeperReward = uint256(1 ether).div(1000);\n  }\n\n  function applyRatio(uint256 v, uint256 n) internal pure returns (uint256 result) {\n    result = v.mul(n).div(uint256(1 ether));\n  }\n\n  function quote() internal {}\n\n  receive() external payable {\n    // no-op\n  }\n\n  function earn() public {\n    quote();\n    uint256 balance = address(this).balance;\n    if (balance > ETH_RESERVE) {\n      uint256 output = balance - ETH_RESERVE;\n      uint256 toGovernance = applyRatio(output, governanceFee);\n      address payable governancePayable = address(uint160(governance));\n      require(governancePayable.send(toGovernance), \"error on send\");\n      address payable strategistPayable = address(uint160(strategist));\n      require(strategistPayable.send(output.sub(toGovernance)), \"error on send\");\n    }\n  }\n\n  function computeRenBTCGasFee(uint256 gasCost, uint256 gasPrice) internal view returns (uint256 result) {\n    result = gasCost.mul(tx.gasprice).mul(renbtcForOneETHPrice).div(uint256(1 ether));\n  }\n\n  function deductMintFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, fee, multiplier));\n  }\n\n  function deductBurnFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, burnFee, multiplier));\n  }\n\n  function applyFee(\n    uint256 amountIn,\n    uint256 _fee,\n    uint256 multiplier\n  ) internal view returns (uint256 amount) {\n    amount = computeRenBTCGasFee(GAS_COST.add(keeperReward.div(tx.gasprice)), tx.gasprice).add(\n      applyRatio(amountIn, _fee)\n    );\n  }\n\n  struct LoanParams {\n    address to;\n    address asset;\n    uint256 nonce;\n    uint256 amount;\n    address module;\n    address underwriter;\n    bytes data;\n    uint256 minOut;\n    uint256 _mintAmount;\n    uint256 gasDiff;\n  }\n\n  function toTypedDataHash(LoanParams memory params) internal view returns (bytes32 result) {\n    bytes32 digest = _hashTypedDataV4(\n      keccak256(\n        abi.encode(\n          keccak256(\n            \"TransferRequest(address asset,uint256 amount,address underwriter,address module,uint256 nonce,bytes data)\"\n          ),\n          params.asset,\n          params.amount,\n          params.underwriter,\n          params.module,\n          params.nonce,\n          keccak256(params.data)\n        )\n      )\n    );\n    return digest;\n  }\n\n  function repay(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public returns (uint256 amountOut) {\n    require(msg.data.length <= 516, \"too much calldata\");\n    uint256 _gasBefore = gasleft();\n    LoanParams memory params;\n    {\n      require(module == renbtc, \"!approved-module\");\n      params = LoanParams({\n        to: to,\n        asset: asset,\n        amount: amount,\n        nonce: nonce,\n        module: module,\n        underwriter: underwriter,\n        data: data,\n        minOut: 1,\n        _mintAmount: 0,\n        gasDiff: computeCalldataGasDiff()\n      });\n      if (data.length > 0) (params.minOut) = abi.decode(data, (uint256));\n    }\n    bytes32 digest = toTypedDataHash(params);\n\n    params._mintAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    {\n      amountOut = deductMintFee(params._mintAmount, 1);\n    }\n    {\n      IERC20(module).safeTransfer(to, amountOut);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          _gasBefore.sub(gasleft()).add(REPAY_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function computeBurnNonce(BurnLocals memory params) internal view returns (uint256 result) {\n    result = uint256(\n      keccak256(\n        abi.encodePacked(params.asset, params.amount, params.deadline, params.nonce, params.data, params.destination)\n      )\n    );\n    while (result < block.timestamp) {\n      // negligible probability of this\n      result = uint256(keccak256(abi.encodePacked(result)));\n    }\n  }\n\n  function computeERC20PermitDigest(bytes32 domainSeparator, BurnLocals memory params)\n    internal\n    view\n    returns (bytes32 result)\n  {\n    result = keccak256(\n      abi.encodePacked(\n        \"\\x19\\x01\",\n        domainSeparator,\n        keccak256(abi.encode(PERMIT_TYPEHASH, params.to, address(this), params.nonce, computeBurnNonce(params), true))\n      )\n    );\n  }\n\n  struct BurnLocals {\n    address to;\n    address asset;\n    uint256 amount;\n    uint256 deadline;\n    uint256 nonce;\n    bytes data;\n    uint256 minOut;\n    uint256 burnNonce;\n    uint256 gasBefore;\n    uint256 gasDiff;\n    uint8 v;\n    bytes32 r;\n    bytes32 s;\n    bytes destination;\n    bytes signature;\n  }\n\n  function burn(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    bytes memory data,\n    bytes memory destination,\n    bytes memory signature\n  ) public returns (uint256 amountToBurn) {\n    require(msg.data.length <= 580, \"too much calldata\");\n    BurnLocals memory params = BurnLocals({\n      to: to,\n      asset: asset,\n      amount: amount,\n      deadline: deadline,\n      data: data,\n      nonce: 0,\n      burnNonce: 0,\n      v: uint8(0),\n      r: bytes32(0),\n      s: bytes32(0),\n      destination: destination,\n      signature: signature,\n      gasBefore: gasleft(),\n      minOut: 1,\n      gasDiff: 0\n    });\n    {\n      params.gasDiff = computeCalldataGasDiff();\n      if (params.data.length > 0) (params.minOut) = abi.decode(params.data, (uint256));\n    }\n    require(block.timestamp < params.deadline, \"!deadline\");\n\n    if (params.asset == renbtc) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.nonce,\n          params.burnNonce,\n          true,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(params.amount, 1);\n    } else revert(\"!supported-asset\");\n    {\n      IGateway(btcGateway).burn(params.destination, amountToBurn);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          params.gasBefore.sub(gasleft()).add(BURN_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function fallbackMint(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public {\n    LoanParams memory params = LoanParams({\n      to: to,\n      asset: asset,\n      amount: amount,\n      nonce: nonce,\n      module: module,\n      underwriter: underwriter,\n      data: data,\n      minOut: 1,\n      _mintAmount: 0,\n      gasDiff: 0\n    });\n    bytes32 digest = toTypedDataHash(params);\n    uint256 _actualAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    IERC20(asset).safeTransfer(to, _actualAmount);\n  }\n}\n"
    },
    "contracts/controllers/RenZECController.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0;\npragma abicoder v2;\n\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { ISwapRouter } from \"@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol\";\nimport { UniswapV2Library } from \"../libraries/UniswapV2Library.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\nimport { IERC2612Permit } from \"../interfaces/IERC2612Permit.sol\";\nimport { SplitSignatureLib } from \"../libraries/SplitSignatureLib.sol\";\nimport { IWETH } from \"../interfaces/IWETH.sol\";\nimport { IGateway } from \"../interfaces/IGateway.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { Math } from \"@openzeppelin/contracts/math/Math.sol\";\nimport { SafeMath } from \"@openzeppelin/contracts/math/SafeMath.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts/token/ERC20/SafeERC20.sol\";\nimport { ECDSA } from \"@openzeppelin/contracts/cryptography/ECDSA.sol\";\nimport { EIP712Upgradeable } from \"@openzeppelin/contracts-upgradeable/drafts/EIP712Upgradeable.sol\";\n\ncontract RenZECController is EIP712Upgradeable {\n  using SafeERC20 for IERC20;\n  using SafeMath for *;\n  uint256 public fee;\n  address public governance;\n  address public strategist;\n\n  address constant router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;\n  address constant renzec = 0x1C5db575E2Ff833E46a2E9864C22F4B22E0B37C2;\n  address constant zecGateway = 0xc3BbD5aDb611dd74eCa6123F05B18acc886e122D;\n  address constant routerv3 = 0xE592427A0AEce92De3Edee1F18E0157C05861564;\n  address constant factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;\n  address constant weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n  address constant usdt = 0xdAC17F958D2ee523a2206206994597C13D831ec7;\n  address constant usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\n  address constant quoter = 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6;\n  uint24 constant uniswapv3Fee = 500;\n  uint256 public governanceFee;\n  bytes32 constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;\n  uint256 constant GAS_COST = uint256(23e4);\n  bytes32 constant LOCK_SLOT = keccak256(\"upgrade-v1\");\n  uint256 constant ETH_RESERVE = uint256(5 ether);\n  uint256 internal renzecForOneETHPrice;\n  uint256 internal burnFee;\n  uint256 public keeperReward;\n  uint256 public constant REPAY_GAS_DIFF = 41510;\n  uint256 public constant BURN_GAS_DIFF = 41118;\n  bytes32 internal PERMIT_DOMAIN_SEPARATOR_USDT;\n  mapping(address => uint256) public noncesUsdt;\n\n  function setStrategist(address _strategist) public {\n    require(msg.sender == governance, \"!governance\");\n    strategist = _strategist;\n  }\n\n  function setGovernance(address _governance) public {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function computeCalldataGasDiff() internal pure returns (uint256 diff) {\n    if (true) return 0; // TODO: implement exact gas metering\n    // EVM charges less for zero bytes, we must compute the offset for refund\n    // TODO make this efficient\n    uint256 sz;\n    assembly {\n      sz := calldatasize()\n    }\n    diff = sz.mul(uint256(68));\n    bytes memory slice;\n    for (uint256 i = 0; i < sz; i += 0x20) {\n      uint256 word;\n      assembly {\n        word := calldataload(i)\n      }\n      for (uint256 i = 0; i < 256 && ((uint256(~0) << i) & word) != 0; i += 8) {\n        if ((word >> i) & 0xff != 0) diff -= 64;\n      }\n    }\n  }\n\n  function getChainId() internal pure returns (uint256 result) {\n    assembly {\n      result := chainid()\n    }\n  }\n\n  function setParameters(\n    uint256 _governanceFee,\n    uint256 _fee,\n    uint256 _burnFee,\n    uint256 _keeperReward\n  ) public {\n    require(governance == msg.sender, \"!governance\");\n    governanceFee = _governanceFee;\n    fee = _fee;\n    burnFee = _burnFee;\n    keeperReward = _keeperReward;\n  }\n\n  function initialize(address _governance, address _strategist) public initializer {\n    fee = uint256(25e14);\n    burnFee = uint256(4e15);\n    governanceFee = uint256(5e17);\n    governance = _governance;\n    strategist = _strategist;\n    keeperReward = uint256(1 ether).div(1000);\n    IERC20(weth).safeApprove(routerv3, ~uint256(0) >> 2);\n    IERC20(usdc).safeApprove(routerv3, ~uint256(0) >> 2);\n    IERC20(usdt).safeApprove(routerv3, ~uint256(0) >> 2);\n    IERC20(weth).safeApprove(router, ~uint256(0) >> 2);\n    IERC20(renzec).safeApprove(router, ~uint256(0) >> 2);\n    PERMIT_DOMAIN_SEPARATOR_USDT = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"USDT\"),\n        keccak256(\"1\"),\n        getChainId(),\n        usdt\n      )\n    );\n  }\n\n  function postUpgrade() public {\n    bool isLocked;\n    bytes32 upgradeSlot = LOCK_SLOT;\n\n    assembly {\n      isLocked := sload(upgradeSlot)\n    }\n\n    require(!isLocked, \"already upgraded\");\n    PERMIT_DOMAIN_SEPARATOR_USDT = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"USDT\"),\n        keccak256(\"1\"),\n        getChainId(),\n        usdt\n      )\n    );\n    IERC20(usdc).safeApprove(routerv3, ~uint256(0) >> 2);\n    IERC20(usdt).safeApprove(routerv3, ~uint256(0) >> 2);\n\n    isLocked = true;\n    assembly {\n      sstore(upgradeSlot, isLocked)\n    }\n  }\n\n  function applyRatio(uint256 v, uint256 n) internal pure returns (uint256 result) {\n    result = v.mul(n).div(uint256(1 ether));\n  }\n\n  function quote() internal {\n    (uint256 amountWeth, uint256 amountRenZEC) = UniswapV2Library.getReserves(factory, weth, renzec);\n    renzecForOneETHPrice = UniswapV2Library.quote(uint256(1 ether), amountWeth, amountRenZEC);\n  }\n\n  function renZECtoETH(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    address[] memory path = new address[](2);\n    path[0] = renzec;\n    path[1] = weth;\n    uint256[] memory amounts = new uint256[](2);\n    amounts = IUniswapV2Router02(router).swapExactTokensForETH(amountIn, minOut, path, out, block.timestamp + 1);\n    return amounts[1];\n  }\n\n  function fromETHToRenZEC(uint256 minOut, uint256 amountIn) internal returns (uint256) {\n    address[] memory path = new address[](2);\n    path[0] = weth;\n    path[1] = renzec;\n    uint256[] memory amounts = new uint256[](2);\n    amounts = IUniswapV2Router02(router).swapExactETHForTokens{ value: amountIn }(\n      minOut,\n      path,\n      address(this),\n      block.timestamp + 1\n    );\n    return amounts[1];\n  }\n\n  function fromUSDC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    bytes memory path = abi.encodePacked(usdc, uniswapv3Fee, weth);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: amountIn,\n      amountOutMinimum: 1,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput(params);\n    IWETH(weth).withdraw(amountOut);\n    amountOut = fromETHToRenZEC(minOut, amountOut);\n  }\n\n  function fromUSDT(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    bytes memory path = abi.encodePacked(usdt, uniswapv3Fee, weth);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: amountIn,\n      amountOutMinimum: 1,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput(params);\n    IWETH(weth).withdraw(amountOut);\n    amountOut = fromETHToRenZEC(minOut, amountOut);\n  }\n\n  function toUSDC(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    bytes memory path = abi.encodePacked(weth, uniswapv3Fee, usdc);\n    amountOut = renZECtoETH(1, amountIn, address(this));\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: out,\n      deadline: block.timestamp + 1,\n      amountIn: amountOut,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput{ value: amountOut }(params);\n  }\n\n  function toUSDT(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    bytes memory path = abi.encodePacked(weth, uniswapv3Fee, usdt);\n    amountOut = renZECtoETH(1, amountIn, address(this));\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: out,\n      deadline: block.timestamp + 1,\n      amountIn: amountOut,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput{ value: amountOut }(params);\n  }\n\n  function toETH() internal returns (uint256 amountOut) {\n    address[] memory path = new address[](2);\n    path[0] = renzec;\n    path[1] = weth;\n    uint256[] memory amounts = new uint256[](2);\n    IUniswapV2Router02(router).swapExactTokensForETH(\n      IERC20(renzec).balanceOf(address(this)),\n      1,\n      path,\n      address(this),\n      block.timestamp + 1\n    );\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function earn() public {\n    quote();\n    toETH();\n    uint256 balance = address(this).balance;\n    if (balance > ETH_RESERVE) {\n      uint256 output = balance - ETH_RESERVE;\n      uint256 toGovernance = applyRatio(output, governanceFee);\n      address payable governancePayable = address(uint160(governance));\n      require(governancePayable.send(toGovernance), \"error on send\");\n      address payable strategistPayable = address(uint160(strategist));\n      require(strategistPayable.send(output.sub(toGovernance)), \"error on send\");\n    }\n  }\n\n  function computeRenZECGasFee(uint256 gasCost, uint256 gasPrice) internal view returns (uint256 result) {\n    result = gasCost.mul(tx.gasprice).mul(renzecForOneETHPrice).div(uint256(1 ether));\n  }\n\n  function deductMintFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, fee, multiplier));\n  }\n\n  function deductBurnFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, burnFee, multiplier));\n  }\n\n  function applyFee(\n    uint256 amountIn,\n    uint256 _fee,\n    uint256 multiplier\n  ) internal view returns (uint256 amount) {\n    amount = computeRenZECGasFee(GAS_COST.add(keeperReward.div(tx.gasprice)), tx.gasprice).add(\n      applyRatio(amountIn, _fee)\n    );\n  }\n\n  struct LoanParams {\n    address to;\n    address asset;\n    uint256 nonce;\n    uint256 amount;\n    address module;\n    address underwriter;\n    bytes data;\n    uint256 minOut;\n    uint256 _mintAmount;\n    uint256 gasDiff;\n  }\n\n  function toTypedDataHash(LoanParams memory params) internal view returns (bytes32 result) {\n    bytes32 digest = _hashTypedDataV4(\n      keccak256(\n        abi.encode(\n          keccak256(\n            \"TransferRequest(address asset,uint256 amount,address underwriter,address module,uint256 nonce,bytes data)\"\n          ),\n          params.asset,\n          params.amount,\n          params.underwriter,\n          params.module,\n          params.nonce,\n          keccak256(params.data)\n        )\n      )\n    );\n    return digest;\n  }\n\n  function repay(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public returns (uint256 amountOut) {\n    require(msg.data.length <= 516, \"too much calldata\");\n    uint256 _gasBefore = gasleft();\n    LoanParams memory params;\n    {\n      require(module == usdc || module == usdt || module == address(0x0) || module == renzec, \"!approved-module\");\n      params = LoanParams({\n        to: to,\n        asset: asset,\n        amount: amount,\n        nonce: nonce,\n        module: module,\n        underwriter: underwriter,\n        data: data,\n        minOut: 1,\n        _mintAmount: 0,\n        gasDiff: computeCalldataGasDiff()\n      });\n      if (data.length > 0) (params.minOut) = abi.decode(data, (uint256));\n    }\n    bytes32 digest = toTypedDataHash(params);\n\n    params._mintAmount = IGateway(zecGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n\n    {\n      amountOut = module == address(0x0)\n        ? renZECtoETH(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : module == usdc\n        ? toUSDC(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : module == usdt\n        ? toUSDT(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : deductMintFee(params._mintAmount, 1);\n    }\n    {\n      if (module == renzec) IERC20(module).safeTransfer(to, amountOut);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          _gasBefore.sub(gasleft()).add(REPAY_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function burnETH(uint256 minOut, bytes memory destination) public payable returns (uint256 amountToBurn) {\n    amountToBurn = fromETHToRenZEC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(zecGateway).burn(destination, amountToBurn);\n  }\n\n  function computeBurnNonce(BurnLocals memory params) internal view returns (uint256 result) {\n    result = uint256(\n      keccak256(\n        abi.encodePacked(params.asset, params.amount, params.deadline, params.nonce, params.data, params.destination)\n      )\n    );\n    while (result < block.timestamp) {\n      // negligible probability of this\n      result = uint256(keccak256(abi.encodePacked(result)));\n    }\n  }\n\n  function computeERC20PermitDigest(bytes32 domainSeparator, BurnLocals memory params)\n    internal\n    view\n    returns (bytes32 result)\n  {\n    result = keccak256(\n      abi.encodePacked(\n        \"\\x19\\x01\",\n        domainSeparator,\n        keccak256(abi.encode(PERMIT_TYPEHASH, params.to, address(this), params.nonce, computeBurnNonce(params), true))\n      )\n    );\n  }\n\n  struct BurnLocals {\n    address to;\n    address asset;\n    uint256 amount;\n    uint256 deadline;\n    uint256 nonce;\n    bytes data;\n    uint256 minOut;\n    uint256 burnNonce;\n    uint256 gasBefore;\n    uint256 gasDiff;\n    uint8 v;\n    bytes32 r;\n    bytes32 s;\n    bytes destination;\n    bytes signature;\n  }\n\n  function burn(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    bytes memory data,\n    bytes memory destination,\n    bytes memory signature\n  ) public returns (uint256 amountToBurn) {\n    require(msg.data.length <= 580, \"too much calldata\");\n    BurnLocals memory params = BurnLocals({\n      to: to,\n      asset: asset,\n      amount: amount,\n      deadline: deadline,\n      data: data,\n      nonce: 0,\n      burnNonce: 0,\n      v: uint8(0),\n      r: bytes32(0),\n      s: bytes32(0),\n      destination: destination,\n      signature: signature,\n      gasBefore: gasleft(),\n      minOut: 1,\n      gasDiff: 0\n    });\n    {\n      params.gasDiff = computeCalldataGasDiff();\n      if (params.data.length > 0) (params.minOut) = abi.decode(params.data, (uint256));\n    }\n    require(block.timestamp < params.deadline, \"!deadline\");\n    if (params.asset == renzec) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.nonce,\n          params.burnNonce,\n          true,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(params.amount, 1);\n    } else if (params.asset == usdc) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.amount,\n          params.burnNonce,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).safeTransferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(fromUSDC(params.minOut, params.amount), 1);\n    } else if (params.asset == usdt) {\n      params.nonce = noncesUsdt[to];\n      noncesUsdt[params.to]++;\n      require(\n        params.to == ECDSA.recover(computeERC20PermitDigest(PERMIT_DOMAIN_SEPARATOR_USDT, params), params.signature),\n        \"!signature\"\n      ); //  usdt does not implement ERC20Permit\n      {\n        (bool success, ) = params.asset.call(\n          abi.encodeWithSelector(IERC20.transferFrom.selector, params.to, address(this), params.amount)\n        );\n        require(success, \"!usdt\");\n      }\n      amountToBurn = deductBurnFee(fromUSDT(params.minOut, params.amount), 1);\n    } else revert(\"!supported-asset\");\n    {\n      IGateway(zecGateway).burn(params.destination, amountToBurn);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          params.gasBefore.sub(gasleft()).add(BURN_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function burnApproved(\n    address from,\n    address asset,\n    uint256 amount,\n    uint256 minOut,\n    bytes memory destination\n  ) public payable returns (uint256 amountToBurn) {\n    require(asset == renzec || asset == address(0x0), \"!approved-module\");\n    if (asset != address(0x0)) IERC20(asset).transferFrom(msg.sender, address(this), amount);\n    amountToBurn = asset == renzec ? amount : fromETHToRenZEC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(zecGateway).burn(destination, amountToBurn);\n  }\n\n  function fallbackMint(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public {\n    LoanParams memory params = LoanParams({\n      to: to,\n      asset: asset,\n      amount: amount,\n      nonce: nonce,\n      module: module,\n      underwriter: underwriter,\n      data: data,\n      minOut: 1,\n      _mintAmount: 0,\n      gasDiff: 0\n    });\n    bytes32 digest = toTypedDataHash(params);\n    uint256 _actualAmount = IGateway(zecGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    IERC20(asset).safeTransfer(to, _actualAmount);\n  }\n}\n"
    },
    "contracts/controllers/RenZECControllerDeployer.sol": {
      "content": "pragma solidity >=0.6.0;\n\nimport { TransparentUpgradeableProxy } from \"@openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol\";\nimport { RenZECController } from \"./RenZECController.sol\";\n\ncontract RenZECControllerDeployer {\n  event Deployed(address indexed controller);\n\n  constructor() {\n    emit Deployed(\n      address(\n        new TransparentUpgradeableProxy(\n          address(new RenZECController()),\n          address(0xFF727BDFa7608d7Fd12Cd2cDA1e7736ACbfCdB7B),\n          abi.encodeWithSelector(\n            RenZECController.initialize.selector,\n            address(0x5E9B37149b7d7611bD0Eb070194dDA78EB11EfdC),\n            address(0x5E9B37149b7d7611bD0Eb070194dDA78EB11EfdC)\n          )\n        )\n      )\n    );\n    selfdestruct(msg.sender);\n  }\n}\n"
    },
    "contracts/controllers/BadgerBridgeZeroControllerArb.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0;\npragma abicoder v2;\n\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { ISwapRouter } from \"@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol\";\nimport { IQuoter } from \"@uniswap/v3-periphery/contracts/interfaces/IQuoter.sol\";\nimport { UniswapV2Library } from \"../libraries/UniswapV2Library.sol\";\nimport { ZeroLib } from \"../libraries/ZeroLib.sol\";\nimport { IERC2612Permit } from \"../interfaces/IERC2612Permit.sol\";\nimport { IRenCrvArbitrum } from \"../interfaces/CurvePools/IRenCrvArbitrum.sol\";\nimport { SplitSignatureLib } from \"../libraries/SplitSignatureLib.sol\";\nimport { IBadgerSettPeak } from \"../interfaces/IBadgerSettPeak.sol\";\nimport { ICurveFi } from \"../interfaces/ICurveFi.sol\";\nimport { IGateway } from \"../interfaces/IGateway.sol\";\nimport { IWETH9 } from \"@uniswap/v3-periphery/contracts/interfaces/external/IWETH9.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { ICurveInt128 } from \"../interfaces/CurvePools/ICurveInt128.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport { IyVault } from \"../interfaces/IyVault.sol\";\nimport { ISett } from \"../interfaces/ISett.sol\";\nimport { Math } from \"@openzeppelin/contracts/math/Math.sol\";\nimport { SafeMath } from \"@openzeppelin/contracts/math/SafeMath.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts/token/ERC20/SafeERC20.sol\";\nimport { ECDSA } from \"@openzeppelin/contracts/cryptography/ECDSA.sol\";\nimport { EIP712Upgradeable } from \"@openzeppelin/contracts-upgradeable/drafts/EIP712Upgradeable.sol\";\n\ncontract BadgerBridgeZeroControllerArb is EIP712Upgradeable {\n  using SafeERC20 for IERC20;\n  using SafeMath for *;\n  uint256 public fee;\n  address public governance;\n  address public strategist;\n\n  address constant btcGateway = 0x05Cadbf3128BcB7f2b89F3dD55E5B0a036a49e20;\n  address constant routerv3 = 0xE592427A0AEce92De3Edee1F18E0157C05861564;\n  address constant factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;\n  address constant usdc = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8;\n  address constant weth = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;\n  address constant wbtc = 0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f;\n  address constant renbtc = 0xDBf31dF14B66535aF65AaC99C32e9eA844e14501;\n  address constant renCrv = 0x3E01dD8a5E1fb3481F0F589056b428Fc308AF0Fb;\n  address constant threepool = 0x7f90122BF0700F9E7e1F688fe926940E8839F353;\n  address constant tricrypto = 0x960ea3e3C7FB317332d990873d354E18d7645590;\n  address constant renCrvLp = 0x3E01dD8a5E1fb3481F0F589056b428Fc308AF0Fb;\n  address constant bCrvRen = 0x6dEf55d2e18486B9dDfaA075bc4e4EE0B28c1545;\n  address constant settPeak = 0x41671BA1abcbA387b9b2B752c205e22e916BE6e3;\n  address constant quoter = 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6;\n  address constant ibbtc = 0xc4E15973E6fF2A35cC804c2CF9D2a1b817a8b40F;\n  uint24 constant wethWbtcFee = 500;\n  uint24 constant usdcWethFee = 500;\n  uint256 public governanceFee;\n  bytes32 constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;\n  bytes32 constant LOCK_SLOT = keccak256(\"upgrade-lock-v2\");\n  uint256 constant GAS_COST = uint256(48e4);\n  uint256 constant IBBTC_GAS_COST = uint256(7e5);\n  uint256 constant ETH_RESERVE = uint256(5 ether);\n  uint256 internal renbtcForOneETHPrice;\n  uint256 internal burnFee;\n  uint256 public keeperReward;\n  uint256 public constant REPAY_GAS_DIFF = 41510;\n  uint256 public constant BURN_GAS_DIFF = 41118;\n  mapping(address => uint256) public nonces;\n  bytes32 internal PERMIT_DOMAIN_SEPARATOR_WBTC;\n  bytes32 internal PERMIT_DOMAIN_SEPARATOR_IBBTC;\n\n  function setStrategist(address _strategist) public {\n    require(msg.sender == governance, \"!governance\");\n    strategist = _strategist;\n  }\n\n  function setGovernance(address _governance) public {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function approveUpgrade(bool lock) public {\n    bool isLocked;\n    bytes32 lock_slot = LOCK_SLOT;\n\n    assembly {\n      isLocked := sload(lock_slot)\n    }\n    require(!isLocked, \"cannot run upgrade function\");\n    assembly {\n      sstore(lock_slot, lock)\n    }\n  }\n\n  function computeCalldataGasDiff() internal pure returns (uint256 diff) {\n    if (true) return 0; // TODO: implement exact gas metering\n    // EVM charges less for zero bytes, we must compute the offset for refund\n    // TODO make this efficient\n    uint256 sz;\n    assembly {\n      sz := calldatasize()\n    }\n    diff = sz.mul(uint256(68));\n    bytes memory slice;\n    for (uint256 i = 0; i < sz; i += 0x20) {\n      uint256 word;\n      assembly {\n        word := calldataload(i)\n      }\n      for (uint256 i = 0; i < 256 && ((uint256(~0) << i) & word) != 0; i += 8) {\n        if ((word >> i) & 0xff != 0) diff -= 64;\n      }\n    }\n  }\n\n  function getChainId() internal pure returns (uint256 result) {\n    assembly {\n      result := chainid()\n    }\n  }\n\n  function setParameters(\n    uint256 _governanceFee,\n    uint256 _fee,\n    uint256 _burnFee,\n    uint256 _keeperReward\n  ) public {\n    require(governance == msg.sender, \"!governance\");\n    governanceFee = _governanceFee;\n    fee = _fee;\n    burnFee = _burnFee;\n    keeperReward = _keeperReward;\n  }\n\n  function initialize(address _governance, address _strategist) public initializer {\n    fee = uint256(25e14);\n    burnFee = uint256(4e15);\n    governanceFee = uint256(5e17);\n    governance = _governance;\n    strategist = _strategist;\n    keeperReward = uint256(1 ether).div(1000);\n    //IERC20(renbtc).safeApprove(btcGateway, ~uint256(0) >> 2);\n    IERC20(renbtc).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(renCrv, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(tricrypto, ~uint256(0) >> 2);\n    IERC20(renCrvLp).safeApprove(bCrvRen, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(routerv3, ~uint256(0) >> 2);\n    IERC20(usdc).safeApprove(routerv3, ~uint256(0) >> 2);\n    //IERC20(bCrvRen).safeApprove(settPeak, ~uint256(0) >> 2);\n    PERMIT_DOMAIN_SEPARATOR_WBTC = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"WBTC\"),\n        keccak256(\"1\"),\n        getChainId(),\n        wbtc\n      )\n    );\n    PERMIT_DOMAIN_SEPARATOR_IBBTC = keccak256(\n      abi.encode(\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n        keccak256(\"ibBTC\"),\n        keccak256(\"1\"),\n        getChainId(),\n        ibbtc\n      )\n    );\n  }\n\n  function applyRatio(uint256 v, uint256 n) internal pure returns (uint256 result) {\n    result = v.mul(n).div(uint256(1 ether));\n  }\n\n  function toWBTC(uint256 amount) internal returns (uint256 amountOut) {\n    uint256 amountStart = IERC20(wbtc).balanceOf(address(this));\n    IRenCrvArbitrum(renCrv).exchange(1, 0, amount, 1, address(this));\n    amountOut = IERC20(wbtc).balanceOf(address(this)).sub(amountStart);\n  }\n\n  function toIBBTC(uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256[2] memory amounts;\n    amounts[0] = amountIn;\n    (bool success, ) = renCrv.call(abi.encodeWithSelector(ICurveFi.add_liquidity.selector, amounts, 0));\n    require(success, \"!curve\");\n    ISett(bCrvRen).deposit(IERC20(renCrvLp).balanceOf(address(this)));\n    amountOut = IBadgerSettPeak(settPeak).mint(0, IERC20(bCrvRen).balanceOf(address(this)), new bytes32[](0));\n  }\n\n  function toUSDC(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    uint256 wbtcAmountIn = toWBTC(amountIn);\n    bytes memory path = abi.encodePacked(wbtc, wethWbtcFee, weth, usdcWethFee, usdc);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: out,\n      deadline: block.timestamp + 1,\n      amountIn: wbtcAmountIn,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput(params);\n  }\n\n  function quote() internal {\n    bytes memory path = abi.encodePacked(wbtc, uint24(500), weth);\n    uint256 wbtcForEthPrice = IQuoter(quoter).quoteExactInput(path, 1 ether);\n    renbtcForOneETHPrice = ICurveInt128(renCrv).get_dy(1, 0, wbtcForEthPrice);\n  }\n\n  function renBTCtoETH(\n    uint256 minOut,\n    uint256 amountIn,\n    address out\n  ) internal returns (uint256 amountOut) {\n    uint256 wbtcAmountOut = toWBTC(amountIn);\n    ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({\n      tokenIn: wbtc,\n      tokenOut: weth,\n      fee: wethWbtcFee,\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: wbtcAmountOut,\n      amountOutMinimum: minOut,\n      sqrtPriceLimitX96: 0\n    });\n    amountOut = ISwapRouter(routerv3).exactInputSingle(params);\n    address payable to = address(uint160(out));\n    IWETH9(weth).withdraw(amountOut);\n    to.transfer(amountOut);\n  }\n\n  function fromIBBTC(uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 amountStart = IERC20(renbtc).balanceOf(address(this));\n    IBadgerSettPeak(settPeak).redeem(0, amountIn);\n    ISett(bCrvRen).withdraw(IERC20(bCrvRen).balanceOf(address(this)));\n    (bool success, ) = renCrv.call(\n      abi.encodeWithSelector(\n        ICurveFi.remove_liquidity_one_coin.selector,\n        IERC20(renCrvLp).balanceOf(address(this)),\n        0,\n        0\n      )\n    );\n    require(success, \"!curve\");\n    amountOut = IERC20(renbtc).balanceOf(address(this)).sub(amountStart);\n  }\n\n  function fromUSDC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    bytes memory path = abi.encodePacked(usdc, usdcWethFee, weth, wethWbtcFee, wbtc);\n    ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: amountIn,\n      amountOutMinimum: minOut,\n      path: path\n    });\n    amountOut = ISwapRouter(routerv3).exactInput(params);\n    amountOut = toRenBTC(amountOut);\n  }\n\n  function toRenBTC(uint256 amountIn) internal returns (uint256 amountOut) {\n    uint256 balanceStart = IERC20(renbtc).balanceOf(address(this));\n    IRenCrvArbitrum(renCrv).exchange(0, 1, amountIn, 1, address(this));\n    amountOut = IERC20(renbtc).balanceOf(address(this)).sub(balanceStart);\n  }\n\n  function fromETHToRenBTC(uint256 minOut, uint256 amountIn) internal returns (uint256 amountOut) {\n    ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({\n      tokenIn: weth,\n      tokenOut: wbtc,\n      fee: wethWbtcFee,\n      recipient: address(this),\n      deadline: block.timestamp + 1,\n      amountIn: amountIn,\n      amountOutMinimum: minOut,\n      sqrtPriceLimitX96: 0\n    });\n    amountOut = ISwapRouter(routerv3).exactInputSingle{ value: amountIn }(params);\n    return toRenBTC(amountOut);\n  }\n\n  function toETH() internal returns (uint256 amountOut) {\n    uint256 wbtcStart = IERC20(wbtc).balanceOf(address(this));\n\n    uint256 amountStart = address(this).balance;\n    (bool success, ) = tricrypto.call(\n      abi.encodeWithSelector(ICurveETHUInt256.exchange.selector, 1, 2, wbtcStart, 0, true)\n    );\n    amountOut = address(this).balance.sub(amountStart);\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function earn() public {\n    quote();\n    toWBTC(IERC20(renbtc).balanceOf(address(this)));\n    toETH();\n    uint256 balance = address(this).balance;\n    if (balance > ETH_RESERVE) {\n      uint256 output = balance - ETH_RESERVE;\n      uint256 toGovernance = applyRatio(output, governanceFee);\n      address payable governancePayable = address(uint160(governance));\n      require(governancePayable.send(toGovernance), \"error on send\");\n      address payable strategistPayable = address(uint160(strategist));\n      require(strategistPayable.send(output.sub(toGovernance)), \"error on send\");\n    }\n  }\n\n  function computeRenBTCGasFee(uint256 gasCost, uint256 gasPrice) internal view returns (uint256 result) {\n    result = gasCost.mul(tx.gasprice).mul(renbtcForOneETHPrice).div(uint256(1 ether));\n  }\n\n  function deductMintFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, fee, multiplier));\n  }\n\n  function deductIBBTCMintFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyIBBTCFee(amountIn, fee, multiplier));\n  }\n\n  function deductBurnFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyFee(amountIn, burnFee, multiplier));\n  }\n\n  function deductIBBTCBurnFee(uint256 amountIn, uint256 multiplier) internal view returns (uint256 amount) {\n    amount = amountIn.sub(applyIBBTCFee(amountIn, burnFee, multiplier));\n  }\n\n  function applyFee(\n    uint256 amountIn,\n    uint256 _fee,\n    uint256 multiplier\n  ) internal view returns (uint256 amount) {\n    amount = computeRenBTCGasFee(GAS_COST.add(keeperReward.div(tx.gasprice)), tx.gasprice).add(\n      applyRatio(amountIn, _fee)\n    );\n  }\n\n  function applyIBBTCFee(\n    uint256 amountIn,\n    uint256 _fee,\n    uint256 multiplier\n  ) internal view returns (uint256 amount) {\n    amount = computeRenBTCGasFee(IBBTC_GAS_COST.add(keeperReward.div(tx.gasprice)), tx.gasprice).add(\n      applyRatio(amountIn, _fee)\n    );\n  }\n\n  struct LoanParams {\n    address to;\n    address asset;\n    uint256 nonce;\n    uint256 amount;\n    address module;\n    address underwriter;\n    bytes data;\n    uint256 minOut;\n    uint256 _mintAmount;\n    uint256 gasDiff;\n  }\n\n  function toTypedDataHash(LoanParams memory params) internal view returns (bytes32 result) {\n    bytes32 digest = _hashTypedDataV4(\n      keccak256(\n        abi.encode(\n          keccak256(\n            \"TransferRequest(address asset,uint256 amount,address underwriter,address module,uint256 nonce,bytes data)\"\n          ),\n          params.asset,\n          params.amount,\n          params.underwriter,\n          params.module,\n          params.nonce,\n          keccak256(params.data)\n        )\n      )\n    );\n    return digest;\n  }\n\n  function repay(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public returns (uint256 amountOut) {\n    require(msg.data.length <= 516, \"too much calldata\");\n    uint256 _gasBefore = gasleft();\n    LoanParams memory params;\n    {\n      require(\n        module == wbtc || module == usdc || module == ibbtc || module == renbtc || module == address(0x0),\n        \"!approved-module\"\n      );\n      params = LoanParams({\n        to: to,\n        asset: asset,\n        amount: amount,\n        nonce: nonce,\n        module: module,\n        underwriter: underwriter,\n        data: data,\n        minOut: 1,\n        _mintAmount: 0,\n        gasDiff: computeCalldataGasDiff()\n      });\n      if (data.length > 0) (params.minOut) = abi.decode(data, (uint256));\n    }\n    bytes32 digest = toTypedDataHash(params);\n\n    params._mintAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    {\n      amountOut = module == wbtc ? toWBTC(deductMintFee(params._mintAmount, 1)) : module == address(0x0)\n        ? renBTCtoETH(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : module == usdc\n        ? toUSDC(params.minOut, deductMintFee(params._mintAmount, 1), to)\n        : module == ibbtc\n        ? toIBBTC(deductIBBTCMintFee(params._mintAmount, 3))\n        : deductMintFee(params._mintAmount, 1);\n    }\n    {\n      if (module != usdc && module != address(0x0)) IERC20(module).safeTransfer(to, amountOut);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          _gasBefore.sub(gasleft()).add(REPAY_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function computeBurnNonce(BurnLocals memory params) internal view returns (uint256 result) {\n    result = uint256(\n      keccak256(\n        abi.encodePacked(params.asset, params.amount, params.deadline, params.nonce, params.data, params.destination)\n      )\n    );\n    while (result < block.timestamp) {\n      // negligible probability of this\n      result = uint256(keccak256(abi.encodePacked(result)));\n    }\n  }\n\n  function computeERC20PermitDigest(bytes32 domainSeparator, BurnLocals memory params)\n    internal\n    view\n    returns (bytes32 result)\n  {\n    result = keccak256(\n      abi.encodePacked(\n        \"\\x19\\x01\",\n        domainSeparator,\n        keccak256(abi.encode(PERMIT_TYPEHASH, params.to, address(this), params.nonce, computeBurnNonce(params), true))\n      )\n    );\n  }\n\n  struct BurnLocals {\n    address to;\n    address asset;\n    uint256 amount;\n    uint256 deadline;\n    uint256 nonce;\n    bytes data;\n    uint256 minOut;\n    uint256 burnNonce;\n    uint256 gasBefore;\n    uint256 gasDiff;\n    uint8 v;\n    bytes32 r;\n    bytes32 s;\n    bytes destination;\n    bytes signature;\n  }\n\n  function burn(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    bytes memory data,\n    bytes memory destination,\n    bytes memory signature\n  ) public returns (uint256 amountToBurn) {\n    require(msg.data.length <= 580, \"too much calldata\");\n    BurnLocals memory params = BurnLocals({\n      to: to,\n      asset: asset,\n      amount: amount,\n      deadline: deadline,\n      data: data,\n      nonce: 0,\n      burnNonce: 0,\n      v: uint8(0),\n      r: bytes32(0),\n      s: bytes32(0),\n      destination: destination,\n      signature: signature,\n      gasBefore: gasleft(),\n      minOut: 1,\n      gasDiff: 0\n    });\n    {\n      params.gasDiff = computeCalldataGasDiff();\n      if (params.data.length > 0) (params.minOut) = abi.decode(params.data, (uint256));\n    }\n    require(block.timestamp < params.deadline, \"!deadline\");\n\n    if (params.asset == wbtc) {\n      params.nonce = nonces[to];\n      nonces[params.to]++;\n      require(\n        params.to == ECDSA.recover(computeERC20PermitDigest(PERMIT_DOMAIN_SEPARATOR_WBTC, params), params.signature),\n        \"!signature\"\n      ); //  wbtc does not implement ERC20Permit\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n        amountToBurn = toRenBTC(deductBurnFee(params.amount, 1));\n      }\n    } else if (asset == ibbtc) {\n      params.nonce = nonces[to];\n      nonces[to]++;\n      require(\n        params.to == ECDSA.recover(computeERC20PermitDigest(PERMIT_DOMAIN_SEPARATOR_IBBTC, params), params.signature),\n        \"!signature\"\n      ); //  wbtc ibbtc do not implement ERC20Permit\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n        amountToBurn = deductIBBTCBurnFee(fromIBBTC(params.amount), 3);\n      }\n    } else if (params.asset == renbtc) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.nonce,\n          params.burnNonce,\n          true,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(params.amount, 1);\n    } else if (params.asset == usdc) {\n      {\n        params.nonce = IERC2612Permit(params.asset).nonces(params.to);\n        params.burnNonce = computeBurnNonce(params);\n      }\n      {\n        (params.v, params.r, params.s) = SplitSignatureLib.splitSignature(params.signature);\n        IERC2612Permit(params.asset).permit(\n          params.to,\n          address(this),\n          params.amount,\n          params.burnNonce,\n          params.v,\n          params.r,\n          params.s\n        );\n      }\n      {\n        IERC20(params.asset).transferFrom(params.to, address(this), params.amount);\n      }\n      amountToBurn = deductBurnFee(fromUSDC(params.minOut, params.amount), 1);\n    } else revert(\"!supported-asset\");\n    {\n      IGateway(btcGateway).burn(params.destination, amountToBurn);\n    }\n    {\n      tx.origin.transfer(\n        Math.min(\n          params.gasBefore.sub(gasleft()).add(BURN_GAS_DIFF).add(params.gasDiff).mul(tx.gasprice).add(keeperReward),\n          address(this).balance\n        )\n      );\n    }\n  }\n\n  function burnETH(uint256 minOut, bytes memory destination) public payable returns (uint256 amountToBurn) {\n    amountToBurn = fromETHToRenBTC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(btcGateway).burn(destination, amountToBurn);\n  }\n\n  function burnApproved(\n    address from,\n    address asset,\n    uint256 amount,\n    uint256 minOut,\n    bytes memory destination\n  ) public payable returns (uint256 amountToBurn) {\n    require(asset == wbtc || asset == usdc || asset == renbtc || asset == address(0x0), \"!approved-module\");\n    if (asset != address(0x0)) IERC20(asset).transferFrom(msg.sender, address(this), amount);\n    amountToBurn = asset == wbtc ? toRenBTC(amount.sub(applyRatio(amount, burnFee))) : asset == usdc\n      ? fromUSDC(minOut, amount.sub(applyRatio(amount, burnFee)))\n      : asset == renbtc\n      ? amount\n      : fromETHToRenBTC(minOut, msg.value.sub(applyRatio(msg.value, burnFee)));\n    IGateway(btcGateway).burn(destination, amountToBurn);\n  }\n\n  function fallbackMint(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public {\n    LoanParams memory params = LoanParams({\n      to: to,\n      asset: asset,\n      amount: amount,\n      nonce: nonce,\n      module: module,\n      underwriter: underwriter,\n      data: data,\n      minOut: 1,\n      _mintAmount: 0,\n      gasDiff: 0\n    });\n    bytes32 digest = toTypedDataHash(params);\n    uint256 _actualAmount = IGateway(btcGateway).mint(\n      keccak256(abi.encode(params.to, params.nonce, params.module, params.data)),\n      actualAmount,\n      nHash,\n      signature\n    );\n    IERC20(asset).safeTransfer(to, _actualAmount);\n  }\n}\n"
    },
    "contracts/modules/PolygonConvert.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\nimport { PolygonConvertLib } from \"./PolygonConvertLib.sol\";\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { IConverter } from \"../interfaces/IConverter.sol\";\nimport { ICurveUInt256 } from \"../interfaces/CurvePools/ICurveUInt256.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { ICurveUnderlyingUInt256 } from \"../interfaces/CurvePools/ICurveUnderlyingUInt256.sol\";\nimport { ICurveInt128 } from \"../interfaces/CurvePools/ICurveInt128.sol\";\nimport { IRenCrvPolygon } from \"../interfaces/CurvePools/IRenCrvPolygon.sol\";\n\ncontract PolygonConvert is IZeroModule {\n  using SafeERC20 for *;\n  using SafeMath for *;\n  mapping(uint256 => PolygonConvertLib.ConvertRecord) public outstanding;\n  address public immutable controller;\n  address public immutable governance;\n  uint256 public blockTimeout;\n  address public constant router = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;\n  address public constant wMatic = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270;\n  address public constant weth = 0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619;\n  address public constant wbtc = 0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6;\n  address public constant override want = 0xDBf31dF14B66535aF65AaC99C32e9eA844e14501;\n  address public constant renCrvPolygon = 0xC2d95EEF97Ec6C17551d45e77B590dc1F9117C67;\n  address public constant tricryptoPolygon = 0x92215849c439E1f8612b6646060B4E3E5ef822cC;\n\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  constructor(address _controller) {\n    controller = _controller;\n    governance = IController(_controller).governance();\n    IERC20(want).safeApprove(router, ~uint256(0) >> 2);\n  }\n\n  function setBlockTimeout(uint256 _ct) public {\n    require(msg.sender == governance, \"!governance\");\n    blockTimeout = _ct;\n  }\n\n  function isActive(PolygonConvertLib.ConvertRecord storage record) internal view returns (bool) {\n    return record.qty != 0 || record.qtyETH != 0;\n  }\n\n  function defaultLoan(uint256 _nonce) public {\n    require(block.number >= outstanding[_nonce].when + blockTimeout);\n    require(isActive(outstanding[_nonce]), \"!outstanding\");\n    uint256 _amountSwappedBack = swapTokensBack(outstanding[_nonce]);\n    IERC20(want).safeTransfer(controller, _amountSwappedBack);\n    delete outstanding[_nonce];\n  }\n\n  function receiveLoan(\n    address _to,\n    address _asset,\n    uint256 _actual,\n    uint256 _nonce,\n    bytes memory _data\n  ) public override onlyController {\n    uint256 ratio = abi.decode(_data, (uint256));\n    (uint256 amountSwappedETH, uint256 amountSwappedBTC) = swapTokens(_actual, ratio);\n    outstanding[_nonce] = PolygonConvertLib.ConvertRecord({\n      qty: amountSwappedBTC,\n      when: uint64(block.timestamp),\n      qtyETH: amountSwappedETH\n    });\n  }\n\n  function swapTokens(uint256 _amountIn, uint256 _ratio)\n    internal\n    returns (uint256 amountSwappedETH, uint256 amountSwappedBTC)\n  {\n    uint256 amountToETH = _ratio.mul(_amountIn).div(uint256(1 ether));\n    if (amountToETH != 0) {\n      address[] memory path = new address[](2);\n      path[0] = want;\n      path[1] = wMatic;\n      uint256[] memory toMaticResult = IUniswapV2Router02(router).swapExactTokensForETH(\n        amountToETH,\n        1,\n        path,\n        address(this),\n        block.timestamp + 1\n      );\n      amountSwappedETH = toMaticResult[1];\n      amountSwappedBTC = _amountIn.sub(amountToETH);\n    } else {\n      amountSwappedBTC = _amountIn;\n    }\n  }\n\n  receive() external payable {\n    //\n  }\n\n  function swapTokensBack(PolygonConvertLib.ConvertRecord storage record) internal returns (uint256 amountReturned) {\n    uint256 _amountStart = IERC20(wbtc).balanceOf(address(this));\n    (bool success, ) = tricryptoPolygon.call{ value: record.qtyETH }(\n      abi.encodeWithSelector(ICurveUInt256.exchange.selector, 2, 1, record.qtyETH, 0)\n    );\n    require(success, \"!exchange\");\n    uint256 wbtcOut = IERC20(wbtc).balanceOf(address(this));\n    amountReturned = IRenCrvPolygon(renCrvPolygon).exchange(0, 1, wbtcOut, 0).add(record.qty);\n  }\n\n  function repayLoan(\n    address _to,\n    address _asset,\n    uint256 _actualAmount,\n    uint256 _nonce,\n    bytes memory _data\n  ) public override onlyController {\n    require(outstanding[_nonce].qty != 0 || outstanding[_nonce].qtyETH != 0, \"!outstanding\");\n    IERC20(want).safeTransfer(_to, outstanding[_nonce].qty);\n    address payable to = address(uint160(_to));\n    to.transfer(outstanding[_nonce].qtyETH);\n    delete outstanding[_nonce];\n  }\n\n  function computeReserveRequirement(uint256 _in) external view override returns (uint256) {\n    return _in.mul(uint256(1e17)).div(uint256(1 ether));\n  }\n}\n"
    },
    "contracts/modules/PolygonConvertLib.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\nlibrary PolygonConvertLib {\n  struct ConvertRecord {\n    uint64 when;\n    uint256 qtyETH;\n    uint256 qty;\n  }\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveUnderlyingUInt256.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurveUnderlyingUInt256 {\n  function get_dy_underlying(\n    uint256,\n    uint256,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange_underlying(\n    uint256,\n    uint256,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function underlying_coins(uint256) external view returns (address);\n}\n"
    },
    "contracts/interfaces/CurvePools/IRenCrvPolygon.sol": {
      "content": "interface IRenCrvPolygon {\n  function exchange(\n    int128 i,\n    int128 j,\n    uint256 dx,\n    uint256 min_dy\n  ) external returns (uint256);\n}\n"
    },
    "contracts/libraries/CurveLib.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\n\nimport { ICurveInt128 } from \"../interfaces/CurvePools/ICurveInt128.sol\";\nimport { ICurveUInt128 } from \"../interfaces/CurvePools/ICurveUInt128.sol\";\n\nimport { ICurveInt256 } from \"../interfaces/CurvePools/ICurveInt256.sol\";\n\nimport { ICurveUInt256 } from \"../interfaces/CurvePools/ICurveUInt256.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { ICurveUnderlyingUInt128 } from \"../interfaces/CurvePools/ICurveUnderlyingUInt128.sol\";\nimport { ICurveUnderlyingUInt256 } from \"../interfaces/CurvePools/ICurveUnderlyingUInt256.sol\";\nimport { ICurveUnderlyingInt128 } from \"../interfaces/CurvePools/ICurveUnderlyingInt128.sol\";\nimport { ICurveUnderlyingInt256 } from \"../interfaces/CurvePools/ICurveUnderlyingInt256.sol\";\nimport { RevertCaptureLib } from \"./RevertCaptureLib.sol\";\n\nlibrary CurveLib {\n  address constant weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n  struct ICurve {\n    address pool;\n    bool underlying;\n    bytes4 coinsSelector;\n    bytes4 exchangeSelector;\n    bytes4 getDySelector;\n    bytes4 coinsUnderlyingSelector;\n  }\n\n  function hasWETH(address pool, bytes4 coinsSelector) internal returns (bool) {\n    for (uint256 i = 0; ; i++) {\n      (bool success, bytes memory result) = pool.staticcall{ gas: 2e5 }(abi.encodePacked(coinsSelector, i));\n      if (!success || result.length == 0) return false;\n      address coin = abi.decode(result, (address));\n      if (coin == weth) return true;\n    }\n  }\n\n  function coins(ICurve memory curve, uint256 i) internal view returns (address result) {\n    (bool success, bytes memory returnData) = curve.pool.staticcall(abi.encodeWithSelector(curve.coinsSelector, i));\n    require(success, \"!coins\");\n    (result) = abi.decode(returnData, (address));\n  }\n\n  function underlying_coins(ICurve memory curve, uint256 i) internal view returns (address result) {\n    (bool success, bytes memory returnData) = curve.pool.staticcall(\n      abi.encodeWithSelector(curve.coinsUnderlyingSelector, i)\n    );\n    require(success, \"!underlying_coins\");\n    (result) = abi.decode(returnData, (address));\n  }\n\n  function get_dy(\n    ICurve memory curve,\n    uint256 i,\n    uint256 j,\n    uint256 amount\n  ) internal view returns (uint256 result) {\n    (bool success, bytes memory returnData) = curve.pool.staticcall(\n      abi.encodeWithSelector(curve.getDySelector, i, j, amount)\n    );\n    require(success, \"!get_dy\");\n    (result) = abi.decode(returnData, (uint256));\n  }\n\n  function exchange(\n    ICurve memory curve,\n    uint256 i,\n    uint256 j,\n    uint256 dx,\n    uint256 min_dy\n  ) internal {\n    (bool success, bytes memory returnData) = curve.pool.call{ gas: gasleft() }(\n      abi.encodeWithSelector(curve.exchangeSelector, i, j, dx, min_dy)\n    );\n    if (!success) revert(RevertCaptureLib.decodeError(returnData));\n  }\n\n  function toDynamic(bytes4[4] memory ary) internal pure returns (bytes4[] memory result) {\n    result = new bytes4[](ary.length);\n    for (uint256 i = 0; i < ary.length; i++) {\n      result[i] = ary[i];\n    }\n  }\n\n  function toDynamic(bytes4[5] memory ary) internal pure returns (bytes4[] memory result) {\n    result = new bytes4[](ary.length);\n    for (uint256 i = 0; i < ary.length; i++) {\n      result[i] = ary[i];\n    }\n  }\n\n  function testSignatures(\n    address target,\n    bytes4[] memory signatures,\n    bytes memory callData\n  ) internal returns (bytes4 result) {\n    for (uint256 i = 0; i < signatures.length; i++) {\n      (, bytes memory returnData) = target.staticcall(abi.encodePacked(signatures[i], callData));\n      if (returnData.length != 0) return signatures[i];\n    }\n    return bytes4(0x0);\n  }\n\n  function testExchangeSignatures(\n    address target,\n    bytes4[] memory signatures,\n    bytes memory callData\n  ) internal returns (bytes4 result) {\n    for (uint256 i = 0; i < signatures.length; i++) {\n      uint256 gasStart = gasleft();\n      (bool success, ) = target.call{ gas: 2e5 }(abi.encodePacked(signatures[i], callData));\n      uint256 gasUsed = gasStart - gasleft();\n      if (gasUsed > 10000) return signatures[i];\n    }\n    return bytes4(0x0);\n  }\n\n  function toBytes(bytes4 sel) internal pure returns (bytes memory result) {\n    result = new bytes(4);\n    bytes32 selWord = bytes32(sel);\n    assembly {\n      mstore(add(0x20, result), selWord)\n    }\n  }\n\n  function duckPool(address pool, bool underlying) internal returns (ICurve memory result) {\n    result.pool = pool;\n    result.underlying = underlying;\n    result.coinsSelector = result.underlying\n      ? testSignatures(\n        pool,\n        toDynamic(\n          [\n            ICurveUnderlyingInt128.underlying_coins.selector,\n            ICurveUnderlyingInt256.underlying_coins.selector,\n            ICurveUnderlyingUInt128.underlying_coins.selector,\n            ICurveUnderlyingUInt256.underlying_coins.selector\n          ]\n        ),\n        abi.encode(0)\n      )\n      : testSignatures(\n        pool,\n        toDynamic(\n          [\n            ICurveInt128.coins.selector,\n            ICurveInt256.coins.selector,\n            ICurveUInt128.coins.selector,\n            ICurveUInt256.coins.selector\n          ]\n        ),\n        abi.encode(0)\n      );\n    result.exchangeSelector = result.underlying\n      ? testExchangeSignatures(\n        pool,\n        toDynamic(\n          [\n            ICurveUnderlyingUInt256.exchange_underlying.selector,\n            ICurveUnderlyingInt128.exchange_underlying.selector,\n            ICurveUnderlyingInt256.exchange_underlying.selector,\n            ICurveUnderlyingUInt128.exchange_underlying.selector\n          ]\n        ),\n        abi.encode(0, 0, 1000000000, type(uint256).max / 0x10, false)\n      )\n      : testExchangeSignatures(\n        pool,\n        toDynamic(\n          [\n            ICurveUInt256.exchange.selector,\n            ICurveInt128.exchange.selector,\n            ICurveInt256.exchange.selector,\n            ICurveUInt128.exchange.selector,\n            ICurveETHUInt256.exchange.selector\n          ]\n        ),\n        abi.encode(0, 0, 1000000000, type(uint256).max / 0x10, false)\n      );\n    if (result.exchangeSelector == bytes4(0x0)) result.exchangeSelector = ICurveUInt256.exchange.selector; //hasWETH(pool, result.coinsSelector) ? ICurveETHUInt256.exchange.selector : ICurveUInt256.exchange.selector;\n    result.getDySelector = testSignatures(\n      pool,\n      toDynamic(\n        [\n          ICurveInt128.get_dy.selector,\n          ICurveInt256.get_dy.selector,\n          ICurveUInt128.get_dy.selector,\n          ICurveUInt256.get_dy.selector\n        ]\n      ),\n      abi.encode(0, 1, 1000000000)\n    );\n  }\n\n  function fromSelectors(\n    address pool,\n    bool underlying,\n    bytes4 coinsSelector,\n    bytes4 coinsUnderlyingSelector,\n    bytes4 exchangeSelector,\n    bytes4 getDySelector\n  ) internal pure returns (ICurve memory result) {\n    result.pool = pool;\n    result.coinsSelector = coinsSelector;\n    result.coinsUnderlyingSelector = coinsUnderlyingSelector;\n    result.exchangeSelector = exchangeSelector;\n    result.getDySelector = getDySelector;\n  }\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveUInt128.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurveUInt128 {\n  function get_dy(\n    uint128,\n    uint128,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange(\n    uint128,\n    uint128,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function coins(uint128) external view returns (address);\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveInt256.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurveInt256 {\n  function get_dy(\n    int256,\n    int256,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange(\n    int256,\n    int256,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function coins(int256) external view returns (address);\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveUnderlyingUInt128.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurveUnderlyingUInt128 {\n  function get_dy_underlying(\n    uint128,\n    uint128,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange_underlying(\n    uint128,\n    uint128,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function underlying_coins(uint128) external view returns (address);\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveUnderlyingInt128.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurveUnderlyingInt128 {\n  function get_dy_underlying(\n    int128,\n    int128,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange_underlying(\n    int128,\n    int128,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function underlying_coins(int128) external view returns (address);\n}\n"
    },
    "contracts/interfaces/CurvePools/ICurveUnderlyingInt256.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\ninterface ICurveUnderlyingInt256 {\n  function get_dy_underlying(\n    int256,\n    int256,\n    uint256\n  ) external view returns (uint256);\n\n  function exchange_underlying(\n    int256,\n    int256,\n    uint256,\n    uint256\n  ) external returns (uint256);\n\n  function underlying_coins(int256) external view returns (address);\n}\n"
    },
    "contracts/libraries/RevertCaptureLib.sol": {
      "content": "pragma experimental ABIEncoderV2;\n// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport { SliceLib } from \"./SliceLib.sol\";\n\nlibrary RevertCaptureLib {\n  using SliceLib for *;\n  uint32 constant REVERT_WITH_REASON_MAGIC = 0x08c379a0; // keccak256(\"Error(string)\")\n\n  function decodeString(bytes memory input) internal pure returns (string memory retval) {\n    (retval) = abi.decode(input, (string));\n  }\n\n  function decodeError(bytes memory buffer) internal pure returns (string memory) {\n    if (buffer.length == 0) return \"captured empty revert buffer\";\n    if (uint32(uint256(bytes32(buffer.toSlice(0, 4).asWord()))) != REVERT_WITH_REASON_MAGIC)\n      return \"captured a revert error, but it doesn't conform to the standard\";\n    bytes memory revertMessageEncoded = buffer.toSlice(4).copy();\n    if (revertMessageEncoded.length == 0) return \"captured empty revert message\";\n    string memory revertMessage = decodeString(revertMessageEncoded);\n    return revertMessage;\n  }\n}\n"
    },
    "contracts/libraries/SliceLib.sol": {
      "content": "pragma experimental ABIEncoderV2;\n// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport { MemcpyLib } from \"./MemcpyLib.sol\";\n\nlibrary SliceLib {\n  struct Slice {\n    uint256 data;\n    uint256 length;\n    uint256 offset;\n  }\n\n  function toPtr(bytes memory input, uint256 offset) internal pure returns (uint256 data) {\n    assembly {\n      data := add(input, add(offset, 0x20))\n    }\n  }\n\n  function toSlice(\n    bytes memory input,\n    uint256 offset,\n    uint256 length\n  ) internal pure returns (Slice memory retval) {\n    retval.data = toPtr(input, offset);\n    retval.length = length;\n    retval.offset = offset;\n  }\n\n  function toSlice(bytes memory input) internal pure returns (Slice memory) {\n    return toSlice(input, 0);\n  }\n\n  function toSlice(bytes memory input, uint256 offset) internal pure returns (Slice memory) {\n    if (input.length < offset) offset = input.length;\n    return toSlice(input, offset, input.length - offset);\n  }\n\n  function toSlice(\n    Slice memory input,\n    uint256 offset,\n    uint256 length\n  ) internal pure returns (Slice memory) {\n    return Slice({ data: input.data + offset, offset: input.offset + offset, length: length });\n  }\n\n  function toSlice(Slice memory input, uint256 offset) internal pure returns (Slice memory) {\n    return toSlice(input, offset, input.length - offset);\n  }\n\n  function toSlice(Slice memory input) internal pure returns (Slice memory) {\n    return toSlice(input, 0);\n  }\n\n  function maskLastByteOfWordAt(uint256 data) internal pure returns (uint8 lastByte) {\n    assembly {\n      lastByte := and(mload(data), 0xff)\n    }\n  }\n\n  function get(Slice memory slice, uint256 index) internal pure returns (bytes1 result) {\n    return bytes1(maskLastByteOfWordAt(slice.data - 0x1f + index));\n  }\n\n  function setByteAt(uint256 ptr, uint8 value) internal pure {\n    assembly {\n      mstore8(ptr, value)\n    }\n  }\n\n  function set(\n    Slice memory slice,\n    uint256 index,\n    uint8 value\n  ) internal pure {\n    setByteAt(slice.data + index, value);\n  }\n\n  function wordAt(uint256 ptr, uint256 length) internal pure returns (bytes32 word) {\n    assembly {\n      let mask := sub(shl(mul(length, 0x8), 0x1), 0x1)\n      word := and(mload(sub(ptr, sub(0x20, length))), mask)\n    }\n  }\n\n  function asWord(Slice memory slice) internal pure returns (bytes32 word) {\n    uint256 data = slice.data;\n    uint256 length = slice.length;\n    return wordAt(data, length);\n  }\n\n  function toDataStart(bytes memory input) internal pure returns (bytes32 start) {\n    assembly {\n      start := add(input, 0x20)\n    }\n  }\n\n  function copy(Slice memory slice) internal pure returns (bytes memory retval) {\n    uint256 length = slice.length;\n    retval = new bytes(length);\n    bytes32 src = bytes32(slice.data);\n    bytes32 dest = toDataStart(retval);\n    MemcpyLib.memcpy(dest, src, length);\n  }\n\n  function keccakAt(uint256 data, uint256 length) internal pure returns (bytes32 result) {\n    assembly {\n      result := keccak256(data, length)\n    }\n  }\n\n  function toKeccak(Slice memory slice) internal pure returns (bytes32 result) {\n    return keccakAt(slice.data, slice.length);\n  }\n}\n"
    },
    "contracts/libraries/MemcpyLib.sol": {
      "content": "pragma experimental ABIEncoderV2;\n// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nlibrary MemcpyLib {\n  function memcpy(\n    bytes32 dest,\n    bytes32 src,\n    uint256 len\n  ) internal pure {\n    assembly {\n      for {\n\n      } iszero(lt(len, 0x20)) {\n        len := sub(len, 0x20)\n      } {\n        mstore(dest, mload(src))\n        dest := add(dest, 0x20)\n        src := add(src, 0x20)\n      }\n      let mask := sub(shl(mul(sub(32, len), 8), 1), 1)\n      mstore(dest, or(and(mload(src), not(mask)), and(mload(dest), mask)))\n    }\n  }\n}\n"
    },
    "contracts/converters/ZeroCurveFactory.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\nimport { ICurvePool } from \"../interfaces/ICurvePool.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { ZeroCurveWrapper } from \"./ZeroCurveWrapper.sol\";\nimport { ICurveInt128 } from \"../interfaces/CurvePools/ICurveInt128.sol\";\nimport { ICurveInt256 } from \"../interfaces/CurvePools/ICurveInt256.sol\";\nimport { ICurveUInt128 } from \"../interfaces/CurvePools/ICurveUInt128.sol\";\nimport { ICurveUInt256 } from \"../interfaces/CurvePools/ICurveUInt256.sol\";\nimport { ICurveUnderlyingInt128 } from \"../interfaces/CurvePools/ICurveUnderlyingInt128.sol\";\nimport { ICurveUnderlyingInt256 } from \"../interfaces/CurvePools/ICurveUnderlyingInt256.sol\";\nimport { ICurveUnderlyingUInt128 } from \"../interfaces/CurvePools/ICurveUnderlyingUInt128.sol\";\nimport { ICurveUnderlyingUInt256 } from \"../interfaces/CurvePools/ICurveUnderlyingUInt256.sol\";\nimport { CurveLib } from \"../libraries/CurveLib.sol\";\n\ncontract ZeroCurveFactory {\n  event CreateWrapper(address _wrapper);\n\n  function createWrapper(\n    bool _underlying,\n    uint256 _tokenInIndex,\n    uint256 _tokenOutIndex,\n    address _pool\n  ) public payable {\n    emit CreateWrapper(address(new ZeroCurveWrapper(_tokenInIndex, _tokenOutIndex, _pool, _underlying)));\n  }\n\n  fallback() external payable {\n    /* no op */\n  }\n}\n"
    },
    "contracts/converters/ZeroCurveWrapper.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\n\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { ICurvePool } from \"../interfaces/ICurvePool.sol\";\nimport { CurveLib } from \"../libraries/CurveLib.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\n\ncontract ZeroCurveWrapper {\n  bool public immutable underlying;\n  uint256 public immutable tokenInIndex;\n  uint256 public immutable tokenOutIndex;\n  address public immutable tokenInAddress;\n  address public immutable tokenOutAddress;\n  address public immutable pool;\n  bytes4 public immutable coinsUnderlyingSelector;\n  bytes4 public immutable coinsSelector;\n  bytes4 public immutable getDySelector;\n  bytes4 public immutable exchangeSelector;\n\n  using SafeMath for uint256;\n  using SafeERC20 for IERC20;\n  using CurveLib for CurveLib.ICurve;\n\n  function getPool() internal view returns (CurveLib.ICurve memory result) {\n    result = CurveLib.fromSelectors(\n      pool,\n      underlying,\n      coinsSelector,\n      coinsUnderlyingSelector,\n      exchangeSelector,\n      getDySelector\n    );\n  }\n\n  constructor(\n    uint256 _tokenInIndex,\n    uint256 _tokenOutIndex,\n    address _pool,\n    bool _underlying\n  ) {\n    underlying = _underlying;\n    tokenInIndex = _tokenInIndex;\n    tokenOutIndex = _tokenOutIndex;\n    pool = _pool;\n    CurveLib.ICurve memory curve = CurveLib.duckPool(_pool, _underlying);\n    coinsUnderlyingSelector = curve.coinsUnderlyingSelector;\n    coinsSelector = curve.coinsSelector;\n    exchangeSelector = curve.exchangeSelector;\n    getDySelector = curve.getDySelector;\n    address _tokenInAddress = tokenInAddress = curve.coins(_tokenInIndex);\n    address _tokenOutAddress = tokenOutAddress = curve.coins(_tokenOutIndex);\n    IERC20(_tokenInAddress).safeApprove(_pool, type(uint256).max / 2);\n  }\n\n  function estimate(uint256 _amount) public returns (uint256 result) {\n    result = getPool().get_dy(tokenInIndex, tokenOutIndex, _amount);\n  }\n\n  function convert(address _module) external payable returns (uint256 _actualOut) {\n    uint256 _balance = IERC20(tokenInAddress).balanceOf(address(this));\n    uint256 _startOut = IERC20(tokenOutAddress).balanceOf(address(this));\n    getPool().exchange(tokenInIndex, tokenOutIndex, _balance, _balance / 0x10);\n    _actualOut = IERC20(tokenOutAddress).balanceOf(address(this)) - _startOut;\n    IERC20(tokenOutAddress).safeTransfer(msg.sender, _actualOut);\n  }\n\n  receive() external payable {\n    /* noop */\n  }\n\n  fallback() external payable {\n    /* noop */\n  }\n}\n"
    },
    "contracts/strategies/StrategyRenVMAsset.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.5.17 <0.8.0;\n\nimport \"oz410/token/ERC20/IERC20.sol\";\nimport \"oz410/math/SafeMath.sol\";\nimport \"oz410/utils/Address.sol\";\nimport \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\n\ncontract StrategyRenVMAsset {\n  using SafeERC20 for IERC20;\n  using Address for address;\n  using SafeMath for uint256;\n\n  address public immutable want;\n\n  address public weth;\n\n  uint256 public performanceFee;\n  uint256 public performanceMax;\n\n  uint256 public withdrawalFee;\n  uint256 public withdrawalMax;\n\n  address public governance;\n  address public controller;\n  address public strategist;\n  string public getName;\n\n  constructor(\n    address _controller,\n    address _want,\n    string memory _name\n  ) {\n    governance = msg.sender;\n    strategist = msg.sender;\n    controller = _controller;\n    want = _want;\n    getName = _name;\n  }\n\n  function setStrategist(address _strategist) external {\n    require(msg.sender == governance, \"!governance\");\n    strategist = _strategist;\n  }\n\n  function setWithdrawalFee(uint256 _withdrawalFee) external {\n    require(msg.sender == governance, \"!governance\");\n    withdrawalFee = _withdrawalFee;\n  }\n\n  function setPerformanceFee(uint256 _performanceFee) external {\n    require(msg.sender == governance, \"!governance\");\n    performanceFee = _performanceFee;\n  }\n\n  function deposit() public {\n    uint256 _want = IERC20(want).balanceOf(msg.sender);\n    IERC20(want).safeTransferFrom(address(msg.sender), address(this), _want);\n  }\n\n  // Controller only function for creating additional rewards from dust\n  function withdraw(IERC20 _asset) external returns (uint256 balance) {\n    require(msg.sender == controller, \"!controller\");\n    require(want != address(_asset), \"want\");\n    balance = _asset.balanceOf(address(this));\n    _asset.safeTransfer(controller, balance);\n  }\n\n  function permissionedSend(address _target, uint256 _amount) external {\n    require(msg.sender == controller, \"!controller\");\n    IERC20(want).safeTransfer(_target, _amount);\n  }\n\n  // Withdraw partial funds, normally used with a vault withdrawal\n  function withdraw(uint256 _amount) external {\n    require(msg.sender == controller, \"!controller\");\n    uint256 _balance = IERC20(want).balanceOf(address(this));\n    if (_balance < _amount) {\n      _amount = _withdrawSome(_amount.sub(_balance));\n      _amount = _amount.add(_balance);\n    }\n\n    uint256 _fee = _amount.mul(withdrawalFee).div(withdrawalMax);\n\n    IERC20(want).safeTransfer(IController(controller).rewards(), _fee);\n    address _vault = IController(controller).vaults(address(want));\n    require(_vault != address(0), \"!vault\"); // additional protection so we don't burn the funds\n\n    IERC20(want).safeTransfer(_vault, _amount.sub(_fee));\n  }\n\n  // Withdraw all funds, normally used when migrating strategies\n  function withdrawAll() external returns (uint256 balance) {\n    require(msg.sender == controller, \"!controller\");\n    _withdrawAll();\n\n    balance = IERC20(want).balanceOf(address(this));\n\n    address _vault = IController(controller).vaults(address(want));\n    require(_vault != address(0), \"!vault\"); // additional protection so we don't burn the funds\n    IERC20(want).safeTransfer(_vault, balance);\n  }\n\n  function _withdrawAll() internal {\n    _withdrawSome(balanceOfWant());\n  }\n\n  function harvest() public {\n    require(msg.sender == strategist || msg.sender == governance, \"!authorized\");\n  }\n\n  function _withdrawC(uint256 _amount) internal {}\n\n  function _withdrawSome(uint256 _amount) internal view returns (uint256) {\n    uint256 _before = IERC20(want).balanceOf(address(this));\n    uint256 _after = IERC20(want).balanceOf(address(this));\n    uint256 _withdrew = _after.sub(_before);\n    return _withdrew;\n  }\n\n  function balanceOfWant() public view returns (uint256 result) {\n    result = IERC20(want).balanceOf(address(this));\n  }\n\n  function balanceOf() public view returns (uint256 result) {}\n\n  function setGovernance(address _governance) external {\n    require(msg.sender == governance, \"!governance\");\n    governance = _governance;\n  }\n\n  function setController(address _controller) external {\n    require(msg.sender == governance, \"!governance\");\n    controller = _controller;\n  }\n}\n"
    },
    "contracts/modules/ArbitrumMIM.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\nimport { ArbitrumConvertLib } from \"./ArbitrumConvertLib.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { IRenCrvArbitrum } from \"../interfaces/CurvePools/IRenCrvArbitrum.sol\";\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\n\ncontract ArbitrumMIMConvert is IZeroModule {\n  using SafeERC20 for *;\n  using SafeMath for *;\n  mapping(uint256 => ArbitrumConvertLib.ConvertRecord) public outstanding;\n  address public immutable controller;\n  address public immutable governance;\n  uint256 public blockTimeout;\n  address public constant weth = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;\n  address public constant wbtc = 0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f;\n  address public constant override want = 0xDBf31dF14B66535aF65AaC99C32e9eA844e14501;\n  address public constant renCrvArbitrum = 0x3E01dD8a5E1fb3481F0F589056b428Fc308AF0Fb;\n  address public constant tricryptoArbitrum = 0x960ea3e3C7FB317332d990873d354E18d7645590;\n  address public constant mimCrvArbitrum = 0x30dF229cefa463e991e29D42DB0bae2e122B2AC7;\n  address public constant usdt = 0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9;\n  address public constant mim = 0xFEa7a6a0B346362BF88A9e4A88416B77a57D6c2A;\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  constructor(address _controller) {\n    controller = _controller;\n    governance = IController(_controller).governance();\n    IERC20(want).safeApprove(renCrvArbitrum, ~uint256(0));\n    IERC20(wbtc).safeApprove(tricryptoArbitrum, ~uint256(0));\n    IERC20(mim).safeApprove(mimCrvArbitrum, ~uint256(0));\n    IERC20(usdt).safeApprove(mimCrvArbitrum, ~uint256(0));\n  }\n\n  function setBlockTimeout(uint256 _ct) public {\n    require(msg.sender == governance, \"!governance\");\n    blockTimeout = _ct;\n  }\n\n  function isActive(ArbitrumConvertLib.ConvertRecord storage record) internal view returns (bool) {\n    return record.qty != 0 || record.qtyETH != 0;\n  }\n\n  function defaultLoan(uint256 _nonce) public {\n    require(block.number >= outstanding[_nonce].when + blockTimeout);\n    require(isActive(outstanding[_nonce]), \"!outstanding\");\n    uint256 _amountSwappedBack = swapTokensBack(outstanding[_nonce]);\n    IERC20(want).safeTransfer(controller, _amountSwappedBack);\n    delete outstanding[_nonce];\n  }\n\n  function receiveLoan(\n    address _to,\n    address _asset,\n    uint256 _actual,\n    uint256 _nonce,\n    bytes memory _data\n  ) public override onlyController {\n    uint256 ratio = abi.decode(_data, (uint256));\n    (uint256 amountSwappedETH, uint256 amountSwappedMIM) = swapTokens(_actual, ratio);\n    outstanding[_nonce] = ArbitrumConvertLib.ConvertRecord({\n      qty: amountSwappedMIM,\n      when: uint64(block.timestamp),\n      qtyETH: amountSwappedETH\n    });\n  }\n\n  function swapTokens(uint256 _amountIn, uint256 _ratio)\n    internal\n    returns (uint256 amountSwappedETH, uint256 amountSwappedMIM)\n  {\n    uint256 wbtcOut = IRenCrvArbitrum(renCrvArbitrum).exchange(0, 1, _amountIn, 0, address(this));\n    uint256 amountToETH = wbtcOut.mul(_ratio).div(uint256(1 ether));\n    amountSwappedETH = ICurveETHUInt256(tricryptoArbitrum).exchange(1, 2, wbtcOut, 0, true);\n    uint256 usdtOut = ICurveETHUInt256(tricryptoArbitrum).exchange(1, 0, wbtcOut.sub(amountToETH), 0, false);\n    amountSwappedMIM = IRenCrvArbitrum(mimCrvArbitrum).exchange(2, 0, usdtOut, 0, address(this));\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function swapTokensBack(ArbitrumConvertLib.ConvertRecord storage record) internal returns (uint256 amountReturned) {\n    uint256 usdtOut = IRenCrvArbitrum(mimCrvArbitrum).exchange(0, 2, record.qty, 0, address(this));\n    uint256 amountSwappedFromETH = ICurveETHUInt256(tricryptoArbitrum).exchange{ value: record.qtyETH }(\n      2,\n      1,\n      record.qtyETH,\n      0,\n      true\n    );\n    uint256 amountSwappedFromUsdt = ICurveETHUInt256(tricryptoArbitrum).exchange(0, 1, usdtOut, 0, false);\n    amountReturned = IRenCrvArbitrum(renCrvArbitrum).exchange(\n      1,\n      0,\n      amountSwappedFromETH.add(amountSwappedFromUsdt),\n      0,\n      address(this)\n    );\n  }\n\n  function repayLoan(\n    address _to,\n    address _asset,\n    uint256 _actualAmount,\n    uint256 _nonce,\n    bytes memory _data\n  ) public override onlyController {\n    require(outstanding[_nonce].qty != 0 || outstanding[_nonce].qtyETH != 0, \"!outstanding\");\n    IERC20(mim).safeTransfer(_to, outstanding[_nonce].qty);\n    address payable to = address(uint160(_to));\n    to.transfer(outstanding[_nonce].qtyETH);\n    delete outstanding[_nonce];\n  }\n\n  function computeReserveRequirement(uint256 _in) external view override returns (uint256) {\n    return _in.mul(uint256(1e17)).div(uint256(1 ether));\n  }\n}\n"
    },
    "contracts/modules/ArbitrumConvertQuick.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\nimport { ArbitrumConvertLib } from \"./ArbitrumConvertLib.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { IRenCrvArbitrum } from \"../interfaces/CurvePools/IRenCrvArbitrum.sol\";\n\ncontract ArbitrumConvertQuick {\n  using SafeERC20 for *;\n  using SafeMath for *;\n  mapping(uint256 => ArbitrumConvertLib.ConvertRecord) public outstanding;\n  address public immutable controller;\n  uint256 public blockTimeout;\n  address public constant weth = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;\n  address public constant wbtc = 0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f;\n  address public constant want = 0xDBf31dF14B66535aF65AaC99C32e9eA844e14501;\n  address public constant renCrvArbitrum = 0x3E01dD8a5E1fb3481F0F589056b428Fc308AF0Fb;\n  address public constant tricryptoArbitrum = 0x960ea3e3C7FB317332d990873d354E18d7645590;\n  uint256 public capacity;\n  struct ConvertRecord {\n    uint128 volume;\n    uint128 when;\n  }\n  mapping(uint256 => ConvertRecord) public records;\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  function governance() public view returns (address) {\n    return IController(controller).governance();\n  }\n\n  function setBlockTimeout(uint256 _amount) public {\n    require(msg.sender == governance(), \"!governance\");\n    blockTimeout = _amount;\n  }\n\n  constructor(\n    address _controller,\n    uint256 _capacity,\n    uint256 _blockTimeout\n  ) {\n    controller = _controller;\n    capacity = _capacity;\n    blockTimeout = _blockTimeout;\n    IERC20(want).safeApprove(renCrvArbitrum, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(tricryptoArbitrum, ~uint256(0) >> 2);\n  }\n\n  function receiveLoan(\n    address _to,\n    address _asset,\n    uint256 _actual,\n    uint256 _nonce,\n    bytes memory _data\n  ) public onlyController {\n    uint256 ratio = abi.decode(_data, (uint256));\n    (uint256 amountSwappedETH, uint256 amountSwappedBTC) = swapTokens(_actual, ratio);\n    IERC20(want).safeTransfer(_to, amountSwappedBTC);\n    address payable to = address(uint160(_to));\n    to.transfer(amountSwappedETH);\n    records[_nonce] = ConvertRecord({ volume: uint128(_actual), when: uint128(block.number) });\n    capacity = capacity.sub(_actual);\n  }\n\n  function defaultLoan(uint256 _nonce) public {\n    require(uint256(records[_nonce].when) + blockTimeout <= block.number, \"!expired\");\n    capacity = capacity.sub(uint256(records[_nonce].volume));\n    delete records[_nonce];\n  }\n\n  function swapTokens(uint256 _amountIn, uint256 _ratio)\n    internal\n    returns (uint256 amountSwappedETH, uint256 amountSwappedBTC)\n  {\n    uint256 amountToETH = _ratio.mul(_amountIn).div(uint256(1 ether));\n    uint256 wbtcOut = amountToETH != 0\n      ? IRenCrvArbitrum(renCrvArbitrum).exchange(1, 0, amountToETH, 0, address(this))\n      : 0;\n    if (wbtcOut != 0) {\n      uint256 _amountStart = address(this).balance;\n      (bool success, ) = tricryptoArbitrum.call(\n        abi.encodeWithSelector(ICurveETHUInt256.exchange.selector, 1, 2, wbtcOut, 0, true)\n      );\n      require(success, \"!exchange\");\n      amountSwappedETH = address(this).balance.sub(_amountStart);\n      amountSwappedBTC = _amountIn.sub(amountToETH);\n    } else {\n      amountSwappedBTC = _amountIn;\n    }\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function repayLoan(\n    address _to,\n    address _asset,\n    uint256 _actualAmount,\n    uint256 _nonce,\n    bytes memory _data\n  ) public onlyController {\n    capacity = capacity.add(records[_nonce].volume);\n    delete records[_nonce];\n  }\n\n  function computeReserveRequirement(uint256 _in) external view returns (uint256) {\n    return _in.mul(12e17).div(1e18); // 120% collateralized\n  }\n}\n"
    },
    "contracts/modules/ArbitrumConvert.sol": {
      "content": "pragma solidity >=0.6.0 <0.8.0;\nimport { ArbitrumConvertLib } from \"./ArbitrumConvertLib.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { IController } from \"../interfaces/IController.sol\";\nimport { ICurveETHUInt256 } from \"../interfaces/CurvePools/ICurveETHUInt256.sol\";\nimport { IRenCrvArbitrum } from \"../interfaces/CurvePools/IRenCrvArbitrum.sol\";\nimport { IZeroModule } from \"../interfaces/IZeroModule.sol\";\n\ncontract ArbitrumConvert is IZeroModule {\n  using SafeERC20 for *;\n  using SafeMath for *;\n  mapping(uint256 => ArbitrumConvertLib.ConvertRecord) public outstanding;\n  address public immutable controller;\n  address public immutable governance;\n  uint256 public blockTimeout;\n  address public constant weth = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;\n  address public constant wbtc = 0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f;\n  address public constant override want = 0xDBf31dF14B66535aF65AaC99C32e9eA844e14501;\n  address public constant renCrvArbitrum = 0x3E01dD8a5E1fb3481F0F589056b428Fc308AF0Fb;\n  address public constant tricryptoArbitrum = 0x960ea3e3C7FB317332d990873d354E18d7645590;\n  modifier onlyController() {\n    require(msg.sender == controller, \"!controller\");\n    _;\n  }\n\n  constructor(address _controller) {\n    controller = _controller;\n    governance = IController(_controller).governance();\n    IERC20(want).safeApprove(renCrvArbitrum, ~uint256(0) >> 2);\n    IERC20(wbtc).safeApprove(tricryptoArbitrum, ~uint256(0) >> 2);\n  }\n\n  function setBlockTimeout(uint256 _ct) public {\n    require(msg.sender == governance, \"!governance\");\n    blockTimeout = _ct;\n  }\n\n  function isActive(ArbitrumConvertLib.ConvertRecord storage record) internal view returns (bool) {\n    return record.qty != 0 || record.qtyETH != 0;\n  }\n\n  function defaultLoan(uint256 _nonce) public {\n    require(block.number >= outstanding[_nonce].when + blockTimeout);\n    require(isActive(outstanding[_nonce]), \"!outstanding\");\n    uint256 _amountSwappedBack = swapTokensBack(outstanding[_nonce]);\n    IERC20(want).safeTransfer(controller, _amountSwappedBack);\n    delete outstanding[_nonce];\n  }\n\n  function receiveLoan(\n    address _to,\n    address _asset,\n    uint256 _actual,\n    uint256 _nonce,\n    bytes memory _data\n  ) public override onlyController {\n    uint256 ratio = abi.decode(_data, (uint256));\n    (uint256 amountSwappedETH, uint256 amountSwappedBTC) = swapTokens(_actual, ratio);\n    outstanding[_nonce] = ArbitrumConvertLib.ConvertRecord({\n      qty: amountSwappedBTC,\n      when: uint64(block.timestamp),\n      qtyETH: amountSwappedETH\n    });\n  }\n\n  function swapTokens(uint256 _amountIn, uint256 _ratio)\n    internal\n    returns (uint256 amountSwappedETH, uint256 amountSwappedBTC)\n  {\n    uint256 amountToETH = _ratio.mul(_amountIn).div(uint256(1 ether));\n    uint256 wbtcOut = amountToETH != 0\n      ? IRenCrvArbitrum(renCrvArbitrum).exchange(1, 0, amountToETH, 0, address(this))\n      : 0;\n    if (wbtcOut != 0) {\n      uint256 _amountStart = address(this).balance;\n      (bool success, ) = tricryptoArbitrum.call(\n        abi.encodeWithSelector(ICurveETHUInt256.exchange.selector, 1, 2, wbtcOut, 0, true)\n      );\n      require(success, \"!exchange\");\n      amountSwappedETH = address(this).balance.sub(_amountStart);\n      amountSwappedBTC = _amountIn.sub(amountToETH);\n    } else {\n      amountSwappedBTC = _amountIn;\n    }\n  }\n\n  receive() external payable {\n    // no-op\n  }\n\n  function swapTokensBack(ArbitrumConvertLib.ConvertRecord storage record) internal returns (uint256 amountReturned) {\n    uint256 _amountStart = IERC20(wbtc).balanceOf(address(this));\n    (bool success, ) = tricryptoArbitrum.call{ value: record.qtyETH }(\n      abi.encodeWithSelector(ICurveETHUInt256.exchange.selector, 2, 1, record.qtyETH, 0, true)\n    );\n    require(success, \"!exchange\");\n    uint256 wbtcOut = IERC20(wbtc).balanceOf(address(this));\n    amountReturned = IRenCrvArbitrum(renCrvArbitrum).exchange(0, 1, wbtcOut, 0, address(this)).add(record.qty);\n  }\n\n  function repayLoan(\n    address _to,\n    address _asset,\n    uint256 _actualAmount,\n    uint256 _nonce,\n    bytes memory _data\n  ) public override onlyController {\n    require(outstanding[_nonce].qty != 0 || outstanding[_nonce].qtyETH != 0, \"!outstanding\");\n    IERC20(want).safeTransfer(_to, outstanding[_nonce].qty);\n    address payable to = address(uint160(_to));\n    to.transfer(outstanding[_nonce].qtyETH);\n    delete outstanding[_nonce];\n  }\n\n  function computeReserveRequirement(uint256 _in) external view override returns (uint256) {\n    return _in.mul(uint256(1e17)).div(uint256(1 ether));\n  }\n}\n"
    },
    "contracts/converters/UniswapFactory.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.7.0 <0.8.0;\nimport { IUniswapV2Router02 } from \"@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"oz410/token/ERC20/SafeERC20.sol\";\nimport { SafeMath } from \"oz410/math/SafeMath.sol\";\n\ncontract ZeroUniswapFactory {\n  address public immutable router;\n\n  event CreateWrapper(address _wrapper);\n\n  constructor(address _router) {\n    router = _router;\n  }\n\n  function createWrapper(address[] memory _path) public {\n    ZeroUniswapWrapper wrapper = new ZeroUniswapWrapper(router, _path);\n    emit CreateWrapper(address(wrapper));\n  }\n}\n\nlibrary AddressSliceLib {\n  function slice(\n    address[] memory ary,\n    uint256 start,\n    uint256 end\n  ) internal pure returns (address[] memory result) {\n    uint256 length = end - start;\n    result = new address[](length);\n    for (uint256 i = 0; i < length; i++) {\n      result[i] = ary[i + start];\n    }\n  }\n\n  function slice(address[] memory ary, uint256 start) internal pure returns (address[] memory result) {\n    result = slice(ary, start, ary.length);\n  }\n}\n\ncontract ZeroUniswapWrapper {\n  address[] public path;\n  address public immutable router;\n\n  using SafeMath for uint256;\n  using SafeERC20 for IERC20;\n  using AddressSliceLib for address[];\n\n  constructor(address _router, address[] memory _path) {\n    router = _router;\n    path = _path;\n    IERC20(_path[0]).safeApprove(address(_router), type(uint256).max);\n  }\n\n  function estimate(uint256 _amount) public view returns (uint256) {\n    if (path[0] == address(0x0)) {\n      return IUniswapV2Router02(router).getAmountsOut(_amount, path.slice(1))[path.length - 2];\n    } else if (path[path.length - 1] == address(0x0)) {\n      return IUniswapV2Router02(router).getAmountsOut(_amount, path.slice(0, path.length - 1))[path.length - 2];\n    } else {\n      return IUniswapV2Router02(router).getAmountsOut(_amount, path)[path.length - 1];\n    }\n  }\n\n  function convert(address _module) external payable returns (uint256) {\n    // Then the input and output tokens are both ERC20\n    uint256 _balance = IERC20(path[0]).balanceOf(address(this));\n    uint256 _minOut = estimate(_balance).sub(1); //Subtract one for minimum in case of rounding errors\n    uint256 _actualOut = IUniswapV2Router02(router).swapExactTokensForTokens(\n      _balance,\n      _minOut,\n      path,\n      msg.sender,\n      block.timestamp\n    )[path.length - 1];\n    return _actualOut;\n  }\n}\n"
    },
    "contracts/converters/WrappedNative.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport \"oz410/math/SafeMath.sol\";\nimport { IWETH } from \"@uniswap/v2-periphery/contracts/interfaces/IWETH.sol\";\nimport { IERC20 } from \"oz410/token/ERC20/IERC20.sol\";\n\ncontract WrapNative {\n  address public immutable wrapper;\n\n  constructor(address _wrapper) {\n    wrapper = _wrapper;\n  }\n\n  receive() external payable {}\n\n  function estimate(uint256 _amount) public view returns (uint256) {\n    return _amount;\n  }\n\n  function convert(address _module) external payable returns (uint256) {\n    IWETH(wrapper).deposit{ value: address(this).balance }();\n    IERC20(wrapper).transfer(msg.sender, IERC20(wrapper).balanceOf(address(this)));\n  }\n}\n\ncontract UnwrapNative {\n  address public immutable wrapper;\n\n  constructor(address _wrapper) {\n    wrapper = _wrapper;\n  }\n\n  receive() external payable {}\n\n  function estimate(uint256 _amount) public view returns (uint256) {\n    return _amount;\n  }\n\n  function convert(address _module) external payable returns (uint256) {\n    IWETH(wrapper).withdraw(IERC20(wrapper).balanceOf(address(this)));\n    require(msg.sender.send(address(this).balance), \"!send\");\n  }\n}\n"
    },
    "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol": {
      "content": "pragma solidity >=0.5.0;\n\ninterface IWETH {\n    function deposit() external payable;\n    function transfer(address to, uint value) external returns (bool);\n    function withdraw(uint) external;\n}\n"
    },
    "@openzeppelin/contracts/utils/EnumerableSet.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity >=0.6.0 <0.8.0;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n *     // Add the library methods\n *     using EnumerableSet for EnumerableSet.AddressSet;\n *\n *     // Declare a set state variable\n *     EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n */\nlibrary EnumerableSet {\n    // To implement this library for multiple types with as little code\n    // repetition as possible, we write it in terms of a generic Set type with\n    // bytes32 values.\n    // The Set implementation uses private functions, and user-facing\n    // implementations (such as AddressSet) are just wrappers around the\n    // underlying Set.\n    // This means that we can only create new EnumerableSets for types that fit\n    // in bytes32.\n\n    struct Set {\n        // Storage of set values\n        bytes32[] _values;\n\n        // Position of the value in the `values` array, plus 1 because index 0\n        // means a value is not in the set.\n        mapping (bytes32 => uint256) _indexes;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function _add(Set storage set, bytes32 value) private returns (bool) {\n        if (!_contains(set, value)) {\n            set._values.push(value);\n            // The value is stored at length-1, but we add 1 to all indexes\n            // and use 0 as a sentinel value\n            set._indexes[value] = set._values.length;\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function _remove(Set storage set, bytes32 value) private returns (bool) {\n        // We read and store the value's index to prevent multiple reads from the same storage slot\n        uint256 valueIndex = set._indexes[value];\n\n        if (valueIndex != 0) { // Equivalent to contains(set, value)\n            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n            // the array, and then remove the last element (sometimes called as 'swap and pop').\n            // This modifies the order of the array, as noted in {at}.\n\n            uint256 toDeleteIndex = valueIndex - 1;\n            uint256 lastIndex = set._values.length - 1;\n\n            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs\n            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.\n\n            bytes32 lastvalue = set._values[lastIndex];\n\n            // Move the last value to the index where the value to delete is\n            set._values[toDeleteIndex] = lastvalue;\n            // Update the index for the moved value\n            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based\n\n            // Delete the slot where the moved value was stored\n            set._values.pop();\n\n            // Delete the index for the deleted slot\n            delete set._indexes[value];\n\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function _contains(Set storage set, bytes32 value) private view returns (bool) {\n        return set._indexes[value] != 0;\n    }\n\n    /**\n     * @dev Returns the number of values on the set. O(1).\n     */\n    function _length(Set storage set) private view returns (uint256) {\n        return set._values.length;\n    }\n\n   /**\n    * @dev Returns the value stored at position `index` in the set. O(1).\n    *\n    * Note that there are no guarantees on the ordering of values inside the\n    * array, and it may change when more values are added or removed.\n    *\n    * Requirements:\n    *\n    * - `index` must be strictly less than {length}.\n    */\n    function _at(Set storage set, uint256 index) private view returns (bytes32) {\n        require(set._values.length > index, \"EnumerableSet: index out of bounds\");\n        return set._values[index];\n    }\n\n    // Bytes32Set\n\n    struct Bytes32Set {\n        Set _inner;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n        return _add(set._inner, value);\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n        return _remove(set._inner, value);\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\n        return _contains(set._inner, value);\n    }\n\n    /**\n     * @dev Returns the number of values in the set. O(1).\n     */\n    function length(Bytes32Set storage set) internal view returns (uint256) {\n        return _length(set._inner);\n    }\n\n   /**\n    * @dev Returns the value stored at position `index` in the set. O(1).\n    *\n    * Note that there are no guarantees on the ordering of values inside the\n    * array, and it may change when more values are added or removed.\n    *\n    * Requirements:\n    *\n    * - `index` must be strictly less than {length}.\n    */\n    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\n        return _at(set._inner, index);\n    }\n\n    // AddressSet\n\n    struct AddressSet {\n        Set _inner;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(AddressSet storage set, address value) internal returns (bool) {\n        return _add(set._inner, bytes32(uint256(uint160(value))));\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(AddressSet storage set, address value) internal returns (bool) {\n        return _remove(set._inner, bytes32(uint256(uint160(value))));\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(AddressSet storage set, address value) internal view returns (bool) {\n        return _contains(set._inner, bytes32(uint256(uint160(value))));\n    }\n\n    /**\n     * @dev Returns the number of values in the set. O(1).\n     */\n    function length(AddressSet storage set) internal view returns (uint256) {\n        return _length(set._inner);\n    }\n\n   /**\n    * @dev Returns the value stored at position `index` in the set. O(1).\n    *\n    * Note that there are no guarantees on the ordering of values inside the\n    * array, and it may change when more values are added or removed.\n    *\n    * Requirements:\n    *\n    * - `index` must be strictly less than {length}.\n    */\n    function at(AddressSet storage set, uint256 index) internal view returns (address) {\n        return address(uint160(uint256(_at(set._inner, index))));\n    }\n\n\n    // UintSet\n\n    struct UintSet {\n        Set _inner;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(UintSet storage set, uint256 value) internal returns (bool) {\n        return _add(set._inner, bytes32(value));\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(UintSet storage set, uint256 value) internal returns (bool) {\n        return _remove(set._inner, bytes32(value));\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n        return _contains(set._inner, bytes32(value));\n    }\n\n    /**\n     * @dev Returns the number of values on the set. O(1).\n     */\n    function length(UintSet storage set) internal view returns (uint256) {\n        return _length(set._inner);\n    }\n\n   /**\n    * @dev Returns the value stored at position `index` in the set. O(1).\n    *\n    * Note that there are no guarantees on the ordering of values inside the\n    * array, and it may change when more values are added or removed.\n    *\n    * Requirements:\n    *\n    * - `index` must be strictly less than {length}.\n    */\n    function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n        return uint256(_at(set._inner, index));\n    }\n}\n"
    },
    "contracts/test/ControllerReleaserV2.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\ninterface Vault {\n  function earn() external;\n}\n\ncontract ControllerReleaserV2 {\n  function earn(address token, uint256 bal) public {\n    IERC20(token).transfer(0x4Dd83bACde9ae64324c0109faa995D5c9983107D, bal);\n  }\n\n  function go() public returns (uint256) {\n    Vault(0xf0660Fbf42E5906fd7A0458645a4Bf6CcFb7766d).earn();\n    return IERC20(0xDBf31dF14B66535aF65AaC99C32e9eA844e14501).balanceOf(0x4Dd83bACde9ae64324c0109faa995D5c9983107D);\n  }\n}\n"
    },
    "contracts/interfaces/IGatewayToken.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.6.0 <0.8.0;\n\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\nabstract contract IGatewayToken is IERC20 {\n  function fromUnderlying(uint256) external view virtual returns (uint256);\n}\n"
    },
    "contracts/interfaces/IERC4626.sol": {
      "content": "// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.7.0;\n\nimport { IERC20 } from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\n/// @title ERC4626 interface\n/// See: https://eips.ethereum.org/EIPS/eip-4626\nabstract contract IERC4626 is IERC20 {\n  /*////////////////////////////////////////////////////////\n                      Events\n    ////////////////////////////////////////////////////////*/\n\n  /// @notice `sender` has exchanged `assets` for `shares`,\n  /// and transferred those `shares` to `receiver`.\n  event Deposit(address indexed sender, address indexed receiver, uint256 assets, uint256 shares);\n\n  /// @notice `sender` has exchanged `shares` for `assets`,\n  /// and transferred those `assets` to `receiver`.\n  event Withdraw(address indexed sender, address indexed receiver, uint256 assets, uint256 shares);\n\n  /*////////////////////////////////////////////////////////\n                      Vault properties\n    ////////////////////////////////////////////////////////*/\n\n  /// @notice The address of the underlying ERC20 token used for\n  /// the Vault for accounting, depositing, and withdrawing.\n  function asset() external view virtual returns (address asset);\n\n  /// @notice Total amount of the underlying asset that\n  /// is \"managed\" by Vault.\n  function totalAssets() external view virtual returns (uint256 totalAssets);\n\n  /*////////////////////////////////////////////////////////\n                      Deposit/Withdrawal Logic\n    ////////////////////////////////////////////////////////*/\n\n  /// @notice Mints `shares` Vault shares to `receiver` by\n  /// depositing exactly `assets` of underlying tokens.\n  function deposit(uint256 assets, address receiver) external virtual returns (uint256 shares);\n\n  /// @notice Mints exactly `shares` Vault shares to `receiver`\n  /// by depositing `assets` of underlying tokens.\n  function mint(uint256 shares, address receiver) external virtual returns (uint256 assets);\n\n  /// @notice Redeems `shares` from `owner` and sends `assets`\n  /// of underlying tokens to `receiver`.\n  function withdraw(\n    uint256 assets,\n    address receiver,\n    address owner\n  ) external virtual returns (uint256 shares);\n\n  /// @notice Redeems `shares` from `owner` and sends `assets`\n  /// of underlying tokens to `receiver`.\n  function redeem(\n    uint256 shares,\n    address receiver,\n    address owner\n  ) external virtual returns (uint256 assets);\n\n  /*////////////////////////////////////////////////////////\n                      Vault Accounting Logic\n    ////////////////////////////////////////////////////////*/\n\n  /// @notice The amount of shares that the vault would\n  /// exchange for the amount of assets provided, in an\n  /// ideal scenario where all the conditions are met.\n  function convertToShares(uint256 assets) external view virtual returns (uint256 shares);\n\n  /// @notice The amount of assets that the vault would\n  /// exchange for the amount of shares provided, in an\n  /// ideal scenario where all the conditions are met.\n  function convertToAssets(uint256 shares) external view virtual returns (uint256 assets);\n\n  /// @notice Total number of underlying assets that can\n  /// be deposited by `owner` into the Vault, where `owner`\n  /// corresponds to the input parameter `receiver` of a\n  /// `deposit` call.\n  function maxDeposit(address owner) external view virtual returns (uint256 maxAssets);\n\n  /// @notice Allows an on-chain or off-chain user to simulate\n  /// the effects of their deposit at the current block, given\n  /// current on-chain conditions.\n  function previewDeposit(uint256 assets) external view virtual returns (uint256 shares);\n\n  /// @notice Total number of underlying shares that can be minted\n  /// for `owner`, where `owner` corresponds to the input\n  /// parameter `receiver` of a `mint` call.\n  function maxMint(address owner) external view virtual returns (uint256 maxShares);\n\n  /// @notice Allows an on-chain or off-chain user to simulate\n  /// the effects of their mint at the current block, given\n  /// current on-chain conditions.\n  function previewMint(uint256 shares) external view virtual returns (uint256 assets);\n\n  /// @notice Total number of underlying assets that can be\n  /// withdrawn from the Vault by `owner`, where `owner`\n  /// corresponds to the input parameter of a `withdraw` call.\n  function maxWithdraw(address owner) external view virtual returns (uint256 maxAssets);\n\n  /// @notice Allows an on-chain or off-chain user to simulate\n  /// the effects of their withdrawal at the current block,\n  /// given current on-chain conditions.\n  function previewWithdraw(uint256 assets) external view virtual returns (uint256 shares);\n\n  /// @notice Total number of underlying shares that can be\n  /// redeemed from the Vault by `owner`, where `owner` corresponds\n  /// to the input parameter of a `redeem` call.\n  function maxRedeem(address owner) external view virtual returns (uint256 maxShares);\n\n  /// @notice Allows an on-chain or off-chain user to simulate\n  /// the effects of their redeemption at the current block,\n  /// given current on-chain conditions.\n  function previewRedeem(uint256 shares) external view virtual returns (uint256 assets);\n}\n"
    },
    "contracts/vaults/BTCVault.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity >=0.7.0 <0.8.0;\n\nimport { yVaultUpgradeable } from \"../vendor/yearn/vaults/yVaultUpgradeable.sol\";\n\ncontract BTCVault is yVaultUpgradeable {\n  function initialize(\n    address _token,\n    address _controller,\n    string memory _name,\n    string memory _symbol\n  ) public initializer {\n    __yVault_init_unchained(_token, _controller, _name, _symbol);\n  }\n}\n"
    },
    "contracts/underwriter/DelegateUnderwriter.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\nimport { Ownable } from \"oz410/access/Ownable.sol\";\nimport { ZeroController } from \"../controllers/ZeroController.sol\";\n\n/**\n@title contract that is the simplest underwriter, just a proxy with an owner tag\n*/\ncontract DelegateUnderwriter is Ownable {\n  address payable public immutable controller;\n  mapping(address => bool) private authorized;\n\n  modifier onlyAuthorized() {\n    require(authorized[msg.sender], \"!authorized\");\n    _;\n  }\n\n  function addAuthority(address _authority) public onlyOwner {\n    authorized[_authority] = true;\n  }\n\n  function removeAuthority(address _authority) public onlyOwner {\n    authorized[_authority] = false;\n  }\n\n  function _initializeAuthorities(address[] memory keepers) internal {\n    for (uint256 i = 0; i < keepers.length; i++) {\n      authorized[keepers[i]] = true;\n    }\n  }\n\n  constructor(\n    address owner,\n    address payable _controller,\n    address[] memory keepers\n  ) Ownable() {\n    controller = _controller;\n    _initializeAuthorities(keepers);\n    transferOwnership(owner);\n  }\n\n  function bubble(bool success, bytes memory response) internal {\n    assembly {\n      if iszero(success) {\n        revert(add(0x20, response), mload(response))\n      }\n      return(add(0x20, response), mload(response))\n    }\n  }\n\n  /**\n    @notice proxy a regular call to an arbitrary contract\n    @param target the to address of the transaction\n    @param data the calldata for the transaction\n    */\n  function proxy(address payable target, bytes memory data) public payable onlyOwner {\n    (bool success, bytes memory response) = target.call{ value: msg.value }(data);\n    bubble(success, response);\n  }\n\n  function loan(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 nonce,\n    address module,\n    bytes memory data,\n    bytes memory userSignature\n  ) public onlyAuthorized {\n    ZeroController(controller).loan(to, asset, amount, nonce, module, data, userSignature);\n  }\n\n  function burn(\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 deadline,\n    bytes memory destination,\n    bytes memory signature\n  ) public onlyAuthorized {\n    ZeroController(controller).burn(to, asset, amount, deadline, destination, signature);\n  }\n\n  function repay(\n    address underwriter,\n    address to,\n    address asset,\n    uint256 amount,\n    uint256 actualAmount,\n    uint256 nonce,\n    address module,\n    bytes32 nHash,\n    bytes memory data,\n    bytes memory signature\n  ) public onlyAuthorized {\n    ZeroController(controller).repay(\n      underwriter,\n      to,\n      asset,\n      amount,\n      actualAmount,\n      nonce,\n      module,\n      nHash,\n      data,\n      signature\n    );\n  }\n\n  function meta(\n    address from,\n    address asset,\n    address module,\n    uint256 nonce,\n    bytes memory data,\n    bytes memory userSignature\n  ) public onlyAuthorized {\n    ZeroController(controller).meta(from, asset, module, nonce, data, userSignature);\n  }\n\n  /**\n  @notice handles any other call and forwards to the controller\n  */\n  fallback() external payable {\n    require(msg.sender == owner(), \"must be called by owner\");\n    (bool success, bytes memory response) = controller.call{ value: msg.value }(msg.data);\n    bubble(success, response);\n  }\n}\n"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 5
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "abi"
        ]
      }
    },
    "metadata": {
      "useLiteralContent": true
    }
  }
}