Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

/**
 * @dev OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
 * From https://github.com/OpenZeppelin/openzeppelin-contracts/tree/8b778fa20d6d76340c5fac1ed66c80273f05b95a
 *
 * BGD Labs adaptations:
 * - Linting
 */

pragma solidity ^0.8.0;

import './ERC1967Proxy.sol';

/**
 * @dev This contract implements a proxy that is upgradeable by an admin.
 *
 * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
 * clashing], which can potentially be used in an attack, this contract uses the
 * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
 * things that go hand in hand:
 *
 * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
 * that call matches one of the admin functions exposed by the proxy itself.
 * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
 * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
 * "admin cannot fallback to proxy target".
 *
 * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
 * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
 * to sudden errors when trying to call a function from the proxy implementation.
 *
 * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
 * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
 */
contract TransparentUpgradeableProxy is ERC1967Proxy {
  /**
   * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
   * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
   */
  constructor(
    address _logic,
    address admin_,
    bytes memory _data
  ) payable ERC1967Proxy(_logic, _data) {
    _changeAdmin(admin_);
  }

  /**
   * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
   */
  modifier ifAdmin() {
    if (msg.sender == _getAdmin()) {
      _;
    } else {
      _fallback();
    }
  }

  /**
   * @dev Returns the current admin.
   *
   * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
   *
   * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
   * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
   * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
   */
  function admin() external ifAdmin returns (address admin_) {
    admin_ = _getAdmin();
  }

  /**
   * @dev Returns the current implementation.
   *
   * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
   *
   * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
   * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
   * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
   */
  function implementation() external ifAdmin returns (address implementation_) {
    implementation_ = _implementation();
  }

  /**
   * @dev Changes the admin of the proxy.
   *
   * Emits an {AdminChanged} event.
   *
   * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.
   */
  function changeAdmin(address newAdmin) external virtual ifAdmin {
    _changeAdmin(newAdmin);
  }

  /**
   * @dev Upgrade the implementation of the proxy.
   *
   * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
   */
  function upgradeTo(address newImplementation) external ifAdmin {
    _upgradeToAndCall(newImplementation, bytes(''), false);
  }

  /**
   * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
   * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
   * proxied contract.
   *
   * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
   */
  function upgradeToAndCall(
    address newImplementation,
    bytes calldata data
  ) external payable ifAdmin {
    _upgradeToAndCall(newImplementation, data, true);
  }

  /**
   * @dev Returns the current admin.
   */
  function _admin() internal view virtual returns (address) {
    return _getAdmin();
  }

  /**
   * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
   */
  function _beforeFallback() internal virtual override {
    require(
      msg.sender != _getAdmin(),
      'TransparentUpgradeableProxy: admin cannot fallback to proxy target'
    );
    super._beforeFallback();
  }
}

// SPDX-License-Identifier: MIT

/** @dev OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
 * From https://github.com/OpenZeppelin/openzeppelin-contracts/tree/8b778fa20d6d76340c5fac1ed66c80273f05b95a
 *
 * BGD Labs adaptations:
 * - Same exact version as OZ, only linting changes
 */

pragma solidity ^0.8.0;

import './Proxy.sol';
import './ERC1967Upgrade.sol';

/**
 * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
 * implementation address that can be changed. This address is stored in storage in the location specified by
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
 * implementation behind the proxy.
 */
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
  /**
   * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
   *
   * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
   * function call, and allows initializing the storage of the proxy like a Solidity constructor.
   */
  constructor(address _logic, bytes memory _data) payable {
    _upgradeToAndCall(_logic, _data, false);
  }

  /**
   * @dev Returns the current implementation address.
   */
  function _implementation() internal view virtual override returns (address impl) {
    return ERC1967Upgrade._getImplementation();
  }
}

// SPDX-License-Identifier: MIT

/**
 * @dev OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
 * From https://github.com/OpenZeppelin/openzeppelin-contracts/tree/8b778fa20d6d76340c5fac1ed66c80273f05b95a
 *
 * BGD Labs adaptations:
 * - Linting
 */
