strideutils 0.3.6__tar.gz → 0.3.15__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strideutils
-Version: 0.3.6
+Version: 0.3.15
 Summary: 
 Author: Your Name
 Author-email: you@example.com
@@ -9,6 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: bech32 (>=1.2.0)
+Requires-Dist: boto3 (>=1.34.115,<2.0.0)
 Requires-Dist: google-api-python-client (>=2.100.0)
 Requires-Dist: google-auth-httplib2 (>=0.1.1)
 Requires-Dist: google-auth-oauthlib (>=1.1.0)

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "strideutils"
-version = "0.3.6"
+version = "0.3.15"
 description = ""
 authors = ["Your Name <you@example.com>"]
 readme = "README.md"
@@ -24,6 +24,7 @@ tabulate = ">=0.9.0"
 pyyaml = ">=6.0.1"
 python-dateutil = ">=2.8.2"
 pycryptodome = ">=3.20.0"
+boto3 = "^1.34.115"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.1.1"

{strideutils-0.3.6 → strideutils-0.3.15}/strideutils/coingecko.py

@@ -12,6 +12,7 @@ from strideutils.stride_config import config
 
 COINGECKO_ENDPOINT = "https://pro-api.coingecko.com/"
 COINGECKO_PRICE_QUERY = "api/v3/simple/price?ids={ticker_id}&vs_currencies=usd"
+COINGECKO_TVL_QUERY = "api/v3/coins/{ticker_id}"
 
 
 def get_coingecko_name(chain_config: stride_config.ChainConfig) -> str:
@@ -31,7 +32,6 @@ def get_token_price(
 ):
     """
     Reads token price from coingecko
-    If a redis_client is provided, then store the value.
     """
     # TODO: Consider using the coingecko ID for stTokens instead of the redemption rate
     # Get redemption rate for calculating st token prices
