fixup! Update docs

Author: matheusaaguiar

docs/cheatsheet.rst

@@ -59,7 +59,7 @@ Members of ``address``
 .. warning::
     ``send`` and ``transfer`` are deprecated and scheduled for removal in the next breaking version (0.9).
     Use the :ref:`call function <address_call_functions>` with an optionally provided maximum amount of
-    gas (default forwards all remaining gas) and an empty calldata parameter, e.g., ``call{value: amount}("")``.
+    gas (by default forwards 63/64 of the remaining gas) and an empty calldata parameter, e.g., ``call{value: amount}("")``.
 
 .. index:: blockhash, blobhash, block, block;basefee, block;blobbasefee, block;chainid, block;coinbase, block;difficulty, block;gaslimit, block;number, block;prevrandao, block;timestamp
 .. index:: gasleft, msg;data, msg;sender, msg;sig, msg;value, tx;gasprice, tx;origin

docs/security-considerations.rst

@@ -77,7 +77,7 @@ Ether transfer can always include code execution,
 so the recipient could be a contract that calls back into ``withdraw``.
 This would let it get multiple refunds and, basically, retrieve all the Ether in the contract.
 In particular, the following contract will allow an attacker to refund multiple times
-as it uses ``call`` which forwards all remaining gas by default:
+as it uses ``call`` which forwards 63/64 of the remaining gas by default:
 
 .. code-block:: solidity
 

docs/types/value-types.rst

@@ -244,8 +244,8 @@ For a quick reference of all members of address, see :ref:`address_related`.
 
 * ``balance`` and ``transfer``
 
-It is possible to query the balance of an address using the property ``balance``
-and to send Ether (in units of wei) to a payable address using the ``transfer`` function:
+    It is possible to query the balance of an address using the property ``balance``
+    and to send Ether (in units of wei) to a payable address using the ``transfer`` function:
 
 .. code-block:: solidity
     :force:
@@ -254,9 +254,9 @@ and to send Ether (in units of wei) to a payable address using the ``transfer``
     address myAddress = address(this);
     if (x.balance < 10 && myAddress.balance >= 10) x.transfer(10);
 
-The ``transfer`` function fails if the balance of the current contract is not large enough
-or if the Ether transfer is rejected by the receiving account. The ``transfer`` function
-reverts on failure.
+    The ``transfer`` function fails if the balance of the current contract is not large enough
+    or if the Ether transfer is rejected by the receiving account. The ``transfer`` function
+    reverts on failure.
 
 .. note::
     If ``x`` is a contract address, its code (more specifically: its :ref:`receive-ether-function`, if present, or otherwise its :ref:`fallback-function`, if present) will be executed together with the ``transfer`` call (this is a feature of the EVM and cannot be prevented). If that execution runs out of gas or fails in any way, the Ether transfer will be reverted and the current contract will stop with an exception.
@@ -268,7 +268,7 @@ reverts on failure.
 
 * ``send``
 
-``send`` is the low-level counterpart of ``transfer``. If the execution fails, the current contract will not stop with an exception, but ``send`` will return ``false``.
+    ``send`` is the low-level counterpart of ``transfer``. If the execution fails, the current contract will not stop with an exception, but ``send`` will return ``false``.
 
 .. warning::
     There are some dangers in using ``send``: The transfer fails if the call stack depth is at 1024
@@ -285,16 +285,16 @@ reverts on failure.
 
 * ``call``, ``delegatecall`` and ``staticcall``
 
-In order to interface with contracts that do not adhere to the ABI,
-or to get more direct control over the encoding,
-the functions ``call``, ``delegatecall`` and ``staticcall`` are provided.
-They all take a single ``bytes memory`` parameter and
-return the success condition (as a ``bool``) and the returned data
-(``bytes memory``).
-The functions ``abi.encode``, ``abi.encodePacked``, ``abi.encodeWithSelector``
-and ``abi.encodeWithSignature`` can be used to encode structured data.
+    In order to interface with contracts that do not adhere to the ABI,
+    or to get more direct control over the encoding,
+    the functions ``call``, ``delegatecall`` and ``staticcall`` are provided.
+    They all take a single ``bytes memory`` parameter and
+    return the success condition (as a ``bool``) and the returned data
+    (``bytes memory``).
+    The functions ``abi.encode``, ``abi.encodePacked``, ``abi.encodeWithSelector``
+    and ``abi.encodeWithSignature`` can be used to encode structured data.
 
