strideutils 0.3.6__tar.gz → 0.3.7__tar.gz

{strideutils-0.3.6 → strideutils-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strideutils
-Version: 0.3.6
+Version: 0.3.7
 Summary: 
 Author: Your Name
 Author-email: you@example.com

{strideutils-0.3.6 → strideutils-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "strideutils"
-version = "0.3.6"
+version = "0.3.7"
 description = ""
 authors = ["Your Name <you@example.com>"]
 readme = "README.md"

{strideutils-0.3.6 → strideutils-0.3.7}/strideutils/stride_requests.py

@@ -811,64 +811,67 @@ def generate_vesting_account(
 
 
 def get_block_height_in_past(
-    time_in_past: datetime.timedelta = datetime.timedelta(hours=24),
-    max_acceptable_error_seconds: int = 60 * 5,
+    target_time: Optional[datetime.datetime] = None,
+    target_time_offset: Optional[datetime.timedelta] = None,
+    error_tolerance: datetime.timedelta = datetime.timedelta(minutes=5),
     seconds_per_block: int = 6,
-    prev_time: Optional[str] = None,
-    verbose: bool = False,
     rpc_endpoint: str = config.stride.rpc_endpoint,
 ) -> int:
     """
     Gets the block height at a specified time by binary searching at different heights
 
     Args:
-        time_in_past: target time to search for
-        max_acceptable_error_seconds: max time delta before the height is considered find
+        target_time (datetime): the target time to search for
+            (e.g. search for the block at time 2024-01-01 01:00:00 UTC)
+        target_time_offset (timedelta): the target time to search for,
+            defined as an offset from the current time
+            (e.g. search for the block 24 hours ago)
+        error_tolerance (timedelta): max time delta before the height is considered found
         seconds_per_block: block time to use for the estimation start
-        prev_time: Optional time to start the search at (instead of using time_in_past)
 
     Returns:
         The block height at the specified time
     """
+    # Get the current time and latest block height
+    current_time = datetime.datetime.now(tz=datetime.timezone.utc)
     latest_block = get_latest_block(rpc_endpoint=rpc_endpoint)
 
-    # set parameters so we can search for the block height
-    blocks_per_day = (24 * 60 * 60) // seconds_per_block
-    if prev_time is not None:
-        if type(prev_time) is str:
-            prev_time: datetime.datetime = pd.to_datetime(prev_time)  # type: ignore
-        ts = (datetime.datetime.utcnow() - cast(datetime.datetime, prev_time)).total_seconds()
-        num_days_back = ts / (60 * 60 * 24)
-        time_in_past = datetime.timedelta(seconds=ts)
+    # Depending on whether the target time or target_time_offset was used,
+    # calculate the parameter that was not provided
+    if target_time and not target_time_offset:
+        target_time_offset = current_time - target_time
+    elif target_time_offset and not target_time:
+        target_time = current_time - target_time_offset
     else:
-        num_days_back = time_in_past.total_seconds() / (60 * 60 * 24)
-    blocks_in_past = int(num_days_back * blocks_per_day)
-    time_estimate_error = float(100000)
-
-    current_time = datetime.datetime.utcnow()
-
-    # do an iterative search to find the block
-    while abs(time_estimate_error) > max_acceptable_error_seconds:
-        backwards_looking_height = latest_block - blocks_in_past
-        backwards_looking_time = get_block_time(backwards_looking_height, rpc_endpoint=rpc_endpoint)
-        time_estimate_error = (current_time - backwards_looking_time - time_in_past).total_seconds()
-        error_in_blocks = time_estimate_error / seconds_per_block
-        blocks_in_past -= int(error_in_blocks)
-        if verbose:
-            print("\tEstimated block: {}".format(backwards_looking_height))
-            print("\tEstimated time: {}".format(backwards_looking_time))
-            print("\tError in blocks: {}".format(error_in_blocks))
-            print("\tTotal Seconds: {}".format(time_estimate_error))
-            print("\t-------------------------")
-    block_last_day = latest_block - blocks_in_past
-    return block_last_day
-
-
-def get_block_height_one_day_ago(verbose: bool = False) -> int:
+        raise ValueError("Either target time or target time offset must be specified (but not both)")
+
+    # Using the target offset, determine the block delta to start our search, based
+    # on the estimated block time
+    blocks_in_past = int(target_time_offset.total_seconds() / seconds_per_block)
+    estimated_height = latest_block - blocks_in_past
+
+    # Continually loop over the following until we find a block that lines up with
+    # our target time (within our margin of error)
+    #  - Guess a height
+    #  - Find the time at that height
+    #  - Check if the time is close enough to our target
+    #  - Refine our block height guess and repeat
+    while True:
+        estimated_time = get_block_time(estimated_height, rpc_endpoint=rpc_endpoint)
+
+        time_error = target_time.timestamp() - estimated_time.timestamp()
+        if abs(time_error) < error_tolerance.total_seconds():
+            return estimated_height
+
+        blocks_correction = int(time_error / seconds_per_block)
+        estimated_height += blocks_correction
+
+
+def get_block_height_one_day_ago() -> int:
     """
     Get the block height from 1 day ago
     """
-    return get_block_height_in_past(datetime.timedelta(hours=24), verbose=verbose)
+    return get_block_height_in_past(target_time_offset=datetime.timedelta(hours=24))
 
 
 def get_sttoken_apr(token: str) -> Optional[float]: