Fix: typos in docs

docs/ens_overview.rst

@@ -105,7 +105,7 @@ The first time it's used, web3.py will create the  ``ens`` instance using
 
     However, if accessing the ``ENS`` class via the ``Web3`` instance as a module
     (``w3.ens``), since all modules use the same ``Web3`` object reference
-    under the the hood (the parent ``w3`` object), changing the
+    under the hood (the parent ``w3`` object), changing the
     ``strict_bytes_type_checking`` flag value on ``w3`` also changes the flag state
     for ``w3.ens.w3`` and all modules.
 

docs/ethpm.rst

@@ -229,7 +229,7 @@ Registry URIs
 ~~~~~~~~~~~~~
 
 The URI to lookup a package from a registry should follow the following
-format. (subject to change as the Registry Contract Standard makes it’s
+format. (subject to change as the Registry Contract Standard makes its
 way through the EIP process)
 
 ::
@@ -450,7 +450,7 @@ To pin a manifest to IPFS
        ),
    )
 
-Pins the active manfiest to disk. Must be the concluding function in a builder set since it returns the IPFS pin data rather than returning the manifest for further processing.
+Pins the active manifest to disk. Must be the concluding function in a builder set since it returns the IPFS pin data rather than returning the manifest for further processing.
 
 
 To add meta fields
@@ -731,7 +731,7 @@ To select only certain contract type data to be included in your manifest, provi
    ... )
    >>> assert expected_manifest == built_manifest
 
-If you would like to alias your contract type, provide the desired alias as a kwarg. This will automatically include the original contract type in a ``contractType`` field. Unless specific contract type fields are provided as kwargs, ``contractType`` will stil default to including all available contract type data found in the compiler output.
+If you would like to alias your contract type, provide the desired alias as a kwarg. This will automatically include the original contract type in a ``contractType`` field. Unless specific contract type fields are provided as kwargs, ``contractType`` will still default to including all available contract type data found in the compiler output.
 
 .. doctest::
 

docs/examples.rst

@@ -747,7 +747,7 @@ If you want to run your application logging in debug mode, below is an example o
         """Setup root logger and quiet some levels."""
         logger = logging.getLogger()
 
-        # Set log format to dislay the logger name to hunt down verbose logging modules
+        # Set log format to display the logger name to hunt down verbose logging modules
         fmt = "%(name)-25s %(levelname)-8s %(message)s"
 
         # Use colored logging output for console with the coloredlogs package
@@ -786,7 +786,7 @@ eth_getLogs limitations
 
 Ethereum JSON-RPC API servers, like Geth, do not provide easy to paginate over events, only over blocks. There's no request that can find the first block with an event or how many events occur within a range of blocks. The only feedback the JSON-RPC service will give you is whether the `eth_getLogs` call failed.
 
-In this example script, we provide two kinds of heurestics to deal with this issue. The script scans events in a chunk of blocks (start block number - end block number). Then it uses two methods to find how many events there are likely to be in a block window:
+In this example script, we provide two kinds of heuristics to deal with this issue. The script scans events in a chunk of blocks (start block number - end block number). Then it uses two methods to find how many events there are likely to be in a block window:
 
 * Dynamically set the block range window size, while never exceeding a threshold (e.g., 10,000 blocks).
 
@@ -931,7 +931,7 @@ The script can be run with: ``python ./eventscanner.py <your JSON-RPC API URL>``
             # # (slow down scan after starting to get hits)
             self.chunk_size_decrease = 0.5
 
-            # Factor how was we increase chunk size if no results found
+            # Factor how fast we increase chunk size if no results found
             self.chunk_size_increase = 2.0
 
         @property
@@ -955,8 +955,8 @@ The script can be run with: ``python ./eventscanner.py <your JSON-RPC API URL>``
             If there are no prior scans, start from block 1.
             Otherwise, start from the last end block minus ten blocks.
             We rescan the last ten scanned blocks in the case there were forks to avoid
-            misaccounting due to minor single block works (happens once in a hour in Ethereum).
-            These heurestics could be made more robust, but this is for the sake of simple reference implementation.
+            misaccounting due to minor single block works (happens once in an hour in Ethereum).
+            These heuristics could be made more robust, but this is for the sake of simple reference implementation.
             """
 
             end_block = self.get_last_scanned_block()
@@ -1051,7 +1051,7 @@ The script can be run with: ``python ./eventscanner.py <your JSON-RPC API URL>``
             Currently Ethereum JSON-API does not have an API to tell when a first event occurred in a blockchain
             and our heuristics try to accelerate block fetching (chunk size) until we see the first event.
 
-            These heurestics exponentially increase the scan chunk size depending on if we are seeing events or not.
+            These heuristics exponentially increase the scan chunk size depending on if we are seeing events or not.
             When any transfers are encountered, we are back to scanning only a few blocks at a time.
             It does not make sense to do a full chain scan starting from block 1, doing one JSON-RPC call per 20 blocks.
             """
@@ -1415,7 +1415,7 @@ The script can be run with: ``python ./eventscanner.py <your JSON-RPC API URL>``
 
             # Assume we might have scanned the blocks all the way to the last Ethereum block
             # that mined a few seconds before the previous scan run ended.
-            # Because there might have been a minor Etherueum chain reorganisations
+            # Because there might have been a minor Ethereum chain reorganisations
             # since the last scan ended, we need to discard
             # the last few blocks from the previous scan results.
             chain_reorg_safety_blocks = 10

docs/filters.rst

@@ -76,14 +76,14 @@ Filter Class
 .. py:method:: Filter.format_entry(entry)
 
     Hook for subclasses to modify the format of the log entries this filter
-    returns, or passes to it's callback functions.
+    returns, or passes to its callback functions.
 
     By default this returns the ``entry`` parameter umodified.
 
 
 .. py:method:: Filter.is_valid_entry(entry)
 
-    Hook for subclasses to add additional programatic filtering.  The default
+    Hook for subclasses to add additional programmatic filtering.  The default
     implementation always returns ``True``.
 
 

docs/gas_price.rst

@@ -90,7 +90,7 @@ Available gas price strategies
     mined blocks. If ``weighted=True``, the block time will be weighted towards
     more recently mined blocks.
 
-    * ``max_wait_seconds`` The desired maxiumum number of seconds the
+    * ``max_wait_seconds`` The desired maximum number of seconds the
       transaction should take to mine.
     * ``sample_size`` The number of recent blocks to sample
     * ``probability`` An integer representation of the desired probability that

docs/middleware.rst

@@ -421,7 +421,7 @@ Why is ``geth_poa_middleware`` necessary?
 
 There is no strong community consensus on a single Proof-of-Authority (PoA) standard yet.
 Some nodes have successful experiments running, though. One is go-ethereum (geth),
-which uses a prototype PoA for it's development mode and the Goerli test network.
+which uses a prototype PoA for its development mode and the Goerli test network.
 
 Unfortunately, it does deviate from the yellow paper specification, which constrains the
 ``extraData`` field in each block to a maximum of 32-bytes. Geth's PoA uses more than

newsfragments/2817.doc.rst

@@ -0,0 +1 @@
+Typos fix in docs