@@ -53,6 +53,23 @@ def get_token_price(
     return price
 
 
+def get_tvl(
+    chain_config: stride_config.ChainConfig,
+    api_token: str = config.COINGECKO_API_TOKEN,
+    cache_response: bool = False,
+) -> float:
+    """
+    Fetch TVL from coingecko in USD
+    """
+    coingecko_name = get_coingecko_name(chain_config)
+    endpoint = COINGECKO_ENDPOINT + COINGECKO_TVL_QUERY.format(ticker_id=coingecko_name)
+    headers = {'x-cg-pro-api-key': api_token}
+
+    # The data structure is huge https://docs.coingecko.com/reference/coins-id
+    response = stride_requests.request(endpoint, headers=headers, cache_response=cache_response)
+    return float(response['market_data']['market_cap']['usd'])
+
+
 def get_token_price_history(token: str, num_days=90, use_key=False, memo={}) -> pd.Series:
     """
     returns a Pandas Series with token price data going back num_days
@@ -62,17 +79,18 @@ def get_token_price_history(token: str, num_days=90, use_key=False, memo={}) ->
     price_key = (token, num_days)
     if price_key not in memo:
         tstr = get_coingecko_name(config.get_chain(ticker=token))
-        rurl = f"https://api.coingecko.com/api/v3/coins/{tstr}/market_chart?vs_currency=usd&days={num_days}"
-        rel_headers = {"x-cg-pro-api-key": config.COINGECKO_API_TOKEN}
-        if not use_key:
-            rel_headers = None
+        rurl = (
+            f"https://api.coingecko.com/api/v3/coins/{tstr}/market_chart?vs_currency=usd&days={num_days}"  # noqa:E231
+        )
+        rel_headers = {"x-cg-pro-api-key": config.COINGECKO_API_TOKEN} if use_key else None
+
         r = requests.get(
             rurl,
             headers=rel_headers,
         )
         assert r.status_code == 200
         out_df = pd.DataFrame(r.json()["prices"])
-        out_df.columns = ["time", "price"]
+        out_df.columns = pd.Index(["time", "price"])
         out_df["time"] = pd.to_datetime(out_df["time"], unit="ms")
         out_df["price"] = out_df["price"].astype(float)
         out_df.set_index("time", inplace=True)
@@ -89,17 +107,18 @@ def get_token_volume_history(token: str, num_days=90, use_key=False, memo={}) ->
     volume_key = (token, num_days)
     if volume_key not in memo:
         tstr = get_coingecko_name(config.get_chain(ticker=token))
-        rurl = f"https://api.coingecko.com/api/v3/coins/{tstr}/market_chart?vs_currency=usd&days={num_days}"
-        rel_headers = {"x-cg-pro-api-key": config.COINGECKO_API_TOKEN}
-        if not use_key:
-            rel_headers = None
+        rurl = (
+            f"https://api.coingecko.com/api/v3/coins/{tstr}/market_chart?vs_currency=usd&days={num_days}"  # noqa:E231
+        )
+        rel_headers = {"x-cg-pro-api-key": config.COINGECKO_API_TOKEN} if use_key else None
+
         r = requests.get(
             rurl,
             headers=rel_headers,
         )
         assert r.status_code == 200
         out_df = pd.DataFrame(r.json()["total_volumes"])
-        out_df.columns = ["time", "volume"]
+        out_df.columns = pd.Index(["time", "volume"])
         out_df["time"] = pd.to_datetime(out_df["time"], unit="ms")
         out_df["volume"] = out_df["volume"].astype(float)
         out_df.set_index("time", inplace=True)

{strideutils-0.3.6 → strideutils-0.3.15}/strideutils/config_examples/strideutils_secrets.yaml.example

@@ -21,4 +21,8 @@ SLACK_PACKET_FAILURE_CHANNEL_ID:
 NUMIA_API_TOKEN:
 UPSTASH_PUBLIC_PASSWORD:
 UPSTASH_STRIDE_FRONTEND_PASSWORD:
-UPSTASH_STRIDE_BACKEND_PASSWORD:
+UPSTASH_STRIDE_BACKEND_PASSWORD:
+
+# AWS
+AWS_ACCESS_KEY_ID:
+AWS_SECRET_ACCESS_KEY:

{strideutils-0.3.6 → strideutils-0.3.15}/strideutils/exec_tx.py

@@ -33,10 +33,10 @@ def execute_tx(command: str, api_endpoint: str = config.stride.api_endpoint) ->
 
     tx_response = None
     response_success = False
-    raw_log = ""
+    raw_log = "Transaction not found on chain after one minute"  # default message
     if not error_out:
         event_filters = [(f"tx.hash='{tx_hash}'")]
-        for _ in range(15):
+        for _ in range(30):
             time.sleep(2)
             tx_response = stride_requests.get_txs(event_filters, api_endpoint)
             if tx_response['total'] != '0':

{strideutils-0.3.6 → strideutils-0.3.15}/strideutils/run_safely.py

@@ -29,13 +29,15 @@ def try_and_log_with_status(
         # (to cover cases where click was used)
         func_name = getattr(func, 'name', None) or func.__name__
         try:
+            print(f"Running {func_name}...", end="")
             func()
-            msg = [f':white_check_mark: {func_name}']
+            print("✅")
+            msgs += [f':white_check_mark: {func_name}']
         except Exception:
+            print("❌")
             print(traceback.format_exc())
-            msg = [f':x: {func_name} ']
+            msgs += [f':x: {func_name} ']
             tracebacks.append(f"{func_name} \n\n" + traceback.format_exc())
-        msgs += msg
 
     count_succeeded_msg = f"{len(functions) - len(tracebacks)}/{len(functions)} {job_name} succeeded"
     if len(tracebacks) > 0:

{strideutils-0.3.6 → strideutils-0.3.15}/strideutils/stride_config.py

@@ -78,6 +78,7 @@ class ChainConfig(ConfigObj):
     ticker: str = ""
     api_endpoint: str = ""
     rpc_endpoint: str = ""
+    evm_chain: bool = False
 
     def __repr__(self) -> str:
         return f"ChainConfig(name={self.name}, id={self.id})"
@@ -152,6 +153,9 @@ class AppChainsConfig(ConfigObj):
     mars: ChainConfig = field(default_factory=ChainConfig)
     canto: ChainConfig = field(default_factory=ChainConfig)
     agoric: ChainConfig = field(default_factory=ChainConfig)
+    sei: ChainConfig = field(default_factory=ChainConfig)
+    noble: ChainConfig = field(default_factory=ChainConfig)
+    forma: ChainConfig = field(default_factory=ChainConfig)
 
 
 @dataclass(repr=False)
@@ -195,6 +199,10 @@ class Config(ConfigObj):
     NUMIA_API_TOKEN: str = ""
     founders: List[str] = field(default_factory=lambda: ['riley', 'aidan', 'vishal'])
 
+    # AWS
+    AWS_ACCESS_KEY_ID: str = ""
+    AWS_SECRET_ACCESS_KEY: str = ""
+
     # Chain configs
     stride: StrideChainConfig = field(default_factory=StrideChainConfig)
     host_zones: HostChainsConfig = field(default_factory=HostChainsConfig)
@@ -361,7 +369,7 @@ def _parse_raw_configs(raw_config: dict[str, Any], raw_secrets: dict[str, Option
     # Load non-nested configs, then overwrite with the chain configs
     config_dict = raw_secrets
     config_dict.update(raw_config)
-    config_dict.update(chain_configs)
+    config_dict.update(chain_configs)  # type: ignore
     return Config(**config_dict)  # type: ignore
 
 

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

@@ -37,6 +37,7 @@ PENDING_ICQ_QUERY = "Stride-Labs/stride/interchainquery/pending_queries"
 RATE_LIMIT_QUERY = "Stride-Labs/ibc-rate-limiting/ratelimit/ratelimits"
 DEPOSIT_RECORDS_QUERY = "Stride-Labs/stride/records/deposit_record_by_host_zone/{chain_id}"
 UNBONDING_RECORDS_QUERY = "Stride-Labs/stride/records/epoch_unbonding_record"
+REDEMPTION_RECORDS_QUERY = "Stride-Labs/stride/records/user_redemption_record"
 LSM_RECORDS_QUERY = "Stride-Labs/stride/stakeibc/lsm_deposits"
 CALLBACK_DATA_QUERY = "Stride-Labs/stride/icacallbacks/callback_data"
 
@@ -67,6 +68,7 @@ def request(
     url: str,
     headers: dict = {},
     params: Union[dict, List[Tuple[str, str]]] = {},
+    data: Optional[str] = None,
     block_height: int = 0,
     cache_response: bool = False,
     _cache: Dict[str, Any] = {},
@@ -95,7 +97,7 @@ def request(
     if type(params) is dict:
         params = list(params.items())
 
-    resp = requests_session.get(url, headers=headers, params=params)
+    resp = requests_session.get(url, headers=headers, params=params, data=data)
     if not resp.ok:  # resp.ok is true if state_code is less than 400
         print(f"Error fetching {url}: {resp.status_code} {resp.json()}")
         raise Exception(f"Error fetching {url}: {resp.status_code} {resp.json()}")
@@ -381,6 +383,33 @@ def get_unbonded_records(
     return filtered_unbonding_records
 
 
+def get_user_redemption_records(chain_id: Optional[str] = None) -> list[dict]:
+    """
+    Queries all user redemption records with optional chain_id filter
+
+    [
+        {
+            "id": "comdex-1.601.comdex1fq0klaec7s59drpl93w6yycgqqtd3d38d34zn0",
+            "receiver": "comdex1fq0klaec7s59drpl93w6yycgqqtd3d38d34zn0",
+            "native_token_amount": "63303481323",
+            "denom": "ucmdx",
+            "host_zone_id": "comdex-1",
+            "epoch_number": "601",
+            "claim_is_pending": false,
+            "st_token_amount": "51025461480"
+        },
+        ...
+    """
+    url = f"{config.stride.api_endpoint}/{REDEMPTION_RECORDS_QUERY}"
+    redemption_records = query_list_with_pagination(url, rel_key="user_redemption_record", max_pages=50)
+
+    if not chain_id:
+        return redemption_records
+
+    redemption_records = [rr for rr in redemption_records if rr["host_zone_id"] == chain_id]
+    return redemption_records
+
+
 def get_lsm_deposit_records(chain_id: str) -> List[Dict[str, Any]]:
     """
     Queries all the LSM deposit records
@@ -811,64 +840,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]:
@@ -1187,3 +1219,31 @@ def get_empirical_annual_fees(ticker: str) -> float:
         stride_upstash.get("sheet_STRD_STAKING_ST{}_DOLLARS".format(ticker.upper()), db_name="frontend") or "0"
     )
     return float(cast(str, empirical_dollar_fees))
+
+
+def query_evm_method(method: str, params: list[str], rpc_endpoint: str) -> str:
+    """
+    Generic querier for evm contract calls
+    Returns a hex endcoded response specific to the contract call
+    """
+    headers = {"Content-Type": "application/json"}
+    payload = {
+        "jsonrpc": "2.0",
+        "method": method,
+        "params": params,
+        "id": 1,
+    }
+
+    response = request(rpc_endpoint, headers=headers, data=json.dumps(payload))
+    return response["result"]
+
+
+def get_evm_balance(address: str, rpc_endpoint: str) -> int:
+    """
+    Queries the native token balance of an evm address
+    Address should be a hex address with an 0x prefix
+    """
+    params = [address, "latest"]
+    balance_raw = query_evm_method("eth_getBalance", params=params, rpc_endpoint=rpc_endpoint)
+    balance = int(balance_raw, 16)
+    return balance