web3 7.0.0b2__py3-none-any.whl → 7.0.0b4__py3-none-any.whl

web3/tools/benchmark/main.py

@@ -0,0 +1,189 @@
+import argparse
+import asyncio
+from collections import (
+    defaultdict,
+)
+import logging
+import sys
+import timeit
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Union,
+)
+
+from web3 import (
+    AsyncHTTPProvider,
+    AsyncWeb3,
+    HTTPProvider,
+    Web3,
+)
+from web3.middleware import (
+    BufferedGasEstimateMiddleware,
+    GasPriceStrategyMiddleware,
+)
+from web3.tools.benchmark.node import (
+    GethBenchmarkFixture,
+)
+from web3.tools.benchmark.reporting import (
+    print_entry,
+    print_footer,
+    print_header,
+)
+from web3.tools.benchmark.utils import (
+    wait_for_aiohttp,
+    wait_for_http,
+)
+from web3.types import (
+    Wei,
+)
+
+KEYFILE_PW = "web3py-test"
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--num-calls",
+    type=int,
+    default=10,
+    help="The number of RPC calls to make",
+)
+
+# TODO - layers to test:
+# contract.functions.method(...).call()
+# w3.eth.call(...)
+# HTTPProvider.make_request(...)
+
+
+def build_web3_http(endpoint_uri: str) -> Web3:
+    wait_for_http(endpoint_uri)
+    _w3 = Web3(
+        HTTPProvider(endpoint_uri),
+        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
+    )
+    return _w3
+
+
+async def build_async_w3_http(endpoint_uri: str) -> AsyncWeb3:
+    await wait_for_aiohttp(endpoint_uri)
+    _w3 = AsyncWeb3(
+        AsyncHTTPProvider(endpoint_uri),
+        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
+    )
+    return _w3
+
+
+def sync_benchmark(func: Callable[..., Any], n: int) -> Union[float, str]:
+    try:
+        starttime = timeit.default_timer()
+        for _ in range(n):
+            func()
+        endtime = timeit.default_timer()
+        execution_time = endtime - starttime
+        return execution_time
+    except Exception:
+        return "N/A"
+
+
+async def async_benchmark(func: Callable[..., Any], n: int) -> Union[float, str]:
+    try:
+        starttime = timeit.default_timer()
+        for result in asyncio.as_completed([func() for _ in range(n)]):
+            await result
+        execution_time = timeit.default_timer() - starttime
+        return execution_time
+    except Exception:
+        return "N/A"
+
+
+def main(logger: logging.Logger, num_calls: int) -> None:
+    fixture = GethBenchmarkFixture()
+    for built_fixture in fixture.build():
+        for _ in built_fixture:
+            w3_http = build_web3_http(fixture.endpoint_uri)
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+
+            # -- sync -- #
+            coinbase = w3_http.eth.coinbase
+
+            # -- async -- #
+            async_w3_http = loop.run_until_complete(
+                build_async_w3_http(fixture.endpoint_uri)
+            )
+            async_coinbase = loop.run_until_complete(async_w3_http.eth.coinbase)
+
+            methods = [
+                {
+                    "name": "eth_gasPrice",
+                    "params": {},
+                    "exec": lambda w3_http=w3_http: w3_http.eth.gas_price,
+                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.gas_price,  # noqa: E501
+                },
+                {
+                    "name": "eth_sendTransaction",
+                    "params": {},
+                    "exec": lambda w3_http=w3_http, coinbase=coinbase: w3_http.eth.send_transaction(  # noqa: E501
+                        {
+                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
+                            "from": coinbase,
+                            "value": Wei(1),
+                        }
+                    ),
+                    "async_exec": lambda async_w3_http=async_w3_http, async_coinbase=async_coinbase: async_w3_http.eth.send_transaction(  # noqa: E501
+                        {
+                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
+                            "from": async_coinbase,
+                            "value": Wei(1),
+                        }
+                    ),
+                },
+                {
+                    "name": "eth_blockNumber",
+                    "params": {},
+                    "exec": lambda w3_http=w3_http: w3_http.eth.block_number,
+                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.block_number,  # noqa: E501
+                },
+                {
+                    "name": "eth_getBlock",
+                    "params": {},
+                    "exec": lambda w3_http=w3_http: w3_http.eth.get_block(1),
+                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.get_block(  # noqa: E501
+                        1
+                    ),
+                },
+            ]
+
+            def benchmark(
+                method: Dict[str, Any], loop: asyncio.AbstractEventLoop = loop
+            ) -> None:
+                outcomes: Dict[str, Union[str, float]] = defaultdict(lambda: "N/A")
+                outcomes["name"] = method["name"]
+                outcomes["HTTPProvider"] = sync_benchmark(
+                    method["exec"],
+                    num_calls,
+                )
+                outcomes["AsyncHTTPProvider"] = loop.run_until_complete(
+                    async_benchmark(method["async_exec"], num_calls)
+                )
+                print_entry(logger, outcomes)
+
+            print_header(logger, num_calls)
+
+            for method in methods:
+                benchmark(method)
+
+            print_footer(logger)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+    logger.addHandler(logging.StreamHandler(sys.stdout))
+
+    main(logger, args.num_calls)

