Ethereum: Adding a Delay to Asynchronous Coroutines

As asynchronous coroutines have become increasingly popular, they offer many benefits such as improved readability and maintainability. However, when it comes to fetching data in real-time, adding a delay can be crucial to avoid overloading the API with concurrent requests.

In this article, we will explore how to add a delay to asynchronous Ethereum coroutines using the “asyncio” library.

Why a Delay?

Before diving into the solution, let’s quickly discuss why adding a delay is necessary. When fetching historical data from Binance for every cryptocurrency pair in your database simultaneously, you are likely to face API bans due to excessive concurrent requests. The reason behind this ban is the API rate limitation, which restricts the number of requests you can make in a specific amount of time.

Solution: Adding a Delay

To add a delay in asynchronous Ethereum coroutines, we will use the « asyncio » library to create a custom asyncio event loop that waits for a specified amount of time before continuing. Here is an example code snippet:

import asyncio
class DelayedEthereumCoroutine:
def __init__(self, delay: float):
self.delay = delay
async def run(self, data):
await asyncio . sleep ( self . delay ) 




Wait for the specified amount of time
return data
async def main() :

Create an instance of our delayed coroutine with a 2 second delay
del_ = Delayed Ethereum Coroutine (2)

Fetch historical data from Binance using our deferred coroutine
async def fetch_data() :

Simulate an API request
import asyncio
await asyncio.sleep(1) 
Simulate an API call

Fetch historical data
return [ fetch_data ( ) for _ in range ( len ( data ) ) ]

Fetch historical data from Binance for each cryptocurrency pair at once
async def fetch_and_fetch_all() :
pairs = ["BTC/USDT", "ETH/BTC"]
results = await asyncio.gather(*[fetch_data() for pair in pairs]);

Run our main function, which waits for the delayed coroutine to complete before continuing
start_time = asyncio.get_event_loop().time();
del_ = Delayed Ethereum Coroutine (2)
result = wait for fetch_and_fetch_all()
end_time = asyncio.get_event_loop().time();
print(f"Time taken: {end_time - start_time} seconds")

Run the main function
asyncio.run(main())

In this example, we create a custom DelayedEthereumCoroutine class that takes a delay parameter. We then use an asynchronous main() function to fetch historical data from Binance using our delayed coroutine.

How ​​it works

Here is a step-by-step explanation of the code:

• We import the asyncio library and define our custom class DelayedEthereumCoroutine.

• In this class, we have a method __init__() that takes a parameter delay and stores it in an instance variable.

• The run() method is an asynchronous function that simulates the API request by sleeping for the specified duration (in seconds).

• In the main() function, we create an instance of our delayed coroutine with a 2-second delay using Del_ = DelayedEthereumCoroutine(2).

• We define another asynchronous function fetch_data() that simulates an API call.

• To fetch historical data from Binance for each cryptocurrency pair simultaneously, we use the asyncio.gather() function to run multiple instances of our delayed coroutine in parallel.

• Finally, we get the start and end times using asyncio.get_event_loop().time(), which gives us the current time before and after the delay.

Conclusion

Adding a delay is crucial when fetching historical data from Binance simultaneously in asynchronous Ethereum coroutines.