-Example:
+    Example:
 
 .. code-block:: solidity
 
@@ -315,35 +315,35 @@ Example:
     arbitrary arguments and would also handle a first argument of type
     ``bytes4`` differently. These edge cases were removed in version 0.5.0.
 
-It is possible to adjust the supplied gas with the ``gas`` modifier:
+    It is possible to adjust the supplied gas with the ``gas`` modifier:
 
 .. code-block:: solidity
 
     address(nameReg).call{gas: 1000000}(abi.encodeWithSignature("register(string)", "MyName"));
 
-Similarly, the supplied Ether value can be controlled too:
+    Similarly, the supplied Ether value can be controlled too:
 
 .. code-block:: solidity
 
     address(nameReg).call{value: 1 ether}(abi.encodeWithSignature("register(string)", "MyName"));
 
-Lastly, these modifiers can be combined. Their order does not matter:
+    Lastly, these modifiers can be combined. Their order does not matter:
 
 .. code-block:: solidity
 
     address(nameReg).call{gas: 1000000, value: 1 ether}(abi.encodeWithSignature("register(string)", "MyName"));
 
-In a similar way, the function ``delegatecall`` can be used: the difference is that only the code of the given address is used, all other aspects (storage, balance, ...) are taken from the current contract. The purpose of ``delegatecall`` is to use library code which is stored in another contract. The user has to ensure that the layout of storage in both contracts is suitable for delegatecall to be used.
+    In a similar way, the function ``delegatecall`` can be used: the difference is that only the code of the given address is used, all other aspects (storage, balance, ...) are taken from the current contract. The purpose of ``delegatecall`` is to use library code which is stored in another contract. The user has to ensure that the layout of storage in both contracts is suitable for delegatecall to be used.
 
 .. note::
     Prior to homestead, only a limited variant called ``callcode`` was available that did not provide access to the original ``msg.sender`` and ``msg.value`` values. This function was removed in version 0.5.0.
 
-Since byzantium ``staticcall`` can be used as well. This is basically the same as ``call``, but will revert if the called function modifies the state in any way.
+    Since byzantium ``staticcall`` can be used as well. This is basically the same as ``call``, but will revert if the called function modifies the state in any way.
 
-All three functions ``call``, ``delegatecall`` and ``staticcall`` are very low-level functions and should only be used as a *last resort* as they break the type-safety of Solidity.
+    All three functions ``call``, ``delegatecall`` and ``staticcall`` are very low-level functions and should only be used as a *last resort* as they break the type-safety of Solidity.
 
-The ``gas`` option is available on all three methods, while the ``value`` option is only available
-on ``call``.
+    The ``gas`` option is available on all three methods, while the ``value`` option is only available
+    on ``call``.
 
 .. note::
     It is best to avoid relying on hardcoded gas values in your smart contract code,
@@ -352,9 +352,9 @@ on ``call``.
 
 * ``code`` and ``codehash``
 
-You can query the deployed code for any smart contract. Use ``.code`` to get the EVM bytecode as a
-``bytes memory``, which might be empty. Use ``.codehash`` to get the Keccak-256 hash of that code
-(as a ``bytes32``). Note that ``addr.codehash`` is cheaper than using ``keccak256(addr.code)``.
+    You can query the deployed code for any smart contract. Use ``.code`` to get the EVM bytecode as a
+    ``bytes memory``, which might be empty. Use ``.codehash`` to get the Keccak-256 hash of that code
+    (as a ``bytes32``). Note that ``addr.codehash`` is cheaper than using ``keccak256(addr.code)``.
 
 .. warning::
     The output of ``addr.codehash`` may be ``0`` if the account associated with ``addr`` is empty or non-existent