web3/tools/benchmark/node.py

@@ -0,0 +1,126 @@
+import os
+import socket
+from subprocess import (
+    PIPE,
+    Popen,
+    check_output,
+)
+from tempfile import (
+    TemporaryDirectory,
+)
+from typing import (
+    Any,
+    Generator,
+    Sequence,
+)
+import zipfile
+
+from geth.install import (
+    get_executable_path,
+    install_geth,
+)
+
+from web3.tools.benchmark.utils import (
+    kill_proc_gracefully,
+)
+
+GETH_FIXTURE_ZIP = "geth-1.13.11-fixture.zip"
+
+# use same coinbase value as in `web3.py/tests/integration/generate_fixtures/common.py`
+COINBASE = "0xdc544d1aa88ff8bbd2f2aec754b1f1e99e1812fd"
+
+
+class GethBenchmarkFixture:
+    def __init__(self) -> None:
+        self.rpc_port = self._rpc_port()
+        self.endpoint_uri = self._endpoint_uri()
+        self.geth_binary = self._geth_binary()
+
+    def build(self) -> Generator[Any, None, None]:
+        with TemporaryDirectory() as base_dir:
+            zipfile_path = os.path.abspath(
+                os.path.join(
+                    os.path.dirname(__file__),
+                    "../../../tests/integration/",
+                    GETH_FIXTURE_ZIP,
+                )
+            )
+            tmp_datadir = os.path.join(str(base_dir), "datadir")
+            with zipfile.ZipFile(zipfile_path, "r") as zip_ref:
+                zip_ref.extractall(tmp_datadir)
+            self.datadir = tmp_datadir
+
+            genesis_file = os.path.join(self.datadir, "genesis.json")
+
+            yield self._geth_process(self.datadir, genesis_file, self.rpc_port)
+
+    def _rpc_port(self) -> str:
+        sock = socket.socket()
+        sock.bind(("127.0.0.1", 0))
+        port = sock.getsockname()[1]
+        sock.close()
+        return str(port)
+
+    def _endpoint_uri(self) -> str:
+        return f"http://localhost:{self.rpc_port}"
+
+    def _geth_binary(self) -> str:
+        if "GETH_BINARY" in os.environ:
+            return os.environ["GETH_BINARY"]
+        elif "GETH_VERSION" in os.environ:
+            geth_version = os.environ["GETH_VERSION"]
+            _geth_binary = get_executable_path(geth_version)
+            if not os.path.exists(_geth_binary):
+                install_geth(geth_version)
+            assert os.path.exists(_geth_binary)
+            return _geth_binary
+        else:
+            return "geth"
+
+    def _geth_command_arguments(self, datadir: str) -> Sequence[str]:
+        return (
+            self.geth_binary,
+            "--dev",
+            "--dev.period",
+            "100",
+            "--datadir",
+            str(datadir),
+            "--nodiscover",
+            "--http",
+            "--http.port",
+            self.rpc_port,
+            "--http.api",
+            "admin,eth,net,web3",
+            "--ipcdisable",
+            "--allow-insecure-unlock",
+            "--miner.etherbase",
+            COINBASE[2:],
+            "--password",
+            os.path.join(datadir, "keystore", "pw.txt"),
+        )
+
+    def _geth_process(
+        self, datadir: str, genesis_file: str, rpc_port: str
+    ) -> Generator[Any, None, None]:
+        init_datadir_command = (
+            self.geth_binary,
+            "--datadir",
+            str(datadir),
+            "init",
+            str(genesis_file),
+        )
+        check_output(
+            init_datadir_command,
+            stdin=PIPE,
+            stderr=PIPE,
+        )
+        proc = Popen(
+            self._geth_command_arguments(datadir),
+            stdin=PIPE,
+            stdout=PIPE,
+            stderr=PIPE,
+        )
+        try:
+            yield proc
+        finally:
+            kill_proc_gracefully(proc)

