style: Run formatter

contracts/facets/IexecEscrowNativeFacet.sol

@@ -9,7 +9,6 @@ import {IexecEscrowNative} from "../interfaces/IexecEscrowNative.sol";
 import {PocoStorageLib} from "../libs/PocoStorageLib.sol";
 
 contract IexecEscrowNativeFacet is IexecEscrowNative, FacetBase, IexecERC20Core {
-
     uint256 internal constant nRLCtoWei = 10 ** 9;
     /***************************************************************************
      *                         Escrow methods: public                          *

contracts/registries/proxy/Address.sol

@@ -37,7 +37,9 @@ library Address {
 
         uint256 size;
         // solhint-disable-next-line no-inline-assembly
-        assembly { size := extcodesize(account) }
+        assembly {
+            size := extcodesize(account)
+        }
         return size > 0;
     }
 }

contracts/registries/proxy/BaseUpgradeabilityProxy.sol

@@ -12,8 +12,8 @@
 
 pragma solidity ^0.8.0;
 
-import './Address.sol';
-import './Proxy.sol';
+import "./Address.sol";
+import "./Proxy.sol";
 
 /**
  * @title BaseUpgradeabilityProxy
@@ -22,50 +22,54 @@ import './Proxy.sol';
  * Such a change is called an implementation upgrade.
  */
 contract BaseUpgradeabilityProxy is Proxy {
-  /**
-   * @dev Emitted when the implementation is upgraded.
-   * @param implementation Address of the new implementation.
-   */
-  event Upgraded(address indexed implementation);
+    /**
+     * @dev Emitted when the implementation is upgraded.
+     * @param implementation Address of the new implementation.
+     */
+    event Upgraded(address indexed implementation);
 
-  /**
-   * @dev Storage slot with the address of the current implementation.
-   * This is the keccak-256 hash of "org.zeppelinos.proxy.implementation", and is
-   * validated in the constructor.
-   */
-  bytes32 internal constant IMPLEMENTATION_SLOT = 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;
+    /**
+     * @dev Storage slot with the address of the current implementation.
+     * This is the keccak-256 hash of "org.zeppelinos.proxy.implementation", and is
+     * validated in the constructor.
+     */
+    bytes32 internal constant IMPLEMENTATION_SLOT =
+        0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;
 
-  /**
-   * @dev Returns the current implementation.
-   * @return impl Address of the current implementation
-   */
-  function _implementation() internal override view returns (address impl) {
-    bytes32 slot = IMPLEMENTATION_SLOT;
-    assembly {
-      impl := sload(slot)
+    /**
+     * @dev Returns the current implementation.
+     * @return impl Address of the current implementation
+     */
+    function _implementation() internal view override returns (address impl) {
+        bytes32 slot = IMPLEMENTATION_SLOT;
+        assembly {
+            impl := sload(slot)
+        }
     }
-  }
 
-  /**
-   * @dev Upgrades the proxy to a new implementation.
-   * @param newImplementation Address of the new implementation.
-   */
-  function _upgradeTo(address newImplementation) internal {
-    _setImplementation(newImplementation);
-    emit Upgraded(newImplementation);
-  }
+    /**
+     * @dev Upgrades the proxy to a new implementation.
+     * @param newImplementation Address of the new implementation.
+     */
+    function _upgradeTo(address newImplementation) internal {
+        _setImplementation(newImplementation);
+        emit Upgraded(newImplementation);
+    }
 
-  /**
-   * @dev Sets the implementation address of the proxy.
-   * @param newImplementation Address of the new implementation.
-   */
-  function _setImplementation(address newImplementation) internal {
-    require(Address.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
+    /**
+     * @dev Sets the implementation address of the proxy.
+     * @param newImplementation Address of the new implementation.
+     */
+    function _setImplementation(address newImplementation) internal {
+        require(
+            Address.isContract(newImplementation),
+            "Cannot set a proxy implementation to a non-contract address"
+        );
 
-    bytes32 slot = IMPLEMENTATION_SLOT;
+        bytes32 slot = IMPLEMENTATION_SLOT;
 
-    assembly {
-      sstore(slot, newImplementation)
+        assembly {
+            sstore(slot, newImplementation)
+        }
     }
-  }
 }

contracts/registries/proxy/InitializableUpgradeabilityProxy.sol

@@ -11,29 +11,29 @@
 
 pragma solidity ^0.8.0;
 
-import './BaseUpgradeabilityProxy.sol';
+import "./BaseUpgradeabilityProxy.sol";
 
 /**
  * @title InitializableUpgradeabilityProxy
  * @dev Extends BaseUpgradeabilityProxy with an initializer for initializing
  * implementation and init data.
  */
 contract InitializableUpgradeabilityProxy is BaseUpgradeabilityProxy {
-  /**
-   * @dev Contract initializer.
-   * @param _logic Address of the initial implementation.
-   * @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
-   * It should include the signature and the parameters of the function to be called, as described in
-   * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
-   * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
-   */
-  function initialize(address _logic, bytes memory _data) public payable {
-    require(_implementation() == address(0));
-    assert(IMPLEMENTATION_SLOT == keccak256("org.zeppelinos.proxy.implementation"));
-    _setImplementation(_logic);
-    if(_data.length > 0) {
-      (bool success,) = _logic.delegatecall(_data);
-      require(success);
+    /**
+     * @dev Contract initializer.
+     * @param _logic Address of the initial implementation.
+     * @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
+     * It should include the signature and the parameters of the function to be called, as described in
+     * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
+     * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
+     */
+    function initialize(address _logic, bytes memory _data) public payable {
+        require(_implementation() == address(0));
+        assert(IMPLEMENTATION_SLOT == keccak256("org.zeppelinos.proxy.implementation"));
+        _setImplementation(_logic);
+        if (_data.length > 0) {
+            (bool success, ) = _logic.delegatecall(_data);
+            require(success);
+        }
     }
-  }
 }

contracts/registries/proxy/Proxy.sol

@@ -18,68 +18,71 @@ pragma solidity ^0.8.0;
  * returned by the abstract _implementation() internal function.
  */
 abstract contract Proxy {
-  /**
-   * @dev Receive function.
-   * Implemented entirely in `_fallback`.
-   */
-  receive() external payable virtual {
-    _fallback();
-  }
+    /**
+     * @dev Receive function.
+     * Implemented entirely in `_fallback`.
+     */
+    receive() external payable virtual {
+        _fallback();
+    }
 
-  /**
-   * @dev Fallback function.
-   * Implemented entirely in `_fallback`.
-   */
-  fallback() external payable {
-    _fallback();
-  }
+    /**
+     * @dev Fallback function.
+     * Implemented entirely in `_fallback`.
+     */
+    fallback() external payable {
+        _fallback();
+    }
 
-  /**
-   * @return impl The Address of the implementation.
-   */
-  function _implementation() internal virtual view returns (address impl);
+    /**
+     * @return impl The Address of the implementation.
+     */
+    function _implementation() internal view virtual returns (address impl);
 
-  /**
-   * @dev Delegates execution to an implementation contract.
-   * This is a low level function that doesn't return to its internal call site.
-   * It will return to the external caller whatever the implementation returns.
-   * @param implementation Address to delegate.
-   */
-  function _delegate(address implementation) internal {
-    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())
+    /**
+     * @dev Delegates execution to an implementation contract.
+     * This is a low level function that doesn't return to its internal call site.
+     * It will return to the external caller whatever the implementation returns.
+     * @param implementation Address to delegate.
+     */
+    function _delegate(address implementation) internal {
+        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)
+            // 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())
+            // Copy the returned data.
+            returndatacopy(0, 0, returndatasize())
 
-      switch result
-      // delegatecall returns 0 on error.
-      case 0 { revert(0, returndatasize()) }
-      default { return(0, returndatasize()) }
+            switch result
+            // delegatecall returns 0 on error.
+            case 0 {
+                revert(0, returndatasize())
+            }
+            default {
+                return(0, returndatasize())
+            }
+        }
     }
-  }
 
-  /**
-   * @dev Function that is run as the first thing in the fallback function.
-   * Can be redefined in derived contracts to add functionality.
-   * Redefinitions must call super._willFallback().
-   */
-  function _willFallback() internal virtual {
-  }
+    /**
+     * @dev Function that is run as the first thing in the fallback function.
+     * Can be redefined in derived contracts to add functionality.
+     * Redefinitions must call super._willFallback().
+     */
+    function _willFallback() internal virtual {}
 
-  /**
-   * @dev fallback implementation.
-   * Extracted to enable manual triggering.
-   */
-  function _fallback() internal {
-    _willFallback();
-    _delegate(_implementation());
-  }
+    /**
+     * @dev fallback implementation.
+     * Extracted to enable manual triggering.
+     */
+    function _fallback() internal {
+        _willFallback();
+        _delegate(_implementation());
+    }
 }