How do I get the most recent block in Web3? If it is a query you could have been asking your self, then you might be precisely the place it’s essential be! This Web3 tutorial will present you the right way to get the present block by timestamp utilizing Moralis. In reality, because of Moralis’ EVM API, all it takes is a single name to the ”get_date_to_block” endpoint whereas passing a date and chain as parameters:
from moralis import evm_api
api_key = "YOUR_API_KEY"
params = {
"date": "",
"chain": "eth",
}
consequence = evm_api.block.get_date_to_block(
api_key=api_key,
params=params,
)
print(consequence)
When working with the primary Web3 infrastructure supplier, it doesn’t should be tougher to get the present block based mostly on a timestamp than the above! If you wish to study extra in regards to the ”get_date_to_block” endpoint, try Moralis’ get block by date Web3 documentation.
For a extra detailed breakdown of the right way to implement this performance into an app, learn on as we present you the way to take action by means of an Ethereum Python implementation. What’s extra, keep in mind to register with Moralis in case you plan to hitch us all through this tutorial. Signing up is free, and also you want an account to comply with alongside!
Overview
In as we speak’s Web3 tutorial, we are going to illustrate the right way to get any block by constructing a Python software in three steps:
- Utilizing a Web3 get block perform – Moralis’ ”get_date_to_block” endpoint
- Establishing the Web3 get block by timestamp backend
- Constructing the Web3 get block frontend
By the tip of this tutorial, you’ll have your personal Python app finalized, enabling you to constantly get blocks based mostly on timestamps. If this sounds attention-grabbing and also you wish to get going instantly, click on right here to leap straight into the Web3 get block function tutorial!
When constructing decentralized purposes (dapps), platforms, and different Web3 initiatives, you’ll rapidly notice that you simply want entry to on-chain knowledge. For the reason that Web3 trade is blockchain-based, you possibly can think about that one piece of such info is block numbers. Getting this knowledge can assist you to, as an example, entry transactional knowledge at given instances. Because of this, this Web3 tutorial will present you the right way to get a block by a timestamp utilizing Moralis!
To make this course of as accessible as attainable, we can be using Moralis’ EVM API and the ”get_date_to_block” endpoint. That is considered one of many Web3 APIs provided by Moralis, and if you’re severe about stepping into the area, think about trying out further Moralis instruments. As an example, an incredible instance is the Web3 Streams API, permitting you to stream on-chain knowledge into your initiatives through Moralis webhooks!
Right here on the weblog, you too can discover subjects past getting blocks based mostly on timestamps. As an example, examine BNB testnet taps or try our information on Web3.py vs Web3.js!
Now, earlier than you proceed, keep in mind to enroll with Moralis, as it’s essential have an lively account to comply with alongside. Setting one up is free and solely takes just a few seconds!
Web3 Get Block Function Tutorial
Within the subsequent sections, we are going to kickstart this Web3 tutorial illustrating the right way to get a block quantity from any chain. Extra particularly, we are going to present you the right way to create a Python software enabling you to get the present block based mostly on a timestamp!
As an instance what you can be working in the direction of, you could find a print display screen of the app’s touchdown web page down under:
The app options three core components: two enter fields and a ”Get Block” button. To make use of the app, all it’s essential do is choose a time, date, and chain, adopted by hitting the button. In return, you must obtain a response just like the one proven under:
To have the ability to seamlessly get the present Web3 block, we can be utilizing Moralis’ EVM API and the ”get_date_to_block” endpoint to create this app. If this sounds thrilling, be a part of us as we cowl the entire course of from begin to end!
Should you want watching movies to study, you too can try the clip under from Moralis’ YouTube channel. Within the video, considered one of our Web3 builders gives a complete walkthrough of every step:
Now, let’s say you might be not sure what a Web3 get block function is. In that case, you possibly can learn extra about Moralis’ ”get_date_to_block” endpoint under the third step. In any other case, be a part of us as we begin by masking the required conditions within the following sub-section!
Conditions
Earlier than diving into this Web3 tutorial on the right way to get the present block by timestamp, you need to have the next prepared:
- Set up Moralis – Open a brand new terminal and set up Moralis by operating the next command:
pip set up moralis
- Set up Django and the Relaxation Framework – Run the terminal inputs under to put in Django and Relaxation:
pip set up django
pip set up djangorestframework django-cors-headers
Step 1: Utilizing a Web3 Get Block Perform – Moralis’ ”get_date_to_block” Endpoint
On this preliminary step, we are going to present a fast demo of Moralis’ ”get_date_to_block” endpoint. It will present you the right way to seamlessly use a Web3 perform to get a block by timestamp!
To get going, begin by establishing a brand new Django Python undertaking. Subsequent, create a ”providers.py” file and add the code under:
from moralis import evm_api
api_key = "YOUR_API_KEY"
params = {
"date": "",
"chain": "eth",
}
consequence = evm_api.block.get_date_to_block(
api_key=api_key,
params=params,
)
print(consequence)
From there, it’s essential configure the code by changing ”YOUR_API_KEY” along with your Moralis API key:
You may fetch your key by logging in to the Moralis admin panel and navigating to the ”Web3 APIs” tab:
Copy your key and enter it into the code. Lastly, you additionally want so as to add a date to the ”date” parameter. This should be a “Unix date” in milliseconds or a date string. As an example, it could possibly look one thing like this: ”1667823435”.
As soon as you might be achieved configuring the code, all that is still is operating the script. To take action, open a brand new terminal, enter ”python providers.py”, and hit enter. This could return a response just like the one proven under. Amongst different issues, the response incorporates the variety of the block closest to the timestamp, which is the second parameter:
{
"date": "2020-01-01T00:00:00+00:00",
"block": 9193266,
"timestamp": 1577836811,
"block_timestamp": "2022-01-03T22:59:39.000Z",
"hash": "0x9b559aef7ea858608c2e554246fe4a24287e7aeeb976848df2b9a2531f4b9171",
"parent_hash": "0x011d1fc45839de975cc55d758943f9f1d204f80a90eb631f3bf064b80d53e045"
}
That’s it! Congratulations, you now know to make use of a Web3 perform to get a block by timestamp!
Within the remaining two steps, we are going to present you the right way to implement this performance into an software. If this sounds attention-grabbing, be a part of us within the subsequent part as we cowl the backend code!
Step 2: Setting Up the Web3 Get Block By Timestamp Backend
To create the Web3 app used to get a block by timestamp, we can be utilizing an already-developed Python software template. So, the very first thing it’s essential do is go to the GitHub repository down under and clone the undertaking:
Full Web3 Get Block App Documentation – https://github.com/MoralisWeb3/youtube-tutorials/tree/fundamental/get-block-by-date
With a duplicate of the undertaking in your native listing, allow us to break down the backend code! First, we are able to go to ”providers.py” to see how the code differs from the preliminary step:
from moralis import evm_api
from dotenv import load_dotenv
import os
load_dotenv()
api_key = os.getenv("MORALIS_API_KEY")
def get_block_by_date(date, chain):
params = {
"date": date,
"chain": chain,
}
consequence = evm_api.block.get_date_to_block(
api_key=api_key,
params=params,
)
return consequence
The code in ”providers.py” remains to be liable for calling Moralis’ ”get_date_to_block” endpoint. Nevertheless, we modify it by defining the ”get_block_by_date()” perform, making the code extra dynamic.
The ”get_block_by_date()” perform takes two variables as arguments: ”date” and ”chain”. As such, we are able to implement logic enabling app customers to specify each these parameters.
We additionally take away the API key from this file, as displaying this worth is a safety threat. As such, it’s essential arrange a ”.env” file in your listing and create a brand new atmosphere variable:
export MORALIS_API_KEY = ”REPLACE_ME”
Within the snippet above, Don’t forget to interchange ”REPLACE_ME” along with your precise key.
With the ”providers.py” script prepared, we additionally make certain so as to add it to ”views.py”:
Lastly, from there, we open the ”urls.py” file and eventually add a brand new path:
However, that covers the important elements of the backend code! Allow us to transfer on to the third step of this Web3 get block tutorial and look nearer on the frontend!
Step 3: Constructing the Web3 Get Block Frontend
The very first thing we do is open the ”bundle.json” file, the place we make certain so as to add ”proxy” and ”axios”:
Subsequent, allow us to study the code in ”App.js”. Right here, the central perform is ”refreshBlockByDate()”:
const refreshBlockByDate = async () => {
await axios
.get(`/get_block?chain=${params.chain}&date=${date}`)
.then((res) => {
setBlockByDate(res.knowledge);
})
.catch((err) => console.log(err));
};
First, we use “axios” to connect with the backend, enabling us to name the ”get_block” endpoint whereas passing the chain and date as parameters. These two variables are fetched from the app’s UI, permitting customers to pick out a sequence and date. From there, the rest of the code is liable for calculating the Unix time, rendering the response and presenting it to the customers, and many others.
Lastly, earlier than launching and testing your Web3 get block app, it’s essential open a brand new terminal, ”cd” into the frontend folder, and set up the “axios” dependencies with the next command:
npm axios
Congratulations! You could have now created a Web3 Python software that may get a block by timestamp!
Should you at any level throughout this Web3 get block tutorial skilled any hassle, please try the video at first of the article, as this can reply any of your questions. You too can try Moralis’ get block by date Web3 documentation, explaining the ”get_date_to_block” endpoint in additional element!
What’s a Web3 Get Block Function?
As we briefly mentioned within the introduction, you typically want on-chain knowledge when creating dapps and different initiatives. One such piece of information is block numbers, which may be advantageous in a number of methods. As an example, block numbers can assist you get transaction knowledge at particular deadlines.
Nevertheless, querying the block quantity at a cut-off date is a difficult job, which is why builders profit from “Web3 get block” options. A Web3 get block function can assist you to simply fetch any block based mostly on a timestamp, and the very best various is Moralis’ ”get_date_to_block” endpoint.
When working with Moralis, you solely want a single API name to the ”get_date_to_block” endpoint. By visiting the official get block by date Web3 documentation, you possibly can attempt it out your self instantly within the browser, and it seems to be like this:
All it’s essential do is enter a sequence and a date:
From there, you possibly can click on on the ”Attempt It” button and obtain a response in return:
Should you appreciated this Web3 get block tutorial and what to take a look at comparable content material, we now have a few articles only for you. Discover ways to get Ethereum transaction particulars, or learn our ENS resolver tutorial! Additionally, discover the right way to implement Supabase authentication or discover ways to use the very best Polygon Mumbai faucet to execute check transactions earlier than launching on the mainnet!
Abstract – Web3 Get Block Function
How do you get the most recent block on Ethereum? The reply to this query is Moralis’ EVM API and the ”get_date_to_block” endpoint! Thanks to those growth sources, you possibly can create a Web3 Python software permitting you to get any block in three easy steps:
- Utilizing a Web3 get block perform – Moralis’ ”get_date_to_block” endpoint
- Establishing the Web3 get block by timestamp backend
- Constructing the Web3 get block frontend
On this tutorial, we lined the steps above. Consequently, if in case you have adopted alongside this far, you now know the right way to get any block by a timestamp and implement this performance right into a Web3 app. From right here, now you can use your newly acquired information to implement comparable performance into any future undertaking!
Should you loved this Web3 tutorial, try different excellent guides right here on Moralis’ Web3 weblog. As an example, think about studying our NodeJS Telegram bot tutorial or our glorious information answering the query, ”what’s a Solana pockets?”. Moreover, if you’re new to the trade and wish to study extra in regards to the underlying know-how, the next is the information for you: ”What’s Web3 know-how?”.
Additionally, think about enrolling in Moralis Academy, as that is the easiest way to develop into a more adept Web3 developer. The academy provides glorious blockchain programs on all ranges. As such, it doesn’t matter if you’re new to the area or have prior expertise; Moralis Academy has you lined. As an example, try the newbie course on Ethereum fundamentals to kickstart your journey!
Lastly, earlier than concluding this text, if you’re severe about changing into a blockchain developer, join with Moralis now. With an account, you possibly can leverage the complete energy of Web3 know-how to construct smarter and quicker!