web3/tools/benchmark/reporting.py

@@ -0,0 +1,39 @@
+from logging import (
+    Logger,
+)
+from typing import (
+    Any,
+    Dict,
+)
+
+
+def print_header(logger: Logger, num_calls: int) -> None:
+    logger.info(
+        "|{:^26}|{:^20}|{:^20}|{:^20}|{:^20}|".format(
+            f"Method ({num_calls} calls)",
+            "HTTPProvider",
+            "AsyncHTTProvider",
+            "IPCProvider",
+            "WebSocketProvider",
+        )
+    )
+    logger.info("-" * 112)
+
+
+def print_entry(
+    logger: Logger,
+    method_benchmarks: Dict[str, Any],
+) -> None:
+    logger.info(
+        "|{:^26}|{:^20.10}|{:^20.10}|{:^20.10}|{:^20.10}|".format(
+            method_benchmarks["name"],
+            method_benchmarks["HTTPProvider"],
+            method_benchmarks["AsyncHTTPProvider"],
+            method_benchmarks["IPCProvider"],
+            method_benchmarks["WebSocketProvider"],
+        )
+    )
+
+
+def print_footer(logger: Logger) -> None:
+    logger.info("-" * 112)

web3/tools/benchmark/utils.py

@@ -0,0 +1,69 @@
+import asyncio
+import signal
+import socket
+import time
+from typing import (
+    Any,
+)
+
+import aiohttp
+import requests
+
+
+def wait_for_socket(ipc_path: str, timeout: int = 30) -> None:
+    start = time.time()
+    while time.time() < start + timeout:
+        try:
+            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            sock.connect(ipc_path)
+            sock.settimeout(timeout)
+        except OSError:
+            time.sleep(0.01)
+        else:
+            break
+
+
+def wait_for_http(endpoint_uri: str, timeout: int = 60) -> None:
+    start = time.time()
+    while time.time() < start + timeout:
+        try:
+            requests.get(endpoint_uri)
+        except requests.ConnectionError:
+            time.sleep(0.01)
+        else:
+            break
+
+
+async def wait_for_aiohttp(endpoint_uri: str, timeout: int = 60) -> None:
+    start = time.time()
+    while time.time() < start + timeout:
+        try:
+            async with aiohttp.ClientSession() as session:
+                await session.get(endpoint_uri)
+        except aiohttp.client_exceptions.ClientConnectorError:
+            await asyncio.sleep(0.01)
+        else:
+            break
+
+
+def wait_for_popen(proc: Any, timeout: int) -> None:
+    start = time.time()
+    while time.time() < start + timeout:
+        if proc.poll() is None:
+            time.sleep(0.01)
+        else:
+            break
+
+
+def kill_proc_gracefully(proc: Any) -> None:
+    if proc.poll() is None:
+        proc.send_signal(signal.SIGINT)
+        wait_for_popen(proc, 13)
+
+    if proc.poll() is None:
+        proc.terminate()
+        wait_for_popen(proc, 5)
+
+    if proc.poll() is None:
+        proc.kill()
+        wait_for_popen(proc, 2)

