ratio1 3.4.34__tar.gz → 3.4.36__tar.gz

{ratio1-3.4.34 → ratio1-3.4.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ratio1
-Version: 3.4.34
+Version: 3.4.36
 Summary: `ratio1` or Ration1 SDK is the Python SDK required for client app development for the Ratio1 ecosystem
 Project-URL: Homepage, https://github.com/Ratio1/ratio1_sdk
 Project-URL: Bug Tracker, https://github.com/Ratio1/ratio1_sdk/issues

{ratio1-3.4.34 → ratio1-3.4.36}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ratio1"
-version = "3.4.34"
+version = "3.4.36"
 authors = [
   { name="Andrei Ionut Damian", email="andrei.damian@ratio1.ai" },
   { name="Cristan Bleotiu", email="cristian.bleotiu@ratio1.ai" },

{ratio1-3.4.34 → ratio1-3.4.36}/ratio1/_ver.py

@@ -1,4 +1,4 @@
-__VER__ = "3.4.34"
+__VER__ = "3.4.36"
 
 if __name__ == "__main__":
   with open("pyproject.toml", "rt") as fd:

ratio1-3.4.34/ratio1/certs/51.15.142.167.cert → ratio1-3.4.36/ratio1/certs/51.15.142.167.crt

@@ -17,4 +17,4 @@ APeA2A8F9zriemjFjQYaveQKW4tzXtGY68ibSMgH/qceVrfgZ8/G1vE7Qy/RtYRE
 z54RLb2dZIIUQCcuRCbzX0KHB4PMbz42gSPrWA3V1anVuxXeq9NYOU87dLK7y4fp
 lcdFmDaI1mQ3UgRRXKrv14yjvRYxSAcao6mfsx1zVVKlvcavqawNxcQp+bQD1Nxw
 scArD5w=
------END CERTIFICATE-----
+-----END CERTIFICATE-----

{ratio1-3.4.34 → ratio1-3.4.36}/ratio1/cli/cli_commands.py

@@ -42,6 +42,10 @@ CLI_COMMANDS = {
         "supervisors": {
             "func": get_supervisors, # DONE
             "description": "Get the list of available supervisor oracles",
+            "params": {
+                "--eth" : "Use a specific node (flag)",
+                "--wide" : "Display all available information (flag)",
+            }
         },
         "eth" : {
             "func": get_eth_addr,

{ratio1-3.4.34 → ratio1-3.4.36}/ratio1/cli/nodes.py

@@ -115,10 +115,15 @@ def get_supervisors(args):
     online_only=True,
     supervisors_only=True,
     return_session=True,
+    eth=args.eth,
+    all_info=args.wide,    
   )
   df, supervisor, super_alias, nr_supers, elapsed, sess = res
   FILTERED = ['Oracle', 'State']
   df = df[[c for c in df.columns if c not in FILTERED]]
+
+  import pandas as pd
+  pd.set_option('display.float_format', '{:.4f}'.format)
   
   if supervisor == "ERROR":
     log_with_color(f"No supervisors or no comms available in {elapsed:.1f}s. Please check your settings.", color='r')

ratio1-3.4.36/xperimental/lp/lp_checker.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Utility script for inspecting the R1/USDC liquidity pool on Base.
+
+The script prints the current LP holders and the amount of R1 and USDC each
+holder would receive if they removed their liquidity.  Additionally it computes
+the "lower bound price" of the R1 token which is defined as the price implied by
+the token balances inside the pair contract (reserves plus any unclaimed
+trading fees).
+"""
+
+from web3 import Web3
+from web3.exceptions import Web3RPCError
+from typing import Iterable, Set
+import logging
+import math
+
+# Connect to Base mainnet RPC (chain ID 8453)
+base_rpc = "https://base-mainnet.public.blastapi.io"
+w3 = Web3(Web3.HTTPProvider(base_rpc))
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s:%(message)s")
+logger = logging.getLogger(__name__)
+
+# Uniswap V2 R1/USDC pair contract address
+pair_address = Web3.to_checksum_address("0x0feC06fd2C2bd4066c7302c08950aBaA2E4AB1d3")
+
+# Minimal ABI for Uniswap V2 pair (token0, token1, getReserves, totalSupply, balanceOf, and Transfer event)
+pair_abi = [
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "token0",
+        "outputs": [{"name": "", "type": "address"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "token1",
+        "outputs": [{"name": "", "type": "address"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "getReserves",
+        "outputs": [
+            {"name": "reserve0", "type": "uint112"},
+            {"name": "reserve1", "type": "uint112"},
+            {"name": "blockTimestampLast", "type": "uint32"},
+        ],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [{"name": "", "type": "uint"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [{"name": "owner", "type": "address"}],
+        "name": "balanceOf",
+        "outputs": [{"name": "", "type": "uint"}],
+        "type": "function",
+    },
+    {
+        "anonymous": False,
+        "inputs": [
+            {"indexed": True, "name": "from", "type": "address"},
+            {"indexed": True, "name": "to", "type": "address"},
+            {"indexed": False, "name": "value", "type": "uint256"},
+        ],
+        "name": "Transfer",
+        "type": "event",
+    },
+]
+pair_contract = w3.eth.contract(address=pair_address, abi=pair_abi)
+
+erc20_abi = [
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [{"name": "", "type": "string"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [{"name": "", "type": "uint8"}],
+        "type": "function",
+    },
+    {
+        "constant": True,
+        "inputs": [{"name": "owner", "type": "address"}],
+        "name": "balanceOf",
+        "outputs": [{"name": "", "type": "uint256"}],
+        "type": "function",
+    },
+]
+
+
+def fetch_transfer_addresses(start_block: int, end_block: int, step: int = 10_000) -> Set[str]:
+    """Return all addresses that ever transferred LP tokens."""
+
+    transfer_topic = Web3.keccak(text="Transfer(address,address,uint256)").hex()
+    addresses: Set[str] = set()
+    for from_block in range(start_block, end_block + 1, step):
+        to_block = min(from_block + step - 1, end_block)
+        logger.debug("Fetching logs %s-%s", from_block, to_block)
+        try:
+            logs = w3.eth.get_logs(
+                {
+                    "fromBlock": from_block,
+                    "toBlock": to_block,
+                    "address": pair_address,
+                    "topics": [transfer_topic],
+                }
+            )
+        except Exception as exc:
+            logger.warning("log request failed %s-%s: %s", from_block, to_block, exc)
+            break
+        for log in logs:
+            from_addr = "0x" + log["topics"][1].hex()[-40:]
+            to_addr = "0x" + log["topics"][2].hex()[-40:]
+            if from_addr != "0x0000000000000000000000000000000000000000":
+                addresses.add(Web3.to_checksum_address(from_addr))
+            if to_addr != "0x0000000000000000000000000000000000000000":
+                addresses.add(Web3.to_checksum_address(to_addr))
+    return addresses
+
+
+def compute_lower_bound_price(
+    r1_balance: int, usdc_balance: int, r1_dec: int, usdc_dec: int
+) -> float:
+    """Return the minimal R1/USDC price implied by token balances."""
+
+    r1_amt = r1_balance / (10**r1_dec)
+    usdc_amt = usdc_balance / (10**usdc_dec)
+    logger.debug("R1 balance=%s (%s decimals)", r1_amt, r1_dec)
+    logger.debug("USDC balance=%s (%s decimals)", usdc_amt, usdc_dec)
+    if r1_amt == 0:
+        return 0.0
+    return usdc_amt / r1_amt
+
+
+def main() -> None:
+    logger.info("Fetching pair metadata")
+    latest_block = w3.eth.block_number
+
+    token0 = pair_contract.functions.token0().call()
+    token1 = pair_contract.functions.token1().call()
+    reserve0, reserve1, _ = pair_contract.functions.getReserves().call()
+    total_supply = pair_contract.functions.totalSupply().call()
+
+    t0_contract = w3.eth.contract(address=token0, abi=erc20_abi)
+    t1_contract = w3.eth.contract(address=token1, abi=erc20_abi)
+    sym0 = t0_contract.functions.symbol().call().upper()
+    sym1 = t1_contract.functions.symbol().call().upper()
+
+    if sym0 == "R1":
+        r1_reserve, usdc_reserve = reserve0, reserve1
+        r1_contract, usdc_contract = t0_contract, t1_contract
+    elif sym1 == "R1":
+        r1_reserve, usdc_reserve = reserve1, reserve0
+        r1_contract, usdc_contract = t1_contract, t0_contract
+    else:
+        r1_reserve, usdc_reserve = reserve0, reserve1
+        r1_contract, usdc_contract = t0_contract, t1_contract
+    logger.info("Reserves: R1=%s, USDC=%s", r1_reserve, usdc_reserve)
+
+    r1_balance = r1_contract.functions.balanceOf(pair_address).call()
+    usdc_balance = usdc_contract.functions.balanceOf(pair_address).call()
+
+    lower_bound = compute_lower_bound_price(
+        r1_balance,
+        usdc_balance,
+        r1_contract.functions.decimals().call(),
+        usdc_contract.functions.decimals().call(),
+    )
+    logger.info("Lower bound price = %s", lower_bound)
+
+    addresses = fetch_transfer_addresses(0, latest_block)
+    logger.info("Found %d transfer addresses", len(addresses))
+    holders = {}
+    for addr in addresses:
+        bal = pair_contract.functions.balanceOf(addr).call()
+        if bal > 0 and w3.eth.get_code(addr) in (b"", b"0x", b"0x0", "0x"):
+            holders[addr] = bal
+
+    logger.info("EOA LP holders: %d", len(holders))
+    for holder, bal in holders.items():
+        share = bal / total_supply
+        r1_amt = int(share * r1_reserve)
+        usdc_amt = int(share * usdc_reserve)
+        print(f"{holder}: R1={r1_amt}, USDC={usdc_amt}")
+
+    logger.info("Lower bound price (R1/USDC) including fees: %s", lower_bound)
+    print(f"Lower bound price (R1/USDC) including fees: {lower_bound}")
+
+
+if __name__ == "__main__":
+    main()

ratio1-3.4.34/xperimental/lp/lp_checker.py

@@ -1,88 +0,0 @@
-#!/usr/bin/env python3
-from web3 import Web3
-
-# Connect to Base mainnet RPC (chain ID 8453)
-base_rpc = "https://base-mainnet.public.blastapi.io"
-w3 = Web3(Web3.HTTPProvider(base_rpc))
-
-# Uniswap V2 R1/USDC pair contract address
-pair_address = Web3.to_checksum_address("0x0feC06fd2C2bd4066c7302c08950aBaA2E4AB1d3")
-
-# Minimal ABI for Uniswap V2 pair (token0, token1, getReserves, totalSupply, balanceOf, and Transfer event)
-pair_abi = [
-    {"constant": True, "inputs": [], "name": "token0", "outputs": [{"name": "", "type": "address"}], "type": "function"},
-    {"constant": True, "inputs": [], "name": "token1", "outputs": [{"name": "", "type": "address"}], "type": "function"},
-    {"constant": True, "inputs": [], "name": "getReserves", "outputs": [
-        {"name": "reserve0", "type": "uint112"},
-        {"name": "reserve1", "type": "uint112"},
-        {"name": "blockTimestampLast", "type": "uint32"}], "type": "function"},
-    {"constant": True, "inputs": [], "name": "totalSupply", "outputs": [{"name": "", "type": "uint"}], "type": "function"},
-    {"constant": True, "inputs": [{"name": "owner", "type": "address"}], "name": "balanceOf", "outputs": [{"name": "", "type": "uint"}], "type": "function"},
-    {"anonymous": False, "inputs": [
-        {"indexed": True, "name": "from", "type": "address"},
-        {"indexed": True, "name": "to", "type": "address"},
-        {"indexed": False, "name": "value", "type": "uint256"}],
-     "name": "Transfer", "type": "event"}
-]
-pair_contract = w3.eth.contract(address=pair_address, abi=pair_abi)
-
-# Fetch token addresses and pool data
-token0 = pair_contract.functions.token0().call()       # Address of R1 or USDC
-token1 = pair_contract.functions.token1().call()       # Address of the other token
-reserve0, reserve1, _ = pair_contract.functions.getReserves().call()
-total_supply = pair_contract.functions.totalSupply().call()
-
-# Determine which reserve is R1 vs USDC by checking token symbols (optional)
-erc20_abi = [{"constant": True, "inputs": [], "name": "symbol", "outputs": [{"name": "", "type": "string"}], "type": "function"}]
-sym0 = w3.eth.contract(address=token0, abi=erc20_abi).functions.symbol().call().upper()
-sym1 = w3.eth.contract(address=token1, abi=erc20_abi).functions.symbol().call().upper()
-if sym0 == 'R1':
-    r1_reserve, usdc_reserve = reserve0, reserve1
-elif sym1 == 'R1':
-    r1_reserve, usdc_reserve = reserve1, reserve0
-else:
-    # Fallback assumption if symbol check fails
-    r1_reserve, usdc_reserve = reserve0, reserve1
-
-# Prepare Transfer event signature hash for filtering logs
-transfer_topic = Web3.keccak(text="Transfer(address,address,uint256)").hex()
-
-# Fetch all Transfer events from block 0 to latest for this pair contract
-logs = w3.eth.get_logs({
-    "fromBlock": 0,
-    "toBlock": "latest",
-    "address": pair_address,
-    "topics": [transfer_topic]
-})
-
-# Collect all addresses that appear in Transfer logs
-all_addresses = set()
-for log in logs:
-    # Topics[1] = from, Topics[2] = to (indexed fields)
-    from_addr = "0x" + log['topics'][1].hex()[-40:]
-    to_addr   = "0x" + log['topics'][2].hex()[-40:]
-    # Convert to checksum addresses
-    from_addr = Web3.to_checksum_address(from_addr)
-    to_addr   = Web3.to_checksum_address(to_addr)
-    # Add addresses if not zero address
-    if from_addr != "0x0000000000000000000000000000000000000000":
-        all_addresses.add(from_addr)
-    if to_addr != "0x0000000000000000000000000000000000000000":
-        all_addresses.add(to_addr)
-
-# Filter for EOAs with positive LP balance
-holders = {}
-for addr in all_addresses:
-    balance = pair_contract.functions.balanceOf(addr).call()
-    if balance > 0:
-        code = w3.eth.get_code(addr)
-        # EOA check: get_code returns empty (0x) for EOAs:contentReference[oaicite:12]{index=12}
-        if code == b'' or code == '0x' or code == b'0x' or code == b'0x0':
-            holders[addr] = balance
-
-# Compute and print each holder's share of R1 and USDC
-for holder, bal in holders.items():
-    share = bal / total_supply
-    r1_amount = int(share * r1_reserve)
-    usdc_amount = int(share * usdc_reserve)
-    print(f"{holder}: R1={r1_amount}, USDC={usdc_amount}")