pragma solidity ^0.8.0;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 *
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 *
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
  /**
   * @dev Delegates the current call to `implementation`.
   *
   * This function does not return to its internal call site, it will return directly to the external caller.
   */
  function _delegate(address implementation) internal virtual {
    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())
      }
    }
  }

  /**
   * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
   * and {_fallback} should delegate.
   */
  function _implementation() internal view virtual returns (address);

  /**
   * @dev Delegates the current call to the address returned by `_implementation()`.
   *
   * This function does not return to its internal call site, it will return directly to the external caller.
   */
  function _fallback() internal virtual {
    _beforeFallback();
    _delegate(_implementation());
  }

  /**
   * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
   * function in the contract matches the call data.
   */
  fallback() external payable virtual {
    _fallback();
  }

  /**
   * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
   * is empty.
   */
  receive() external payable virtual {
    _fallback();
  }

  /**
   * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
   * call, or as part of the Solidity `fallback` or `receive` functions.
   *
   * If overridden should call `super._beforeFallback()`.
   */
  function _beforeFallback() internal virtual {}
}

// SPDX-License-Identifier: MIT

/** @dev OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
 * From https://github.com/OpenZeppelin/openzeppelin-contracts/tree/8b778fa20d6d76340c5fac1ed66c80273f05b95a
 *
 * BGD Labs adaptations:
 * - This is an opinionated version, to be used on "classic" transparent upgradeable proxies (non UUPS/Beacon)
 * - For the sake of simplification and gas savings on deployment, the functions/constants related with UUPS/Beacon have been removed
 * - Moved declaration of `_ADMIN_SLOT` constant and `AdminChanged` event to the top
 * - Linting
 * - Removed imports not used anymore due to not have UUPS/Beacon logic
 */

pragma solidity ^0.8.2;

import '../oz-common/Address.sol';
import '../oz-common/StorageSlot.sol';

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 *
 * @custom:oz-upgrades-unsafe-allow delegatecall
 */