web3/tracing.py

@@ -53,10 +53,10 @@ class Tracing(Module):
         self._default_block = value
 
     def trace_replay_transaction_munger(
-        self,
-        block_identifier: Union[_Hash32, BlockIdentifier],
-        mode: TraceMode = ["trace"],
+        self, block_identifier: Union[_Hash32, BlockIdentifier], mode: TraceMode = None
     ) -> Tuple[Union[BlockIdentifier, _Hash32], TraceMode]:
+        if mode is None:
+            mode = ["trace"]
         return (block_identifier, mode)
 
     trace_replay_transaction: Method[Callable[..., BlockTrace]] = Method(
@@ -86,9 +86,11 @@ class Tracing(Module):
     def trace_call_munger(
         self,
         transaction: TxParams,
-        mode: TraceMode = ["trace"],
+        mode: TraceMode = None,
         block_identifier: Optional[BlockIdentifier] = None,
     ) -> Tuple[TxParams, TraceMode, BlockIdentifier]:
+        if mode is None:
+            mode = ["trace"]
         if "from" not in transaction and is_checksum_address(
             self.w3.eth.default_account
         ):
@@ -105,8 +107,10 @@ class Tracing(Module):
     )
 
     def trace_transactions_munger(
-        self, raw_transaction: HexStr, mode: TraceMode = ["trace"]
+        self, raw_transaction: HexStr, mode: TraceMode = None
     ) -> Tuple[HexStr, TraceMode]:
