Contract

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2;

interface IERC20 {
  function totalSupply() external view returns (uint);

  function balanceOf(address account) external view returns (uint);

  function transfer(address recipient, uint amount) external returns (bool);

  function allowance(address owner, address spender) external view returns (uint);

  function approve(address spender, uint amount) external returns (bool);

  function transferFrom(address sender, address recipient, uint amount) external returns (bool);

  function symbol() external view returns (string memory);

  event Transfer(address indexed from, address indexed to, uint value);
  event Approval(address indexed owner, address indexed spender, uint value);

  function decimals() external view returns (uint8);

  function name() external view returns (string memory);
}

// SPDX-License-Identifier:	MIT
pragma solidity ^0.8.18;

import {AbstractRouter} from "./abstract/AbstractRouter.sol";

/// @title Minimalistic Mangrove Router Proxy
/// @notice A proxy contract that delegates calls to an instance of an AbstractRouter contract.
///         It does not allow updates of implementation contract.
/// @dev it assumes the IMPLEMENTATION uses first storage slot to hold the admin address (this is guaranteed as long as `AbstractRouter` is `AccessControlled`)
contract RouterProxy {
  /// @notice The address of the deployed SmartRouter contract acting as the delegate implementation.
  /// @dev The SmartRouter instance must be AccessControlled to ensure the storage layout is matched.
  AbstractRouter public immutable IMPLEMENTATION;

  /// @notice Emitted when the admin of the proxy is set.
  /// * This is a copy of the AccessControlled event to set without calling the implementation.
  /// @param admin The address of the admin of the proxy.
  event SetAdmin(address admin);

  /// @notice Deploys a Proxy for the SmartRouter that handles incoming transactions and delegates them to the implementation.
  /// @param implementation The address of the deployed SmartRouter contract to which calls will be delegated.
  /// @dev Initializes the contract with an AccessControlled base to set up access control.
  constructor(AbstractRouter implementation) {
    IMPLEMENTATION = implementation;
    // store the msg sender at address 0 (_admin storage slot on access controlled)
    assembly {
      sstore(0, caller())
    }
    emit SetAdmin(msg.sender);
  }

  /// @notice Fallback function to delegate calls to the implementation contract.
  fallback() external {
    AbstractRouter implementation = IMPLEMENTATION;
    assembly {
      // Copy msg.data. We take full control of memory in this inline assembly
      // block because it will not return to Solidity code. We overwrite the
      // Solidity scratch pad at memory position 0.
      calldatacopy(0, 0, calldatasize())

      // Call the implementation.
      // out and outsize are 0 because we don't know the size yet.
      let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

      // Copy the returned data.
      returndatacopy(0, 0, returndatasize())

      switch result
      // delegatecall returns 0 on error.
      case 0 { revert(0, returndatasize()) }
      default { return(0, returndatasize()) }
    }
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {AccessControlled} from "@mgv-strats/src/strategies/utils/AccessControlled.sol";
import {RoutingOrderLib as RL} from "./RoutingOrderLib.sol";

/// @title AbstractRouter
/// @notice Partial implementation and requirements for liquidity routers.

abstract contract AbstractRouter is AccessControlled(msg.sender) {
  ///@notice This modifier verifies that `msg.sender` an allowed caller of this router.
  modifier onlyBound() {
    require(isBound(msg.sender), "AccessControlled/Invalid");
    _;
  }

  ///@notice This modifier verifies that `msg.sender` is the admin or an allowed caller of this router.
  modifier boundOrAdmin() {
    require(msg.sender == admin() || isBound(msg.sender), "AccessControlled/Invalid");
    _;
  }

  ///@notice logging bound maker contract
  ///@param maker the maker address. This is indexed, so that RPC calls can filter on it.
  ///@notice by emitting this data, an indexer will be able to keep track of what maker contracts are allowed to call this router.
  event MakerBind(address indexed maker);

  ///@notice logging unbound maker contract
  ///@param maker the maker address. This is indexed, so that RPC calls can filter on it.
  ///@notice by emitting this data, an indexer will be able to keep track of what maker contracts are allowed to call this router.
  event MakerUnbind(address indexed maker);

  ///@notice getter for the `makers: addr => bool` mapping
  ///@param mkr the address of a maker contract
  ///@return true if `mkr` is authorized to call this router.
  function isBound(address mkr) public view virtual returns (bool) {
    return RL.boundMakerContracts()[mkr];
  }

  ///@notice pulls liquidity from the reserve and sends it to the calling maker contract.
  ///@param routingOrder the arguments of the pull order
  ///@param amount of token that needs to be routed
  ///@param strict if false the router may pull at more than `amount` to msg.sender. Otherwise it pulls at least `amount`.
  ///@return pulled the amount of `routingOrder.token` that has been sent to `msg.sender`
  function pull(RL.RoutingOrder calldata routingOrder, uint amount, bool strict)
    external
    onlyBound
    returns (uint pulled)
  {
    if (strict && amount == 0) {
      return 0;
    }
    pulled = __pull__(routingOrder, amount, strict);
  }

  ///@notice router dependent hook to customize pull orders.
  ///@param routingOrder the arguments of the pull order
  ///@param amount of token that needs to be routed
  ///@param strict if false the router may pull at more than `amount` to msg.sender. Otherwise it pulls at least `amount`.
  ///@return pulled the amount of `routingOrder.token` that has been sent to `msg.sender`
  function __pull__(RL.RoutingOrder memory routingOrder, uint amount, bool strict) internal virtual returns (uint);

  ///@notice pushes liquidity from msg.sender to the reserve
  ///@param routingOrder the arguments of the push order
  ///@param amount of token that needs to be routed
  ///@return pushed the amount of `routingOrder.token` that has been taken from `msg.sender`
  function push(RL.RoutingOrder calldata routingOrder, uint amount) external onlyBound returns (uint pushed) {
    if (amount == 0) {
      return 0;
    }
    pushed = __push__(routingOrder, amount);
  }

  ///@notice router dependent hook to customize pull orders.
  ///@param routingOrder the arguments of the pull order
  ///@param amount of token that needs to be routed
  ///@return pushed the amount of `routingOrder.token` that has been sent to `msg.sender`
  function __push__(RL.RoutingOrder memory routingOrder, uint amount) internal virtual returns (uint pushed);

  ///@notice iterative `push` of the whole maker contract's balance
  ///@dev minimizes external calls in case several assets needs to be pushed via the router.
  ///@param routingOrders to be executed
  function flush(RL.RoutingOrder[] memory routingOrders) external onlyBound {
    for (uint i = 0; i < routingOrders.length; ++i) {
      uint amount = routingOrders[i].token.balanceOf(msg.sender);
      if (amount > 0) {
        require(__push__(routingOrders[i], amount) == amount, "router/flushFailed");
      }
    }
  }

  ///@notice adds a maker contract address to the allowed makers of this router
  ///@dev this function is callable by router's admin to bootstrap, but later on an allowed maker contract can add another address
  ///@param makerContract the maker contract address
  function bind(address makerContract) public onlyAdmin {
    RL.boundMakerContracts()[makerContract] = true;
    emit MakerBind(makerContract);
  }

  ///@notice removes a maker contract address from the allowed makers of this router
  ///@param makerContract the maker contract address
  function _unbind(address makerContract) internal {
    RL.boundMakerContracts()[makerContract] = false;
    emit MakerUnbind(makerContract);
  }

  ///@notice removes `msg.sender` from the allowed makers of this router
  function unbind() external onlyBound {
    _unbind(msg.sender);
  }

  ///@notice removes a makerContract from the allowed makers of this router
  ///@param makerContract the maker contract address
  function unbind(address makerContract) external onlyAdmin {
    _unbind(makerContract);
  }

  /**
   * @notice Returns the token balance available for a specific routing order
   * @param routingOrder The routing order to check the balance for
   * @return balance The balance of the token in the routing order
   */
  function tokenBalanceOf(RL.RoutingOrder calldata routingOrder) public view virtual returns (uint balance);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {IERC20} from "@mgv/lib/IERC20.sol";

/// @title Library to obtain Routing orders of various kind

library RoutingOrderLib {
  ///@notice pointer to first storage slot used for randomized access
  bytes32 private constant OFFSET = keccak256("MangroveStrats.RoutingOrderLib.Layout");

  ///@notice Argument to pull/push
  ///@param token the asset to be routed
  ///@param olKeyHash the id of the market that triggered the calling offer logic. Is bytes32(0) when routing is done outside offer logic.
  ///@param offerId the id of the offer that triggered the calling offer logic. Is uint(0) when routing is done outsider offer logic.
  ///@param fundOwner the owner of the routed funds. If calling router is a proxy, it address is determined by `fundOwner`.
  struct RoutingOrder {
    IERC20 token;
    bytes32 olKeyHash;
    uint offerId;
    address fundOwner;
  }

  ///@notice helper to create a RoutingOrder struct without zero'ed fields for market coordinates.
  ///@param token the asset to be routed
  ///@param fundOwner the owner of the routed funds
  ///@return ro the routing order struct
  function createOrder(IERC20 token, address fundOwner) internal pure returns (RoutingOrder memory ro) {
    ro.token = token;
    ro.fundOwner = fundOwner;
  }

  ///@notice the bound maker contracts which are allowed to call this router.
  struct Layout {
    mapping(address => bool) boundMakerContracts;
  }

  ///@notice allowed pullers/pushers for this router
  ///@return bound contracts to this router, in the form of a storage mapping
  function boundMakerContracts() internal view returns (mapping(address => bool) storage) {
    bytes32 offset = OFFSET;
    Layout storage st;
    assembly ("memory-safe") {
      st.slot := offset
    }
    return st.boundMakerContracts;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

/// @title This contract is used to restrict access to privileged functions of inheriting contracts through modifiers.
/// @notice The contract stores an admin address which is checked against `msg.sender` in the `onlyAdmin` modifier.
/// @notice Additionally, a specific `msg.sender` can be verified with the `onlyCaller` modifier.
contract AccessControlled {
  /**
   * @notice logs new `admin` of `this`
   * @param admin The new admin.
   * @notice By emitting this data, an indexer will be able to keep track of what address is the admin of this contract.
   */
  event SetAdmin(address admin);
  /**
   * @notice The admin address.
   */

  address internal _admin;

  /**
   * @notice `AccessControlled`'s constructor
   * @param admin_ The address of the admin that can access privileged functions and also allowed to change the admin. Cannot be `address(0)`.
   */
  constructor(address admin_) {
    _setAdmin(admin_);
  }

  /**
   * @notice This modifier verifies that `msg.sender` is the admin.
   */
  modifier onlyAdmin() {
    require(msg.sender == _admin, "AccessControlled/Invalid");
    _;
  }

  /**
   * @notice This modifier verifies that `msg.sender` is the caller.
   * @param caller The address of the caller that can access the modified function.
   */
  modifier onlyCaller(address caller) {
    require(msg.sender == caller, "AccessControlled/Invalid");
    _;
  }

  /**
   * @notice This modifier verifies that `msg.sender` is either caller or the admin
   * @param caller The address of a caller that can access the modified function.
   */
  modifier adminOrCaller(address caller) {
    // test _admin second to save a storage read when possible
    require(msg.sender == caller || msg.sender == _admin, "AccessControlled/Invalid");
    _;
  }

  /**
   * @notice Retrieves the current admin.
   * @return current admin.
   */
  function admin() public view returns (address current) {
    return _admin;
  }

  /**
   * @notice This function is called to add logic on admin change for inheriting contracts.
   * @param admin_ The new admin. Cannot be `address(0)`.
   */
  function _onAdminChange(address admin_) internal virtual {}

  /**
   * @notice This sets and log a new admin
   * @param admin_ The new admin. Cannot be `address(0)`.
   */
  function _setAdmin(address admin_) internal {
    require(admin_ != address(0), "AccessControlled/0xAdmin");
    _admin = admin_;
    emit SetAdmin(admin_);
    _onAdminChange(admin_);
  }

  /**
   * @notice This sets the admin. Only the current admin can change the admin.
   * @param admin_ The new admin. Cannot be `address(0)`.
   */
  function setAdmin(address admin_) external onlyAdmin {
    _setAdmin(admin_);
  }
}