abstract contract ERC1967Upgrade {
  /**
   * @dev Storage slot with the address of the current implementation.
   * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
   * validated in the constructor.
   */
  bytes32 internal constant _IMPLEMENTATION_SLOT =
    0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

  /**
   * @dev Storage slot with the admin of the contract.
   * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
   * validated in the constructor.
   */
  bytes32 internal constant _ADMIN_SLOT =
    0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

  /**
   * @dev Emitted when the implementation is upgraded.
   */
  event Upgraded(address indexed implementation);

  /**
   * @dev Emitted when the admin account has changed.
   */
  event AdminChanged(address previousAdmin, address newAdmin);

  /**
   * @dev Returns the current implementation address.
   */
  function _getImplementation() internal view returns (address) {
    return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
  }

  /**
   * @dev Stores a new address in the EIP1967 implementation slot.
   */
  function _setImplementation(address newImplementation) private {
    require(Address.isContract(newImplementation), 'ERC1967: new implementation is not a contract');
    StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
  }

  /**
   * @dev Perform implementation upgrade
   *
   * Emits an {Upgraded} event.
   */
  function _upgradeTo(address newImplementation) internal {
    _setImplementation(newImplementation);
    emit Upgraded(newImplementation);
  }

  /**
   * @dev Perform implementation upgrade with additional setup call.
   *
   * Emits an {Upgraded} event.
   */
  function _upgradeToAndCall(
    address newImplementation,
    bytes memory data,
    bool forceCall
  ) internal {
    _upgradeTo(newImplementation);
    if (data.length > 0 || forceCall) {
      Address.functionDelegateCall(newImplementation, data);
    }
  }

  /**
   * @dev Returns the current admin.
   */
  function _getAdmin() internal view returns (address) {
    return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
  }

  /**
   * @dev Stores a new address in the EIP1967 admin slot.
   */
  function _setAdmin(address newAdmin) private {
    require(newAdmin != address(0), 'ERC1967: new admin is the zero address');
    StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
  }

  /**
   * @dev Changes the admin of the proxy.
   *
   * Emits an {AdminChanged} event.
   */
  function _changeAdmin(address newAdmin) internal {
    emit AdminChanged(_getAdmin(), newAdmin);
    _setAdmin(newAdmin);
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
// From commit https://github.com/OpenZeppelin/openzeppelin-contracts/commit/8b778fa20d6d76340c5fac1ed66c80273f05b95a

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
  /**
   * @dev Returns true if `account` is a contract.
   *
   * [IMPORTANT]
   * ====
   * It is unsafe to assume that an address for which this function returns
   * false is an externally-owned account (EOA) and not a contract.
   *
   * Among others, `isContract` will return false for the following
   * types of addresses:
   *
   *  - an externally-owned account
   *  - a contract in construction
   *  - an address where a contract will be created
   *  - an address where a contract lived, but was destroyed
   * ====
   *
   * [IMPORTANT]
   * ====
   * You shouldn't rely on `isContract` to protect against flash loan attacks!
   *
   * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
   * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
   * constructor.
   * ====
   */
  function isContract(address account) internal view returns (bool) {
    // This method relies on extcodesize/address.code.length, which returns 0
    // for contracts in construction, since the code is only stored at the end
    // of the constructor execution.

    return account.code.length > 0;
  }

  /**
   * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
   * `recipient`, forwarding all available gas and reverting on errors.
   *
   * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
   * of certain opcodes, possibly making contracts go over the 2300 gas limit
   * imposed by `transfer`, making them unable to receive funds via
   * `transfer`. {sendValue} removes this limitation.
   *
   * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
   *
   * IMPORTANT: because control is transferred to `recipient`, care must be
   * taken to not create reentrancy vulnerabilities. Consider using
   * {ReentrancyGuard} or the
   * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
   */
  function sendValue(address payable recipient, uint256 amount) internal {
    require(address(this).balance >= amount, 'Address: insufficient balance');

    (bool success, ) = recipient.call{value: amount}('');
    require(success, 'Address: unable to send value, recipient may have reverted');
  }

  /**
   * @dev Performs a Solidity function call using a low level `call`. A
   * plain `call` is an unsafe replacement for a function call: use this
   * function instead.
   *
   * If `target` reverts with a revert reason, it is bubbled up by this
   * function (like regular Solidity function calls).
   *
   * Returns the raw returned data. To convert to the expected return value,
   * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
   *
   * Requirements:
   *
   * - `target` must be a contract.
   * - calling `target` with `data` must not revert.
   *
   * _Available since v3.1._
   */
  function functionCall(address target, bytes memory data) internal returns (bytes memory) {
    return functionCallWithValue(target, data, 0, 'Address: low-level call failed');
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
   * `errorMessage` as a fallback revert reason when `target` reverts.
   *
   * _Available since v3.1._
   */
  function functionCall(
    address target,
    bytes memory data,
    string memory errorMessage
  ) internal returns (bytes memory) {
    return functionCallWithValue(target, data, 0, errorMessage);
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
   * but also transferring `value` wei to `target`.
   *
   * Requirements:
   *
   * - the calling contract must have an ETH balance of at least `value`.
   * - the called Solidity function must be `payable`.
   *
   * _Available since v3.1._
   */
  function functionCallWithValue(
    address target,
    bytes memory data,
    uint256 value
  ) internal returns (bytes memory) {
    return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
  }

  /**
   * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
   * with `errorMessage` as a fallback revert reason when `target` reverts.
   *
   * _Available since v3.1._
   */
  function functionCallWithValue(
    address target,
    bytes memory data,
    uint256 value,
    string memory errorMessage
  ) internal returns (bytes memory) {
    require(address(this).balance >= value, 'Address: insufficient balance for call');
    (bool success, bytes memory returndata) = target.call{value: value}(data);
    return verifyCallResultFromTarget(target, success, returndata, errorMessage);
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
   * but performing a static call.
   *
   * _Available since v3.3._
   */
  function functionStaticCall(
    address target,
    bytes memory data
  ) internal view returns (bytes memory) {
    return functionStaticCall(target, data, 'Address: low-level static call failed');
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
   * but performing a static call.
   *
   * _Available since v3.3._
   */
  function functionStaticCall(
    address target,
    bytes memory data,
    string memory errorMessage
  ) internal view returns (bytes memory) {
    (bool success, bytes memory returndata) = target.staticcall(data);
    return verifyCallResultFromTarget(target, success, returndata, errorMessage);
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
   * but performing a delegate call.
   *
   * _Available since v3.4._
   */
  function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
    return functionDelegateCall(target, data, 'Address: low-level delegate call failed');
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
   * but performing a delegate call.
   *
   * _Available since v3.4._
   */
  function functionDelegateCall(
    address target,
    bytes memory data,
    string memory errorMessage
  ) internal returns (bytes memory) {
    (bool success, bytes memory returndata) = target.delegatecall(data);
    return verifyCallResultFromTarget(target, success, returndata, errorMessage);
  }

  /**
   * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
   * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
   *
   * _Available since v4.8._
   */
  function verifyCallResultFromTarget(
    address target,
    bool success,
    bytes memory returndata,
    string memory errorMessage
  ) internal view returns (bytes memory) {
    if (success) {
      if (returndata.length == 0) {
        // only check isContract if the call was successful and the return data is empty
        // otherwise we already know that it was a contract
        require(isContract(target), 'Address: call to non-contract');
      }
      return returndata;
    } else {
      _revert(returndata, errorMessage);
    }
  }

  /**
   * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
   * revert reason or using the provided one.
   *
   * _Available since v4.3._
   */
  function verifyCallResult(
    bool success,
    bytes memory returndata,
    string memory errorMessage
  ) internal pure returns (bytes memory) {
    if (success) {
      return returndata;
    } else {
      _revert(returndata, errorMessage);
    }
  }

  function _revert(bytes memory returndata, string memory errorMessage) private pure {
    // Look for revert reason and bubble it up if present
    if (returndata.length > 0) {
      // The easiest way to bubble the revert reason is using memory via assembly
      /// @solidity memory-safe-assembly
      assembly {
        let returndata_size := mload(returndata)
        revert(add(32, returndata), returndata_size)
      }
    } else {
      revert(errorMessage);
    }
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
// From commit https://github.com/OpenZeppelin/openzeppelin-contracts/commit/8b778fa20d6d76340c5fac1ed66c80273f05b95a

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlot {
  struct AddressSlot {
    address value;
  }

  struct BooleanSlot {
    bool value;
  }

  struct Bytes32Slot {
    bytes32 value;
  }

  struct Uint256Slot {
    uint256 value;
  }

  /**
   * @dev Returns an `AddressSlot` with member `value` located at `slot`.
   */
  function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
    /// @solidity memory-safe-assembly
    assembly {
      r.slot := slot
    }
  }

  /**
   * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
   */
  function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
    /// @solidity memory-safe-assembly
    assembly {
      r.slot := slot
    }
  }

  /**
   * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
   */
  function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
    /// @solidity memory-safe-assembly
    assembly {
      r.slot := slot
    }
  }

  /**
   * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
   */
  function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
    /// @solidity memory-safe-assembly
    assembly {
      r.slot := slot
    }
  }
}

{
  "remappings": [
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "ds-test/=lib/aave-helpers/lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/aave-helpers/lib/forge-std/src/",
    "solidity-utils/=lib/aave-helpers/lib/solidity-utils/src/",
    "aave-address-book/=lib/aave-helpers/lib/aave-address-book/src/",
    "aave-helpers/=lib/aave-helpers/src/",
    "@aave/core-v3/=lib/aave-helpers/lib/aave-address-book/lib/aave-v3-core/",
    "aave-v3-core/=lib/aave-helpers/lib/aave-address-book/lib/aave-v3-core/",
    "aave-v3-periphery/=lib/aave-helpers/lib/aave-address-book/lib/aave-v3-periphery/",
    "@aave/periphery-v3/=lib/aave-helpers/lib/aave-address-book/lib/aave-v3-periphery/",
    "governance-crosschain-bridges/=lib/aave-helpers/lib/governance-crosschain-bridges/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"address","name":"admin_","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"admin_","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"changeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"implementation_","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

6080604052604051610d0a380380610d0a833981016040819052610022916103c3565b828161002f82825f610043565b5061003b90508261006e565b5050506104df565b61004c836100db565b5f825111806100585750805b1561006957610067838361011a565b505b505050565b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f6100ad5f516020610cc35f395f51905f52546001600160a01b031690565b604080516001600160a01b03928316815291841660208301520160405180910390a16100d881610146565b50565b6100e4816101e1565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b905f90a250565b606061013f8383604051806060016040528060278152602001610ce360279139610275565b9392505050565b6001600160a01b0381166101b05760405162461bcd60e51b815260206004820152602660248201527f455243313936373a206e65772061646d696e20697320746865207a65726f206160448201526564647265737360d01b60648201526084015b60405180910390fd5b805f516020610cc35f395f51905f525b80546001600160a01b0319166001600160a01b039290921691909117905550565b6001600160a01b0381163b61024e5760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b60648201526084016101a7565b807f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc6101c0565b60605f5f856001600160a01b0316856040516102919190610494565b5f60405180830381855af49150503d805f81146102c9576040519150601f19603f3d011682016040523d82523d5f602084013e6102ce565b606091505b5090925090506102e0868383876102ea565b9695505050505050565b606083156103585782515f03610351576001600160a01b0385163b6103515760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016101a7565b5081610362565b610362838361036a565b949350505050565b81511561037a5781518083602001fd5b8060405162461bcd60e51b81526004016101a791906104aa565b80516001600160a01b03811681146103aa575f5ffd5b919050565b634e487b7160e01b5f52604160045260245ffd5b5f5f5f606084860312156103d5575f5ffd5b6103de84610394565b92506103ec60208501610394565b60408501519092506001600160401b03811115610407575f5ffd5b8401601f81018613610417575f5ffd5b80516001600160401b03811115610430576104306103af565b604051601f8201601f19908116603f011681016001600160401b038111828210171561045e5761045e6103af565b604052818152828201602001881015610475575f5ffd5b8160208401602083015e5f602083830101528093505050509250925092565b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f83011684010191505092915050565b6107d7806104ec5f395ff3fe60806040526004361061004d575f3560e01c80633659cfe6146100645780634f1ef286146100835780635c60da1b146100965780638f283970146100c6578063f851a440146100e55761005c565b3661005c5761005a6100f9565b005b61005a6100f9565b34801561006f575f5ffd5b5061005a61007e366004610698565b610113565b61005a6100913660046106b1565b61014e565b3480156100a1575f5ffd5b506100aa6101b4565b6040516001600160a01b03909116815260200160405180910390f35b3480156100d1575f5ffd5b5061005a6100e0366004610698565b6101e4565b3480156100f0575f5ffd5b506100aa610204565b610101610224565b61011161010c6102b9565b6102c2565b565b61011b6102e0565b6001600160a01b03163303610146576101438160405180602001604052805f8152505f610312565b50565b6101436100f9565b6101566102e0565b6001600160a01b031633036101ac576101a78383838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525060019250610312915050565b505050565b6101a76100f9565b5f6101bd6102e0565b6001600160a01b031633036101d9576101d46102b9565b905090565b6101e16100f9565b90565b6101ec6102e0565b6001600160a01b03163303610146576101438161033c565b5f61020d6102e0565b6001600160a01b031633036101d9576101d46102e0565b61022c6102e0565b6001600160a01b031633036101115760405162461bcd60e51b815260206004820152604260248201527f5472616e73706172656e745570677261646561626c6550726f78793a2061646d60448201527f696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267606482015261195d60f21b608482015260a4015b60405180910390fd5b5f6101d4610390565b365f5f375f5f365f845af43d5f5f3e8080156102dc573d5ff35b3d5ffd5b5f7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035b546001600160a01b0316919050565b61031b836103b7565b5f825111806103275750805b156101a75761033683836103f6565b50505050565b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f6103656102e0565b604080516001600160a01b03928316815291841660208301520160405180910390a161014381610422565b5f7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc610303565b6103c0816104cb565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b905f90a250565b606061041b838360405180606001604052806027815260200161077b6027913961055f565b9392505050565b6001600160a01b0381166104875760405162461bcd60e51b815260206004820152602660248201527f455243313936373a206e65772061646d696e20697320746865207a65726f206160448201526564647265737360d01b60648201526084016102b0565b807fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035b80546001600160a01b0319166001600160a01b039290921691909117905550565b6001600160a01b0381163b6105385760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b60648201526084016102b0565b807f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc6104aa565b60605f5f856001600160a01b03168560405161057b919061072f565b5f60405180830381855af49150503d805f81146105b3576040519150601f19603f3d011682016040523d82523d5f602084013e6105b8565b606091505b50915091506105c9868383876105d3565b9695505050505050565b606083156106415782515f0361063a576001600160a01b0385163b61063a5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016102b0565b508161064b565b61064b8383610653565b949350505050565b8151156106635781518083602001fd5b8060405162461bcd60e51b81526004016102b09190610745565b80356001600160a01b0381168114610693575f5ffd5b919050565b5f602082840312156106a8575f5ffd5b61041b8261067d565b5f5f5f604084860312156106c3575f5ffd5b6106cc8461067d565b9250602084013567ffffffffffffffff8111156106e7575f5ffd5b8401601f810186136106f7575f5ffd5b803567ffffffffffffffff81111561070d575f5ffd5b86602082840101111561071e575f5ffd5b939660209190910195509293505050565b5f82518060208501845e5f920191825250919050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f8301168401019150509291505056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220da2623db5083841682ed889b9b075b24d52b3211a670598bad7b8dce63302e2664736f6c634300081c0033b53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c656400000000000000000000000003d56967c93d2e4a92e9c1607b857ba8bb7ada7a000000000000000000000000f28e4b60d751c2207c45faf1da6274bc4e85e9fa000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000e4906571470000000000000000000000006c56ddccb3726faa089a5e9e29b712525cf916d7000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000001d57726170706564204176616c6f6e204176616c6f6e20534f4c56425443000000000000000000000000000000000000000000000000000000000000000000000e7761536f6e6963534f4c5642544300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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

00000000000000000000000003d56967c93d2e4a92e9c1607b857ba8bb7ada7a000000000000000000000000f28e4b60d751c2207c45faf1da6274bc4e85e9fa000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000e4906571470000000000000000000000006c56ddccb3726faa089a5e9e29b712525cf916d7000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000001d57726170706564204176616c6f6e204176616c6f6e20534f4c56425443000000000000000000000000000000000000000000000000000000000000000000000e7761536f6e6963534f4c5642544300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _logic (address): 0x03d56967C93D2E4A92e9C1607B857BA8BB7aDa7A
Arg [1] : admin_ (address): 0xF28E4b60D751C2207c45FAF1Da6274bC4E85E9fA
Arg [2] : _data (bytes): 0x906571470000000000000000000000006c56ddccb3726faa089a5e9e29b712525cf916d7000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000001d57726170706564204176616c6f6e204176616c6f6e20534f4c56425443000000000000000000000000000000000000000000000000000000000000000000000e7761536f6e6963534f4c56425443000000000000000000000000000000000000

-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 00000000000000000000000003d56967c93d2e4a92e9c1607b857ba8bb7ada7a
Arg [1] : 000000000000000000000000f28e4b60d751c2207c45faf1da6274bc4e85e9fa
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000e4
Arg [4] : 906571470000000000000000000000006c56ddccb3726faa089a5e9e29b71252
Arg [5] : 5cf916d700000000000000000000000000000000000000000000000000000000
Arg [6] : 0000006000000000000000000000000000000000000000000000000000000000
Arg [7] : 000000a000000000000000000000000000000000000000000000000000000000
Arg [8] : 0000001d57726170706564204176616c6f6e204176616c6f6e20534f4c564254
Arg [9] : 4300000000000000000000000000000000000000000000000000000000000000
Arg [10] : 0000000e7761536f6e6963534f4c564254430000000000000000000000000000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000000

1784:3289:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2871:11:4;:9;:11::i;:::-;1784:3289:5;;2664:11:4;:9;:11::i;3945:128:5:-;;;;;;;;;;-1:-1:-1;3945:128:5;;;;;:::i;:::-;;:::i;4433:170::-;;;;;;:::i;:::-;;:::i;3388:123::-;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;1212:32:6;;;1194:51;;1182:2;1167:18;3388:123:5;;;;;;;3700:97;;;;;;;;;;-1:-1:-1;3700:97:5;;;;;:::i;:::-;;:::i;2858:90::-;;;;;;;;;;;;;:::i;2335:100:4:-;2379:17;:15;:17::i;:::-;2402:28;2412:17;:15;:17::i;:::-;2402:9;:28::i;:::-;2335:100::o;3945:128:5:-;2371:11;:9;:11::i;:::-;-1:-1:-1;;;;;2357:25:5;:10;:25;2353:79;;4014:54:::1;4032:17;4051:9;;;;;;;;;;;::::0;4062:5:::1;4014:17;:54::i;:::-;3945:128:::0;:::o;2353:79::-;2414:11;:9;:11::i;4433:170::-;2371:11;:9;:11::i;:::-;-1:-1:-1;;;;;2357:25:5;:10;:25;2353:79;;4550:48:::1;4568:17;4587:4;;4550:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;4593:4:5::1;::::0;-1:-1:-1;4550:17:5::1;::::0;-1:-1:-1;;4550:48:5:i:1;:::-;4433:170:::0;;;:::o;2353:79::-;2414:11;:9;:11::i;3388:123::-;3440:23;2371:11;:9;:11::i;:::-;-1:-1:-1;;;;;2357:25:5;:10;:25;2353:79;;3489:17:::1;:15;:17::i;:::-;3471:35;;3388:123:::0;:::o;2353:79::-;2414:11;:9;:11::i;:::-;3388:123;:::o;3700:97::-;2371:11;:9;:11::i;:::-;-1:-1:-1;;;;;2357:25:5;:10;:25;2353:79;;3770:22:::1;3783:8;3770:12;:22::i;2858:90::-:0;2901:14;2371:11;:9;:11::i;:::-;-1:-1:-1;;;;;2357:25:5;:10;:25;2353:79;;2932:11:::1;:9;:11::i;4856:215::-:0;4944:11;:9;:11::i;:::-;-1:-1:-1;;;;;4930:25:5;:10;:25;4915:122;;;;-1:-1:-1;;;4915:122:5;;1458:2:6;4915:122:5;;;1440:21:6;1497:2;1477:18;;;1470:30;1536:34;1516:18;;;1509:62;1607:34;1587:18;;;1580:62;-1:-1:-1;;;1658:19:6;;;1651:33;1701:19;;4915:122:5;;;;;;;;1319:134:2;1386:12;1413:35;:33;:35::i;1099:779:4:-;1409:14;1406:1;1403;1390:34;1605:1;1602;1586:14;1583:1;1567:14;1560:5;1547:60;1669:16;1666:1;1663;1648:38;1701:6;1756:52;;;;1843:16;1840:1;1833:27;1756:52;1783:16;1780:1;1773:27;3137:116:3;3181:7;1614:66;3203:39;:45;-1:-1:-1;;;;;3203:45:3;;3137:116;-1:-1:-1;3137:116:3:o;2823:261::-;2943:29;2954:17;2943:10;:29::i;:::-;2996:1;2982:4;:11;:15;:28;;;;3001:9;2982:28;2978:102;;;3020:53;3049:17;3068:4;3020:28;:53::i;:::-;;2823:261;;;:::o;3617:125::-;3677:35;3690:11;:9;:11::i;:::-;3677:35;;;-1:-1:-1;;;;;1923:32:6;;;1905:51;;1992:32;;;1987:2;1972:18;;1965:60;1878:18;3677:35:3;;;;;;;3718:19;3728:8;3718:9;:19::i;1999:134::-;2052:7;1315:66;2074:48;1692:170:1;2559:142:3;2621:37;2640:17;2621:18;:37::i;:::-;2669:27;;-1:-1:-1;;;;;2669:27:3;;;;;;;;2559:142;:::o;6239:192:0:-;6322:12;6349:77;6370:6;6378:4;6349:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;6342:84;6239:192;-1:-1:-1;;;6239:192:0:o;3327:191:3:-;-1:-1:-1;;;;;3386:22:3;;3378:73;;;;-1:-1:-1;;;3378:73:3;;2238:2:6;3378:73:3;;;2220:21:6;2277:2;2257:18;;;2250:30;2316:34;2296:18;;;2289:62;-1:-1:-1;;;2367:18:6;;;2360:36;2413:19;;3378:73:3;2036:402:6;3378:73:3;3505:8;1614:66;3457:39;:56;;-1:-1:-1;;;;;;3457:56:3;-1:-1:-1;;;;;3457:56:3;;;;;;;;;;-1:-1:-1;3327:191:3:o;2216:249::-;-1:-1:-1;;;;;1513:19:0;;;2285:95:3;;;;-1:-1:-1;;;2285:95:3;;2645:2:6;2285:95:3;;;2627:21:6;2684:2;2664:18;;;2657:30;2723:34;2703:18;;;2696:62;-1:-1:-1;;;2774:18:6;;;2767:43;2827:19;;2285:95:3;2443:409:6;2285:95:3;2443:17;1315:66;2386:48;1692:170:1;6603:301:0;6730:12;6751;6765:23;6792:6;-1:-1:-1;;;;;6792:19:0;6812:4;6792:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6750:67;;;;6830:69;6857:6;6865:7;6874:10;6886:12;6830:26;:69::i;:::-;6823:76;6603:301;-1:-1:-1;;;;;;6603:301:0:o;7178:548::-;7340:12;7364:7;7360:362;;;7385:10;:17;7406:1;7385:22;7381:256;;-1:-1:-1;;;;;1513:19:0;;;7568:60;;;;-1:-1:-1;;;7568:60:0;;3365:2:6;7568:60:0;;;3347:21:6;3404:2;3384:18;;;3377:30;3443:31;3423:18;;;3416:59;3492:18;;7568:60:0;3163:353:6;7568:60:0;-1:-1:-1;7651:10:0;7644:17;;7360:362;7682:33;7690:10;7702:12;7682:7;:33::i;:::-;7178:548;;;;;;:::o;8192:476::-;8343:17;;:21;8339:325;;8545:10;8539:17;8593:15;8580:10;8576:2;8572:19;8565:44;8339:325;8644:12;8637:20;;-1:-1:-1;;;8637:20:0;;;;;;;;:::i;14:173:6:-;82:20;;-1:-1:-1;;;;;131:31:6;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;383:660::-;462:6;470;478;531:2;519:9;510:7;506:23;502:32;499:52;;;547:1;544;537:12;499:52;570:29;589:9;570:29;:::i;:::-;560:39;;650:2;639:9;635:18;622:32;677:18;669:6;666:30;663:50;;;709:1;706;699:12;663:50;732:22;;785:4;777:13;;773:27;-1:-1:-1;763:55:6;;814:1;811;804:12;763:55;854:2;841:16;880:18;872:6;869:30;866:50;;;912:1;909;902:12;866:50;957:7;952:2;943:6;939:2;935:15;931:24;928:37;925:57;;;978:1;975;968:12;925:57;383:660;;1009:2;1001:11;;;;;-1:-1:-1;1031:6:6;;-1:-1:-1;;;383:660:6:o;2857:301::-;2986:3;3024:6;3018:13;3070:6;3063:4;3055:6;3051:17;3046:3;3040:37;3132:1;3096:16;;3121:13;;;-1:-1:-1;3096:16:6;2857:301;-1:-1:-1;2857:301:6:o;3521:418::-;3670:2;3659:9;3652:21;3633:4;3702:6;3696:13;3745:6;3740:2;3729:9;3725:18;3718:34;3804:6;3799:2;3791:6;3787:15;3782:2;3771:9;3767:18;3761:50;3860:1;3855:2;3846:6;3835:9;3831:22;3827:31;3820:42;3930:2;3923;3919:7;3914:2;3906:6;3902:15;3898:29;3887:9;3883:45;3879:54;3871:62;;;3521:418;;;;:::o

ipfs://da2623db5083841682ed889b9b075b24d52b3211a670598bad7b8dce63302e26