code-alongs/Introduction_to_Accessing_Blockchain_Data.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yz6K3L3lD4FQ"
      },
      "source": [
        "# Introduction to Accessing Blockchain Data\n",
        "A Code Along to understand and access basic blockchain data. We will use a public hosted blockchain node to access network, account, block and transaction details. \n",
        "\n",
        "**Author: Harish Raisinghani, DevRel @ Covalent**. https://twitter.com/harish_yvr\n",
        "\n",
        "## Web3.py Setup\n",
        "\n",
        "We will be using [Web3.py](https://web3py.readthedocs.io/en/stable/quickstart.html), a comprehensive Python library for interacting with the programmable [Ethereum](https://ethereum.org/) blockchain, in this Code Along. \n",
        "\n",
        "We install the library using `pip`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "SiyuxA0qDvPX"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Defaulting to user installation because normal site-packages is not writeable\n",
            "Collecting web3\n",
            "  Downloading web3-6.1.0-py3-none-any.whl (570 kB)\n",
            "\u001b[K     |████████████████████████████████| 570 kB 1.8 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting aiohttp>=3.7.4.post0\n",
            "  Downloading aiohttp-3.8.4-cp39-cp39-macosx_10_9_x86_64.whl (360 kB)\n",
            "\u001b[K     |████████████████████████████████| 360 kB 5.8 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting eth-abi>=4.0.0\n",
            "  Downloading eth_abi-4.0.0-py3-none-any.whl (28 kB)\n",
            "Collecting hexbytes>=0.1.0\n",
            "  Downloading hexbytes-0.3.0-py3-none-any.whl (6.4 kB)\n",
            "Collecting jsonschema>=4.0.0\n",
            "  Downloading jsonschema-4.17.3-py3-none-any.whl (90 kB)\n",
            "\u001b[K     |████████████████████████████████| 90 kB 10.7 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting eth-typing>=3.0.0\n",
            "  Downloading eth_typing-3.3.0-py3-none-any.whl (6.3 kB)\n",
            "Collecting protobuf>=4.21.6\n",
            "  Downloading protobuf-4.22.1-cp37-abi3-macosx_10_9_universal2.whl (397 kB)\n",
            "\u001b[K     |████████████████████████████████| 397 kB 9.6 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting websockets>=10.0.0\n",
            "  Downloading websockets-11.0.1-cp39-cp39-macosx_10_9_x86_64.whl (120 kB)\n",
            "\u001b[K     |████████████████████████████████| 120 kB 11.4 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting requests>=2.16.0\n",
            "  Using cached requests-2.28.2-py3-none-any.whl (62 kB)\n",
            "Collecting eth-utils>=2.1.0\n",
            "  Downloading eth_utils-2.1.0-py3-none-any.whl (24 kB)\n",
            "Collecting eth-hash[pycryptodome]>=0.5.1\n",
            "  Downloading eth_hash-0.5.1-py3-none-any.whl (9.0 kB)\n",
            "Collecting eth-account>=0.8.0\n",
            "  Downloading eth_account-0.8.0-py3-none-any.whl (102 kB)\n",
            "\u001b[K     |████████████████████████████████| 102 kB 18.5 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting lru-dict>=1.1.6\n",
            "  Downloading lru_dict-1.1.8-cp39-cp39-macosx_10_9_x86_64.whl (9.9 kB)\n",
            "Collecting frozenlist>=1.1.1\n",
            "  Downloading frozenlist-1.3.3-cp39-cp39-macosx_10_9_x86_64.whl (36 kB)\n",
            "Collecting multidict<7.0,>=4.5\n",
            "  Downloading multidict-6.0.4-cp39-cp39-macosx_10_9_x86_64.whl (29 kB)\n",
            "Collecting charset-normalizer<4.0,>=2.0\n",
            "  Using cached charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_x86_64.whl (124 kB)\n",
            "Collecting yarl<2.0,>=1.0\n",
            "  Downloading yarl-1.8.2-cp39-cp39-macosx_10_9_x86_64.whl (61 kB)\n",
            "\u001b[K     |████████████████████████████████| 61 kB 29.5 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting async-timeout<5.0,>=4.0.0a3\n",
            "  Downloading async_timeout-4.0.2-py3-none-any.whl (5.8 kB)\n",
            "Collecting attrs>=17.3.0\n",
            "  Downloading attrs-22.2.0-py3-none-any.whl (60 kB)\n",
            "\u001b[K     |████████████████████████████████| 60 kB 6.4 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting aiosignal>=1.1.2\n",
            "  Downloading aiosignal-1.3.1-py3-none-any.whl (7.6 kB)\n",
            "Collecting parsimonious<0.10.0,>=0.9.0\n",
            "  Downloading parsimonious-0.9.0.tar.gz (48 kB)\n",
            "\u001b[K     |████████████████████████████████| 48 kB 15.3 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting eth-rlp<1,>=0.3.0\n",
            "  Downloading eth_rlp-0.3.0-py3-none-any.whl (5.0 kB)\n",
            "Collecting eth-keys<0.5,>=0.4.0\n",
            "  Downloading eth_keys-0.4.0-py3-none-any.whl (21 kB)\n",
            "Collecting rlp<4,>=1.0.0\n",
            "  Downloading rlp-3.0.0-py2.py3-none-any.whl (20 kB)\n",
            "Collecting bitarray<3,>=2.4.0\n",
            "  Downloading bitarray-2.7.3-cp39-cp39-macosx_10_9_x86_64.whl (120 kB)\n",
            "\u001b[K     |████████████████████████████████| 120 kB 14.2 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting eth-keyfile<0.7.0,>=0.6.0\n",
            "  Downloading eth_keyfile-0.6.1-py3-none-any.whl (6.5 kB)\n",
            "Collecting pycryptodome<4,>=3.6.6\n",
            "  Downloading pycryptodome-3.17-cp35-abi3-macosx_10_9_x86_64.whl (1.6 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.6 MB 11.4 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting cytoolz>=0.10.1\n",
            "  Downloading cytoolz-0.12.1-cp39-cp39-macosx_10_9_x86_64.whl (410 kB)\n",
            "\u001b[K     |████████████████████████████████| 410 kB 15.1 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting toolz>=0.8.0\n",
            "  Downloading toolz-0.12.0-py3-none-any.whl (55 kB)\n",
            "\u001b[K     |████████████████████████████████| 55 kB 10.1 MB/s eta 0:00:01\n",
            "\u001b[?25hCollecting pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0\n",
            "  Downloading pyrsistent-0.19.3-cp39-cp39-macosx_10_9_universal2.whl (82 kB)\n",
            "\u001b[K     |████████████████████████████████| 82 kB 4.0 MB/s  eta 0:00:011\n",
            "\u001b[?25hCollecting regex>=2022.3.15\n",
            "  Downloading regex-2023.3.23-cp39-cp39-macosx_10_9_x86_64.whl (294 kB)\n",
            "\u001b[K     |████████████████████████████████| 294 kB 30.1 MB/s eta 0:00:0101\n",
            "\u001b[?25hCollecting urllib3<1.27,>=1.21.1\n",
            "  Using cached urllib3-1.26.15-py2.py3-none-any.whl (140 kB)\n",
            "Collecting certifi>=2017.4.17\n",
            "  Using cached certifi-2022.12.7-py3-none-any.whl (155 kB)\n",
            "Collecting idna<4,>=2.5\n",
            "  Using cached idna-3.4-py3-none-any.whl (61 kB)\n",
            "Building wheels for collected packages: parsimonious\n",
            "  Building wheel for parsimonious (setup.py) ... \u001b[?25ldone\n",
            "\u001b[?25h  Created wheel for parsimonious: filename=parsimonious-0.9.0-py3-none-any.whl size=44316 sha256=4533a7344c8b736626f5cbc5492e5e102dc5ad6af8ff53fc91df8108309b25d7\n",
            "  Stored in directory: /Users/harish/Library/Caches/pip/wheels/98/f5/bb/28d71f018fa6da82e7488371edcbc506add6b3cff02ed9d6fd\n",
            "Successfully built parsimonious\n",
            "Installing collected packages: toolz, eth-typing, eth-hash, cytoolz, regex, eth-utils, rlp, pycryptodome, parsimonious, multidict, idna, hexbytes, frozenlist, eth-keys, yarl, urllib3, pyrsistent, eth-rlp, eth-keyfile, eth-abi, charset-normalizer, certifi, bitarray, attrs, async-timeout, aiosignal, websockets, requests, protobuf, lru-dict, jsonschema, eth-account, aiohttp, web3\n",
            "Successfully installed aiohttp-3.8.4 aiosignal-1.3.1 async-timeout-4.0.2 attrs-22.2.0 bitarray-2.7.3 certifi-2022.12.7 charset-normalizer-3.1.0 cytoolz-0.12.1 eth-abi-4.0.0 eth-account-0.8.0 eth-hash-0.5.1 eth-keyfile-0.6.1 eth-keys-0.4.0 eth-rlp-0.3.0 eth-typing-3.3.0 eth-utils-2.1.0 frozenlist-1.3.3 hexbytes-0.3.0 idna-3.4 jsonschema-4.17.3 lru-dict-1.1.8 multidict-6.0.4 parsimonious-0.9.0 protobuf-4.22.1 pycryptodome-3.17 pyrsistent-0.19.3 regex-2023.3.23 requests-2.28.2 rlp-3.0.0 toolz-0.12.0 urllib3-1.26.15 web3-6.1.0 websockets-11.0.1 yarl-1.8.2\n",
            "\u001b[33mWARNING: You are using pip version 21.2.4; however, version 23.0.1 is available.\n",
            "You should consider upgrading via the '/Library/Developer/CommandLineTools/usr/bin/python3 -m pip install --upgrade pip' command.\u001b[0m\n",
            "Note: you may need to restart the kernel to use updated packages.\n"
          ]
        }
      ],
      "source": [
        "pip install web3"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "2MTGEpwSFW6c"
      },
      "source": [
        "## Connect to a Hosted Node Provider\n",
        "\n",
        "In order to read data from blockchains, you can either:\n",
        "\n",
        "1. Run your own node on that blockchain, download the entire ledger, execute the transactions and fetch the data from your node. \n",
        "\n",
        "2. Use a hosted node provider who manage the infrastructure for you\n",
        "\n",
        "> Deeper dive: Set up your own Ethereum node following [this guide.](https://ethereum.org/en/developers/docs/nodes-and-clients/run-a-node/)\n",
        "\n",
        "3. Use a data provider like [Covalent](https://www.covalenthq.com/platform/) that offers APIs to read data from blockchains\n",
        "\n",
        "Examples of hosted Ethereum node providers are listed here: https://ethereumnodes.com/ . This is just a small set but does cover many of the major providers. \n",
        "\n",
        "In this Code Along, we will use the [Pocket Network](https://pokt.network/\n",
        " ) hosted node provider which offers a comprehensive [list of public nodes](https://docs.pokt.network/use/public-rpc/). Note the URL for accessing the Ethereum Mainnet node: https://eth-rpc.gateway.pokt.network\n",
        "\n",
        " The following code configures our `web3.py` library to use the Pocket Network as our node provider:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7ab0z9ayE7Yw",
        "outputId": "25055bf9-0113-4bdc-eb7d-cbe53508d4cb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<web3.main.Web3 at 0x10e05c820>"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from web3 import Web3\n",
        "\n",
        "eth_mainnet_provider = 'https://eth-rpc.gateway.pokt.network'\n",
        "\n",
        "w3_mainnet = Web3(Web3.HTTPProvider(eth_mainnet_provider))\n",
        "\n",
        "# Check that we have a web3 object\n",
        "w3_mainnet"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "lYAmDjGhFgZK"
      },
      "source": [
        "\n",
        "## JSON-RPC\n",
        "Assuming that you are familiar with the `JSON` data format, `JSON-RPC` is a remote procedure call (RPC) protocol which follows a [specification](https://www.jsonrpc.org/specification) defining standards around data structures and processing in distributed computing.\n",
        "\n",
        "The Ethereum protocol implements the [**Ethereum JSON-RPC**](https://ethereum.github.io/execution-apis/api-documentation/) specification - a standard collection of methods that all Ethereum clients implement so that applications can expect some consistency regardless of the node or client implementation.  \n",
        "\n",
        "Examples of Ethereum JSON-RPC methods include:\n",
        "\n",
        "* `eth_chainId`: Returns the unique chain ID of the current blockchain network\n",
        "* `eth_gasPrice`: Returns the current price per gas in wei\n",
        "* `eth_blockNumber`: Returns the sequence number of the most recent block\n",
        "* `eth_getBalance`: Returns the balance of the account of a given address\n",
        "\n",
        "For the full list of Ethereum JSON-RPC methods, see: https://ethereum.github.io/execution-apis/api-documentation/.\n",
        "\n",
        "\n",
        "## JSON-RPC & `web3.eth`\n",
        "\n",
        "The Web3.py library uses the `web3.eth` API object for interacting with the Ethereum blockchain and thus provides a mapping to Ethereum JSON-RPC methods. \n",
        "\n",
        "![Web3.py JSON-RPC Setup](https://i.imgur.com/QOqFqJ3l.png)\n",
        "\n",
        "The `web3.eth` object exposes both *properties* and *methods* to interact with the JSON-RPC APIs under the `eth_` namespace.\n",
        "\n",
        "For example the following shows JSON-RPC methods mapped to to `web3.eth` properties and methods:\n",
        "\n",
        "### Properties:\n",
        "*   `eth_chainId` -> `web3.eth.chain_id`\n",
        "*   `eth_gasPrice` -> `web3.eth.gas_price`\n",
        "\n",
        "### Methods:\n",
        "*   `eth_blockNumber` -> `web3.eth.get_block_number()`\n",
        "*   `eth_getBalance` -> `web3.eth.get_balance(<address>)`\n",
        "\n",
        "\n",
        "See the full list of in `web3.eth` mappings [here](https://web3py.readthedocs.io/en/stable/web3.eth.html#methods).\n",
        "\n",
        "Let us try a few examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4P_crFpFJMwZ",
        "outputId": "0f5c48a6-7e2d-4422-df9f-55e109acd04a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "w3_mainnet.eth.chain_id"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-gc-3YK-YRQY"
      },
      "source": [
        "Chain IDs are unique blockchain identifiers for Ethereum-compatible blockchain networks. For example, Ethereum Mainnet has a chain ID of 1 while Polygon Mainnet has a chain ID of 137. \n",
        "\n",
        "You can find the full list of Ethereum-compatible blockchain's chain IDs (including both mainnets and testnets) at: https://chainlist.org/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "juxHu8DmFpWz",
        "outputId": "b69e4dff-538c-43d0-c395-32f1b6fb32af"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "19909730434"
            ]
          },
          "execution_count": 33,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "w3_mainnet.eth.gas_price"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i0waXX-6Flr9",
        "outputId": "26d6d427-a8af-410c-f94a-74a1ba4ff09c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "15454222"
            ]
          },
          "execution_count": 29,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "w3_mainnet.eth.get_block_number()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m76VMcNAF0cn",
        "outputId": "4e58fe8d-7bac-4e1b-ad45-17550f4234f7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "563418429638025147\n"
          ]
        }
      ],
      "source": [
        "balance_wei = w3_mainnet.eth.get_balance('demo.eth')\n",
        "print(balance_wei)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4jlI9MA6HGOm"
      },
      "source": [
        "A couple of key things to note:\n",
        "\n",
        "1. Ethereum blockchain values, such as the gas price or account balance are commonly denominated in unit called `wei`, which is the smallest unit of ether (ETH) equal to `10^-18`. You can find the full `wei` to `ether` table at: https://gwei.io/. \n",
        "\n",
        "2. The `eth.get_balance()` takes either an alphanumeric account address OR an [Ethereum Name Service](https://ens.domains/) domain (which gets resolved to the underlying account address). \n",
        "\n",
        "> Deeper dive - search and set your own ENS domain (fee required): https://app.ens.domains/\n",
        "\n",
        "So to convert our balance from `wei` to `ether` we can divide `balance_wei` by `10^18`)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yFemjo-5HFyv",
        "outputId": "74877925-e23d-4d67-b5ae-15e16d6dd342"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.6456238284254397\n"
          ]
        }
      ],
      "source": [
        "balance = balance_wei / (10**18)\n",
        "print(balance)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "-MzaE_xutLV8"
      },
      "source": [
        "OR we can use the built in `.from_wei()` method and specify the `ether` unit:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rhU-LYZLHNEd",
        "outputId": "2d5c1124-cbbe-4bcf-9ddf-6e86b14ebf9c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.563418429638025147\n"
          ]
        }
      ],
      "source": [
        "balance = w3_mainnet.from_wei(balance_wei, 'ether')\n",
        "print(balance)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "So this is interesting to explore blockchain data effectively like command line, but wouldn't it be nice to have a front-end that we can use? Enter the **Block Explorer**. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kB5K9iBFuGrg"
      },
      "source": [
        "## Block Explorers\n",
        "\n",
        "![Etherscan](https://info.etherscan.com/content/images/2019/12/image-1.png)\n",
        "\n",
        "A front-end that allows users to explore blockchain data without having to manually make API calls with code are called **block explorers**. The most popular Ethereum block explorer is [Etherscan](https://etherscan.io/). There, we can compare the results to the `web3.eth` API calls made above. \n",
        "\n",
        "> Q) What are some other block explorers for Ethereum mainnet and testnets?"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "j2Xfmv9RITfT"
      },
      "source": [
        "## Transactions & Transaction Hashes\n",
        "\n",
        "The state of the Ethereum blockchain changes as a result of **transactions** or data (signed messages) that is committed to the blockchain by an account. Think of blockchains like Ethereum as global [singleton](https://en.wikipedia.org/wiki/Singleton_pattern) state machines where transactions are the driver changing the machine's state. Smart contracts or programs on blockchains *do not run on their own*. Everything starts with a transaction.\n",
        "\n",
        "> Deeper dive - learn more about different [types of transactions](https://www.covalenthq.com/docs/unified-api/guides/understanding-blockchain-transactions-with-covalent/)\n",
        "\n",
        "Transactions on the blockchain are recorded as transaction hashes. In this Code Along, we are simply accessing existing transaction data through transaction hashes, not creating new transactions (for a later Code Along).\n",
        "\n",
        "\n",
        "### Get a Transaction by Hash\n",
        "We can use the Block Explorer to find a transaction hash and then we can see all the key details of a transaction by using the [`eth_getTransactionByHash`](https://web3py.readthedocs.io/en/stable/web3.eth.html#web3.eth.Eth.get_transaction) JSON-RPC method. \n",
        "\n",
        "Let us take the following transaction hash: [0x7bebda592bfb8923b80f5498c58a8a5abf2c689feeafd8a6c46fc8626b249c56](https://etherscan.io/tx/0x7bebda592bfb8923b80f5498c58a8a5abf2c689feeafd8a6c46fc8626b249c56) which is an example of a basic ETH transfer/payment:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zJdV_DqCHyuf",
        "outputId": "f90456d7-17ea-42e3-b236-821df16efcd7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "AttributeDict({'accessList': [],\n",
              " 'blockHash': HexBytes('0xe8ed5b0aaabc311e05b89c76ea236f91d8107529d7aa5d8084d151adac1a8566'),\n",
              " 'blockNumber': 15454264,\n",
              " 'chainId': 1,\n",
              " 'from': '0x347334073a11B74C0029C7B9Cf43a56dCB0d7c1C',\n",
              " 'gas': 21000,\n",
              " 'gasPrice': 22035434010,\n",
              " 'hash': HexBytes('0x7bebda592bfb8923b80f5498c58a8a5abf2c689feeafd8a6c46fc8626b249c56'),\n",
              " 'input': '0x',\n",
              " 'maxFeePerGas': 24709787665,\n",
              " 'maxPriorityFeePerGas': 1500000000,\n",
              " 'nonce': 19,\n",
              " 'r': HexBytes('0xfaf61893b260fb3522f328e53be69703ffa829cf2ca24954c84a5a7d365d4c9b'),\n",
              " 's': HexBytes('0x3ea579fcf16eefb9447c788f20751c9c2b3be5fb63b76fc95c4af00e88ef031c'),\n",
              " 'to': '0x31532aA0137b1c1E1b9164C3Fe11634F4218c5b7',\n",
              " 'transactionIndex': 174,\n",
              " 'type': 2,\n",
              " 'v': 1,\n",
              " 'value': 50000000000000000})"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "w3_mainnet.eth.get_transaction('0x7bebda592bfb8923b80f5498c58a8a5abf2c689feeafd8a6c46fc8626b249c56')"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "LOjVIRw3L_WQ"
      },
      "source": [
        "We see the following key details:\n",
        "- `nonce`: a sequence number issued by the sending Ethereum account indicating the number of previous transactions to prevent message replay\n",
        "- `blockNumber`: the block where this transaction was placed in\n",
        "- `from`: the sending Ethereum account\n",
        "- `to`: the receiving Ethereum account\n",
        "- `value`: the amount of ETH transferred (in Wei)\n",
        "- `input`: any data sent with the transaction\n",
        "- `gas`: the amount of gas provided by the sending Ethereum account\n",
        "- `gasPrice`: the price in Wei per unit of gas provided by the sending Ethereum account\n",
        "- `r`, `s`, `v` make up the components of the sender's encrypted digital signature\n",
        "\n",
        "This is effectively the structure of any Ethereum-based transaction. In this example, there is a `value` amount but no `input` data so this represents a payment transaction using the native currency of the blockchain (i.e. ETH on Ethereum).\n",
        "\n",
        "If the transaction involves a smart contract function, the details of the function being invoked are passed in the `input` field. \n",
        "\n",
        "\n",
        "### Get a Transaction by Block\n",
        "We can also get the number of transactions for a given block and then pass an index value to get a specific transaction within a block. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LkX9Hnm4Oiis",
        "outputId": "bf47f1fb-7939-4930-aedf-61e0e5c5d4be"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "205"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "w3_mainnet.eth.get_block_transaction_count(15454264)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "13Oox00bL-90",
        "outputId": "031f0bd0-9943-47f5-afdc-81c34476b80b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "AttributeDict({'accessList': [],\n",
              " 'blockHash': HexBytes('0xe8ed5b0aaabc311e05b89c76ea236f91d8107529d7aa5d8084d151adac1a8566'),\n",
              " 'blockNumber': 15454264,\n",
              " 'chainId': 1,\n",
              " 'from': '0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8',\n",
              " 'gas': 250000,\n",
              " 'gasPrice': 21535434010,\n",
              " 'hash': HexBytes('0x88824a6cfaf3f02edb0d36efe46f918789dbc3ec26c2ef36b973e1a5ac9b0fa7'),\n",
              " 'input': '0x',\n",
              " 'maxFeePerGas': 32946580402,\n",
              " 'maxPriorityFeePerGas': 1000000000,\n",
              " 'nonce': 44876480,\n",
              " 'r': HexBytes('0x8794af6856ae07fbb843ab867431a4f7afce319300a056996288526499d0f538'),\n",
              " 's': HexBytes('0x482f0916443ac3d7da0f758f8d3abd8d21f7c9a7c3ad2d034639ab8f7d8250b3'),\n",
              " 'to': '0x587Ea10544Ad3B22f08232c1146cC61c54566c36',\n",
              " 'transactionIndex': 0,\n",
              " 'type': 2,\n",
              " 'v': 1,\n",
              " 'value': 82393545439714279})"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Fetch the first transaction in block 15454264 using an index value of 0\n",
        "w3_mainnet.eth.get_transaction_by_block(15454264,0)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "> Deeper dive - learn more about [gas fees](https://ethereum.org/en/developers/docs/gas/#pre-london) including `maxFeePerGas` and `maxPriorityFeePerGas` values."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "kfMXTVgnPUB5"
      },
      "source": [
        "## Summary\n",
        "So we have covered how to access basic blockchain data - blockchain details, account balances and individual and block transactions. \n",
        "\n",
        "In the next Code Along, we look at data generated by smart contracts and in particular, custom fungible tokens (alt coins such as stablecoins, utility coins, asset coins, etc..) which are referred to as ERC20 standard tokens. This means that all tokens created under the ERC20 standard use the same smart contract interface and hence can be traded seamlessly. "
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.8.2 64-bit",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.6"
    },
    "vscode": {
      "interpreter": {
        "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}