+        if mode is None:
+            mode = ["trace"]
         return raw_transaction, mode
 
     trace_raw_transaction: Method[Callable[..., BlockTrace]] = Method(

web3/types.py

@@ -5,10 +5,12 @@ from typing import (
     Coroutine,
     Dict,
     List,
+    Literal,
     NewType,
     Optional,
     Sequence,
     Type,
+    TypedDict,
     TypeVar,
     Union,
 )
@@ -25,9 +27,7 @@ from hexbytes import (
 )
 
 from web3._utils.compat import (
-    Literal,
     NotRequired,
-    TypedDict,
 )
 from web3._utils.function_identifiers import (
     FallbackFn,
@@ -135,6 +135,7 @@ TxData = TypedDict(
     "TxData",
     {
         "accessList": AccessList,
+        "blobVersionedHashes": Sequence[HexBytes],
         "blockHash": HexBytes,
         "blockNumber": BlockNumber,
         "chainId": int,
@@ -142,6 +143,7 @@ TxData = TypedDict(
         "from": ChecksumAddress,
         "gas": int,
         "gasPrice": Wei,
+        "maxFeePerBlobGas": Wei,
         "maxFeePerGas": Wei,
         "maxPriorityFeePerGas": Wei,
         "hash": HexBytes,
@@ -163,6 +165,8 @@ TxData = TypedDict(
 TxParams = TypedDict(
     "TxParams",
     {
+        "accessList": AccessList,
+        "blobVersionedHashes": Sequence[Union[str, HexStr, bytes, HexBytes]],
         "chainId": int,
         "data": Union[bytes, HexStr],
         # addr or ens
@@ -170,6 +174,7 @@ TxParams = TypedDict(
         "gas": int,
         # legacy pricing
         "gasPrice": Wei,
+        "maxFeePerBlobGas": Union[str, Wei],
         # dynamic fee pricing
         "maxFeePerGas": Union[str, Wei],
         "maxPriorityFeePerGas": Union[str, Wei],
@@ -183,15 +188,11 @@ TxParams = TypedDict(
 )
 
 
-WithdrawalData = TypedDict(
-    "WithdrawalData",
-    {
-        "index": int,
-        "validator_index": int,
-        "address": ChecksumAddress,
-        "amount": Gwei,
-    },
-)
+class WithdrawalData(TypedDict):
+    index: int
+    validator_index: int
+    address: ChecksumAddress
+    amount: Gwei
 
 
 class BlockData(TypedDict, total=False):
@@ -218,6 +219,9 @@ class BlockData(TypedDict, total=False):
     uncles: Sequence[HexBytes]
     withdrawals: Sequence[WithdrawalData]
     withdrawalsRoot: HexBytes
+    parentBeaconBlockRoot: HexBytes
+    blobGasUsed: int
+    excessBlobGas: int
 
     # ExtraDataToPOAMiddleware replaces extraData w/ proofOfAuthorityData
     proofOfAuthorityData: HexBytes
@@ -338,17 +342,12 @@ class FeeHistory(TypedDict):
     reward: List[List[Wei]]
 
 
-StateOverrideParams = TypedDict(
-    "StateOverrideParams",
-    {
-        "balance": Optional[Wei],
-        "nonce": Optional[int],
-        "code": Optional[Union[bytes, HexStr]],
-        "state": Optional[Dict[HexStr, HexStr]],
-        "stateDiff": Optional[Dict[HexStr, HexStr]],
-    },
-    total=False,
-)
+class StateOverrideParams(TypedDict, total=False):
+    balance: Optional[Wei]
+    nonce: Optional[int]
+    code: Optional[Union[bytes, HexStr]]
+    state: Optional[Dict[HexStr, HexStr]]
+    stateDiff: Optional[Dict[HexStr, HexStr]]
 
 
 StateOverride = Dict[ChecksumAddress, StateOverrideParams]
@@ -381,6 +380,8 @@ TxReceipt = TypedDict(
     },
 )
 
+BlockReceipts = List[TxReceipt]
+
 
 class SignedTx(TypedDict, total=False):
     raw: bytes

web3/utils/caching.py

@@ -16,22 +16,20 @@ class SimpleCache:
         self._data: OrderedDict[str, Any] = OrderedDict()
 
     def cache(self, key: str, value: Any) -> Tuple[Any, Dict[str, Any]]:
-        evicted_items = None
+        evicted_items = {}
         # If the key is already in the OrderedDict just update it
         # and don't evict any values. Ideally, we could still check to see
         # if there are too many items in the OrderedDict but that may rearrange
         # the order it should be unlikely that the size could grow over the limit
         if key not in self._data:
             while len(self._data) >= self._size:
-                if evicted_items is None:
-                    evicted_items = {}
                 k, v = self._data.popitem(last=False)
                 evicted_items[k] = v
         self._data[key] = value
 
         # Return the cached value along with the evicted items at the same time. No
         # need to reach back into the cache to grab the value.
-        return value, evicted_items
+        return value, evicted_items or None
 
     def get_cache_entry(self, key: str) -> Optional[Any]:
         return self._data[key] if key in self._data else None

{web3-7.0.0b2.dist-info → web3-7.0.0b4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.0.0b2
+Version: 7.0.0b4
 Summary: web3.py
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -20,12 +20,12 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp >=3.7.4.post0
-Requires-Dist: eth-abi >=4.0.0
-Requires-Dist: eth-account >=0.8.0
+Requires-Dist: eth-abi >=5.0.1
+Requires-Dist: eth-account >=0.12.0
 Requires-Dist: eth-hash[pycryptodome] >=0.5.1
-Requires-Dist: eth-typing >=3.0.0
+Requires-Dist: eth-typing >=4.0.0
 Requires-Dist: eth-utils >=4.0.0
-Requires-Dist: hexbytes <0.4.0,>=0.1.0
+Requires-Dist: hexbytes >=1.2.0
 Requires-Dist: pydantic >=2.4.0
 Requires-Dist: requests >=2.16.0
 Requires-Dist: typing-extensions >=4.0.1
@@ -33,44 +33,31 @@ Requires-Dist: websockets >=10.0.0
 Requires-Dist: pyunormalize >=15.0.0
 Requires-Dist: pywin32 >=223 ; platform_system == "Windows"
 Provides-Extra: dev
-Requires-Dist: eth-tester[py-evm] ==v0.10.0-b.3 ; extra == 'dev'
+Requires-Dist: eth-tester[py-evm] <0.12.0b1,>=0.11.0b1 ; extra == 'dev'
 Requires-Dist: py-geth >=4.1.0 ; extra == 'dev'
-Requires-Dist: black >=22.1.0 ; extra == 'dev'
-Requires-Dist: flake8 ==3.8.3 ; extra == 'dev'
-Requires-Dist: isort >=5.11.0 ; extra == 'dev'
-Requires-Dist: mypy ==1.4.1 ; extra == 'dev'
-Requires-Dist: types-setuptools >=57.4.4 ; extra == 'dev'
-Requires-Dist: types-requests >=2.26.1 ; extra == 'dev'
 Requires-Dist: sphinx >=5.3.0 ; extra == 'dev'
 Requires-Dist: sphinx-rtd-theme >=1.0.0 ; extra == 'dev'
 Requires-Dist: towncrier <22,>=21 ; extra == 'dev'
+Requires-Dist: build >=0.9.0 ; extra == 'dev'
 Requires-Dist: bumpversion ; extra == 'dev'
 Requires-Dist: flaky >=3.7.0 ; extra == 'dev'
 Requires-Dist: hypothesis >=3.31.2 ; extra == 'dev'
-Requires-Dist: pytest >=7.0.0 ; extra == 'dev'
+Requires-Dist: pre-commit >=3.4.0 ; extra == 'dev'
 Requires-Dist: pytest-asyncio <0.23,>=0.18.1 ; extra == 'dev'
 Requires-Dist: pytest-mock >=1.10 ; extra == 'dev'
 Requires-Dist: pytest-watch >=4.2 ; extra == 'dev'
 Requires-Dist: pytest-xdist >=1.29 ; extra == 'dev'
+Requires-Dist: pytest >=7.0.0 ; extra == 'dev'
 Requires-Dist: setuptools >=38.6.0 ; extra == 'dev'
 Requires-Dist: tox >=3.18.0 ; extra == 'dev'
 Requires-Dist: tqdm >4.32 ; extra == 'dev'
 Requires-Dist: twine >=1.13 ; extra == 'dev'
-Requires-Dist: build >=0.9.0 ; extra == 'dev'
-Requires-Dist: importlib-metadata <5.0 ; (python_version < "3.8") and extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: sphinx >=5.3.0 ; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme >=1.0.0 ; extra == 'docs'
 Requires-Dist: towncrier <22,>=21 ; extra == 'docs'
-Provides-Extra: linter
-Requires-Dist: black >=22.1.0 ; extra == 'linter'
-Requires-Dist: flake8 ==3.8.3 ; extra == 'linter'
-Requires-Dist: isort >=5.11.0 ; extra == 'linter'
-Requires-Dist: mypy ==1.4.1 ; extra == 'linter'
-Requires-Dist: types-setuptools >=57.4.4 ; extra == 'linter'
-Requires-Dist: types-requests >=2.26.1 ; extra == 'linter'
 Provides-Extra: tester
-Requires-Dist: eth-tester[py-evm] ==v0.10.0-b.3 ; extra == 'tester'
+Requires-Dist: eth-tester[py-evm] <0.12.0b1,>=0.11.0b1 ; extra == 'tester'
 Requires-Dist: py-geth >=4.1.0 ; extra == 'tester'
 
 # web3.py
@@ -81,9 +68,9 @@ Requires-Dist: py-geth >=4.1.0 ; extra == 'tester'
 
 A Python library for interacting with Ethereum.
 
--   Python 3.8+ support
+- Python 3.8+ support
 
----
+______________________________________________________________________
 
 ## Quickstart
 
@@ -101,6 +88,6 @@ guidelines for [contributing](https://web3py.readthedocs.io/en/latest/contributi
 then check out issues that are labeled
 [Good First Issue](https://github.com/ethereum/web3.py/issues?q=is%3Aissue+is%3Aopen+label%3A%22Good+First+Issue%22).
 
----
+______________________________________________________________________
 
 #### Questions on implementation or usage? Join the conversation on [discord](https://discord.gg/GHryRvPB84).