cryptointerface 0.1.0__py3-none-any.whl

cryptointerface/token.py

@@ -0,0 +1,264 @@
+import requests
+import polars as pl
+from web3 import Web3
+from .periphery.db import _init_tables, insert_data
+from .periphery.mapping import COINGECKO_CHAIN_IDS
+
+_ERC20_APPROVE_ABI = [
+    {
+        "inputs": [
+            {"internalType": "address", "name": "spender", "type": "address"},
+            {"internalType": "uint256", "name": "amount", "type": "uint256"},
+        ],
+        "name": "approve",
+        "outputs": [{"internalType": "bool", "name": "", "type": "bool"}],
+        "stateMutability": "nonpayable",
+        "type": "function",
+    }
+]
+
+_ERC20_ALLOWANCE_ABI = [
+    {
+        "inputs": [
+            {"internalType": "address", "name": "owner", "type": "address"},
+            {"internalType": "address", "name": "spender", "type": "address"},
+        ],
+        "name": "allowance",
+        "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    }
+]
+
+
+class Token:
+    def __init__(self, symbol: str, chain_id: str):
+        self.symbol = symbol
+        self.chain_id = chain_id
+        self.interface = TokenInterface()
+
+        self._address = None
+        self._decimals = None
+        self._info = None
+
+    @property
+    def address(self):
+        if self._address is None:
+            self._address = self.interface.get_token_address(self.symbol, self.chain_id)
+        return self._address
+
+    @property
+    def decimals(self) -> int:
+        if self._decimals is None:
+            self._decimals = self.interface.get_token_decimals(
+                self.symbol, self.chain_id
+            )
+        return self._decimals
+
+    @property
+    def info(self):
+        if self._info is None:
+            self._info = self.interface.get_token_info(self.symbol, self.chain_id)
+        return self._info
+
+    def approve(
+        self, spender_address: str, amount: int, owner_address: str, rpc_url: str
+    ) -> dict:
+        """
+        Build an unsigned ERC-20 approve transaction.
+        amount is in raw token units — use to_wei() to scale beforehand.
+        Pass 2**256 - 1 as amount for an unlimited approval.
+        """
+        w3 = Web3(Web3.HTTPProvider(rpc_url))
+        contract = w3.eth.contract(
+            address=Web3.to_checksum_address(self.address),
+            abi=_ERC20_APPROVE_ABI,
+        )
+        owner_cs = Web3.to_checksum_address(owner_address)
+        return contract.functions.approve(
+            Web3.to_checksum_address(spender_address), amount
+        ).build_transaction({"from": owner_cs})
+
+    def check_allowance(
+        self, owner_address: str, spender_address: str, rpc_url: str
+    ) -> int:
+        """
+        Return the current ERC-20 allowance (in raw token units) that
+        `spender_address` is approved to spend on behalf of `owner_address`.
+        """
+        w3 = Web3(Web3.HTTPProvider(rpc_url))
+        contract = w3.eth.contract(
+            address=Web3.to_checksum_address(self.address),
+            abi=_ERC20_ALLOWANCE_ABI,
+        )
+        return contract.functions.allowance(
+            Web3.to_checksum_address(owner_address),
+            Web3.to_checksum_address(spender_address),
+        ).call()
+
+
+class TokenInterface:
+    def __init__(self):
+        self.table_name = "tokens"
+
+    @property
+    def conn(self):
+        return _init_tables()
+
+    def get_token_info(self, symbol: str, chain_id: str) -> pl.DataFrame:
+        symbol = symbol.upper()
+        chain_id = str(chain_id)
+        gen = self._read_token_info(symbol)
+        print(f"GEN: {gen}")
+        df = self._read_token_info(symbol, chain_id)
+        print(f"DF: {df}")
+        if not df.is_empty():
+            return df
+
+        # Cache miss — download all chains and persist them.
+        downloaded = self._download_token_info(symbol)
+        if not downloaded.is_empty():
+            self._insert_token_info(downloaded)
+
+        # Re-read so we only return the requested chain.
+        df = self._read_token_info(symbol, chain_id)
+        return df
+
+    def get_token_address(self, symbol: str, chain_id: str):
+        df = self.get_token_info(symbol=symbol, chain_id=chain_id)
+        return df["address"][0]
+
+    def get_token_decimals(self, symbol: str, chain_id: str):
+        df = self.get_token_info(symbol=symbol, chain_id=chain_id)
+        return df["decimals"][0]
+
+    def batch_save(self, symbols: list):
+        if isinstance(symbols, str):
+            symbols = [symbols]
+
+        coin_ids = _find_coin_ids()
+
+        for s in symbols:
+            try:
+                df = self._download_token_info(s, coin_ids=coin_ids)
+                self._insert_token_info(df)
+            except Exception as e:
+                break
+            except KeyboardInterrupt:
+                break
+
+    def _download_token_info(self, symbol: str, coin_ids: list = None) -> dict:
+        if coin_ids is None:
+            coin_ids = _find_coin_ids(symbol=symbol)
+        else:
+            coin_ids = _match_coin_ids(coins=coin_ids, symbol=symbol)
+        addresses = _fetch_token_addresses(symbol, coin_ids=coin_ids)
+        decimals_map = _fetch_token_decimals(symbol, coin_ids=coin_ids)
+        decimals = next(iter(decimals_map.values())) if decimals_map else None
+
+        data = {
+            "chain_id": [],
+            "address": [],
+        }
+        for k, v in addresses.items():
+            cid = COINGECKO_CHAIN_IDS.get(k, None)
+            data["chain_id"].append(str(cid) if cid is not None else None)
+            try:
+                address = Web3.to_checksum_address(v)
+            except ValueError:
+                address = v
+            data["address"].append(address)
+
+        df = pl.DataFrame(data)
+        df = df.filter(pl.col("chain_id").is_not_null())
+        df = df.with_columns(
+            pl.lit(symbol).alias("symbol"), pl.lit(decimals).alias("decimals")
+        )
+        df = df[["symbol", "chain_id", "address", "decimals"]]
+        return df
+
+    def update_decimals(self, symbol: str, decimals: int) -> None:
+        self.conn.execute(
+            "UPDATE tokens SET decimals = ? WHERE symbol = ?",
+            [decimals, symbol],
+        )
+
+    def _insert_token_info(self, df: pl.DataFrame):
+        insert_data(
+            df,
+            db_cols=["symbol", "chain_id", "address", "decimals"],
+            table_name=self.table_name,
+            conn=self.conn,
+            pk_cols=["chain_id", "address"],
+        )
+
+    def _read_token_info(self, symbol: str, chain_id: str = None) -> pl.DataFrame:
+        if chain_id:
+            query = f"SELECT * FROM {self.table_name} WHERE symbol = '{symbol}' AND chain_id = '{chain_id}'"
+        else:
+            query = f"SELECT * FROM {self.table_name} WHERE symbol = '{symbol}'"
+        return self.conn.execute(query).pl()
+
+
+def _find_coin_ids(symbol: str = None) -> list[dict]:
+    """Return all CoinGecko coin entries matching the given symbol."""
+    coins = requests.get(
+        "https://api.coingecko.com/api/v3/coins/list",
+        params={"include_platform": "true"},
+        timeout=15,
+    ).json()
+    if symbol:
+        return [c for c in coins if c.get("symbol", "").upper() == symbol]
+    else:
+        return coins
+
+
+def _match_coin_ids(coins: list, symbol: str):
+    return [c for c in coins if c.get("symbol", "").upper() == symbol]
+
+
+def _fetch_token_addresses(symbol: str, coin_ids: list = None) -> dict[str, str]:
+    """
+    Given a token symbol (e.g. "WETH"), return {network: address}
+    for all networks known to CoinGecko.
+    """
+    addresses: dict[str, str] = {}
+    if coin_ids is None:
+        coin_ids = _find_coin_ids(symbol)
+    for coin in coin_ids:
+        for network, address in coin.get("platforms", {}).items():
+            if address:
+                addresses[network] = address
+    return addresses
+
+
+def _fetch_token_decimals(symbol: str, coin_ids: list = None) -> dict[str, int]:
+    """
+    Given a token symbol (e.g. "WETH"), return {network: decimals}
+    for every network where CoinGecko reports a decimal_place value.
+    """
+    if coin_ids is None:
+        matches = _find_coin_ids(symbol)
+    else:
+        matches = coin_ids
+    if not matches:
+        return {}
+
+    decimals: dict[str, int] = {}
+    for coin in matches:
+        detail = requests.get(
+            f"https://api.coingecko.com/api/v3/coins/{coin['id']}",
+            params={
+                "localization": "false",
+                "tickers": "false",
+                "market_data": "false",
+                "community_data": "false",
+                "developer_data": "false",
+            },
+            timeout=15,
+        ).json()
+        for network, info in detail.get("detail_platforms", {}).items():
+            dp = info.get("decimal_place")
+            if dp is not None:
+                decimals[network] = dp
+    return decimals

cryptointerface/wallet.py

@@ -0,0 +1,28 @@
+from web3 import Web3
+
+
+class Wallet:
+    def __init__(self, private_key: str, rpc_url: str):
+        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
+        self.account = self.w3.eth.account.from_key(private_key)
+        self.address = self.account.address
+
+    def sign_and_send(self, tx: dict) -> str:
+        """
+        Fill in nonce and gas if missing, sign the transaction, broadcast it,
+        and return the transaction hash as a hex string.
+        """
+        if "nonce" not in tx:
+            tx["nonce"] = self.w3.eth.get_transaction_count(self.address)
+        if "gas" not in tx:
+            tx["gas"] = self.w3.eth.estimate_gas({**tx, "from": self.address})
+        if "gasPrice" not in tx and "maxFeePerGas" not in tx:
+            tx["gasPrice"] = self.w3.eth.gas_price
+
+        signed = self.account.sign_transaction(tx)
+        tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
+        return tx_hash.hex()
+
+    def wait(self, tx_hash: str, timeout: int = 120) -> dict:
+        """Block until the transaction is mined and return the receipt."""
+        return self.w3.eth.wait_for_transaction_receipt(tx_hash, timeout=timeout)

cryptointerface-0.1.0.dist-info/METADATA

@@ -0,0 +1,354 @@
+Metadata-Version: 2.4
+Name: cryptointerface
+Version: 0.1.0
+Summary: Interface with cryptocurrency and DEX contracts. Store data locally for future use.
+Project-URL: Source, https://github.com/William-Kruta/CryptoInterface
+License: MIT
+Keywords: aave,arbitrage,crypto,defi,dex,uniswap,web3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.12
+Requires-Dist: duckdb>=1.5
+Requires-Dist: polars>=1.0
+Requires-Dist: pyarrow>=14.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: requests>=2.33
+Requires-Dist: web3>=7.0
+Description-Content-Type: text/markdown
+
+# CryptoInterface
+
+A Python library for interacting with EVM-compatible DEXes — price fetching, swapping.
+
+I have provided some starter data to enter in your database.
+
+To do this, just write this code:
+
+```
+from cryptointerface.periphery.db import  insert_tokens_csv_to_db, insert_pools_csv_to_db
+
+insert_tokens_csv_to_db()
+insert_pools_csv_to_db()
+```
+
+## Installation
+
+```bash
+pip install cryptointerface
+```
+
+Or with [uv](https://github.com/astral-sh/uv):
+
+```bash
+uv add cryptointerface
+```
+
+**Requirements:** Python 3.12+
+
+---
+
+## Quick Start
+
+```python
+from cryptointerface import Dex, Token, Wallet, arbitrage_route
+from cryptointerface.providers.infura import Infura
+from cryptointerface.periphery.utils import to_wei, from_wei
+from cryptointerface.periphery.enums import Network, Platform
+
+infura = Infura(api_key="YOUR_INFURA_KEY")
+
+# Look up a token
+token = Token("WETH", chain_id=Network.ARBITRUM.value)
+print(token.address, token.decimals)
+
+# Fetch a price
+dex = Dex("uniswap_v3", chain_id="42161", rpc_url=infura.get_url("42161"))
+price = dex.get_price(weth_address, usdc_address)
+```
+
+---
+
+## Core Modules
+
+### `Token` / `TokenInterface`
+
+Resolves token metadata from a local DuckDB cache, downloading from CoinGecko on first use.
+
+```python
+from cryptointerface import Token, TokenInterface
+
+token = Token("USDC", chain_id="42161")
+print(token.address)    # checksummed address
+print(token.decimals)   # 6
+print(token.info)       # polars DataFrame
+
+# Build an ERC-20 approve transaction (unsigned)
+tx = token.approve(
+    spender_address="0xRouter...",
+    amount=to_wei(1000, decimals=6),
+    owner_address="0xYourWallet",
+    rpc_url="https://...",
+)
+```
+
+`TokenInterface` provides the lower-level DB methods (`get_token_info`, `get_token_address`, `get_token_decimals`, `batch_save`, `update_decimals`).
+
+---
+
+### `Dex` / `DexInterface`
+
+Fetches pool addresses and prices, and builds swap transactions for all supported DEX protocols.
+
+```python
+from cryptointerface import Dex
+
+dex = Dex("uniswap_v3", chain_id="42161", rpc_url="https://...")
+
+# Pool address (cached in DuckDB on first call)
+pool = dex.pool_address(token_a_address, token_b_address)
+
+# Spot price — token_a denominated in token_b
+price = dex.get_price(token_a_address, token_b_address)
+
+# Build an unsigned swap transaction
+tx = dex.interface.swap(
+    token_in=token_a_address,
+    token_out=token_b_address,
+    amount_in=to_wei(1.0),
+    dex_name="uniswap_v3",
+    chain_id="42161",
+    sender="0xYourWallet",
+)
+```
+
+#### Supported DEXes
+
+| Name             | Protocol        | Chains                                               |
+| ---------------- | --------------- | ---------------------------------------------------- |
+| `uniswap_v2`     | Uniswap V2      | Ethereum, Sepolia                                    |
+| `uniswap_v3`     | Uniswap V3      | Ethereum, Arbitrum, Polygon, Optimism, Base, Sepolia |
+| `sushiswap_v2`   | Uniswap V2 fork | Ethereum, Arbitrum, Polygon, Sepolia                 |
+| `sushiswap_v3`   | Uniswap V3 fork | Ethereum, Arbitrum, Polygon, Sepolia                 |
+| `pancakeswap_v2` | Uniswap V2 fork | BSC, Ethereum                                        |
+| `pancakeswap_v3` | Uniswap V3 fork | BSC, Ethereum                                        |
+| `quickswap_v2`   | Uniswap V2 fork | Polygon                                              |
+| `quickswap_v3`   | Algebra V3      | Polygon                                              |
+| `camelot_v2`     | Uniswap V2 fork | Arbitrum                                             |
+| `camelot_v3`     | Algebra V3      | Arbitrum                                             |
+| `traderjoe_v1`   | Uniswap V2 fork | Avalanche, Arbitrum                                  |
+| `aerodrome`      | Solidly V2      | Base                                                 |
+| `velodrome`      | Solidly V2      | Optimism                                             |
+
+#### Protocols
+
+- **Uniswap V2** — `getPair` factory, fixed fee per DEX, `getReserves` pricing
+- **Uniswap V3** — `getPool` factory, per-pool fee tiers, `sqrtPriceX96` pricing
+- **Algebra V3** — `poolByPair` factory, dynamic fees, no fee argument (QuickSwap, Camelot V3)
+- **Solidly V2** — `getPool(stable: bool)` factory, stable/volatile pools (Aerodrome, Velodrome)
+
+#### `create_dex_mapping`
+
+Build a multi-DEX dict for use with `get_prices` / `arbitrage_route`:
+
+```python
+from cryptointerface.dex import create_dex_mapping
+
+dex_mapping = create_dex_mapping(
+    dex_names=["uniswap_v3", "sushiswap_v3", "camelot_v3"],
+    chain_ids=["42161"],
+    infura_obj=infura,
+)
+```
+
+---
+
+### `routes` — Prices & Arbitrage
+
+```python
+from cryptointerface import get_prices, arbitrage_route
+
+# Parallel price fetch across all DEXes
+prices = get_prices(dex_mapping, token_a_address, token_b_address)
+# {"uniswap_v3": {"price": 1823.4, "pool": "0x...", "fee_bps": 5}, ...}
+
+# Arbitrage analysis
+route = arbitrage_route(dex_mapping, token_a_address, token_b_address)
+```
+
+`arbitrage_route` returns:
+
+```python
+{
+    "buy":            {"dex": "camelot_v3", "price": 1820.1, "pool": "0x...", "fee_bps": 5},
+    "sell":           {"dex": "uniswap_v3", "price": 1825.8, "pool": "0x...", "fee_bps": 5},
+    "spread_abs":     5.7,
+    "spread_pct":     0.3132,
+    "total_fee_pct":  0.1,       # both legs combined
+    "net_spread_pct": 0.2132,    # spread after fees
+    "profitable":     True,
+    "all_prices":     {...},
+}
+```
+
+Fees are sourced from `dex_architecture.json` — V3 fee tiers use the matched pool tier; V2 uses the fixed DEX fee.
+
+---
+
+### `Wallet`
+
+Signs and broadcasts unsigned transactions built by `Dex`, `Token`, or `AaveFlashLoan`.
+
+```python
+from cryptointerface import Wallet
+
+wallet = Wallet(private_key="0x...", rpc_url="https://...")
+
+tx_hash = wallet.sign_and_send(tx)   # auto-fills nonce, gas, gasPrice
+receipt = wallet.wait(tx_hash)       # blocks until mined
+```
+
+---
+
+### `AaveFlashLoan`
+
+Builds Aave V3 flash loan transactions. Supported chains: Ethereum, Optimism, BSC, Polygon, Base, Arbitrum, Avalanche, Sepolia.
+
+Flash loan fee: **0.09%** (9 bps).
+
+```python
+from cryptointerface import AaveFlashLoan
+from cryptointerface.periphery.utils import to_wei
+
+fl = AaveFlashLoan(chain_id="42161", rpc_url="https://...")
+
+# Single-asset flash loan (lower gas)
+tx = fl.flash_loan_simple_tx(
+    receiver_contract="0xYourDeployedExecutor",
+    asset=usdc_address,
+    amount=to_wei(10_000, decimals=6),
+    sender=wallet.address,
+)
+tx_hash = wallet.sign_and_send(tx)
+
+# Multi-asset flash loan
+tx = fl.flash_loan_tx(
+    receiver_contract="0xYourDeployedExecutor",
+    assets=[weth_address, usdc_address],
+    amounts=[to_wei(5.0), to_wei(10_000, decimals=6)],
+    sender=wallet.address,
+)
+
+# Check profitability after the flash loan fee
+result = AaveFlashLoan.net_profit(
+    amount=to_wei(10_000, decimals=6),
+    gross_profit_wei=to_wei(15, decimals=6),
+    token_decimals=6,
+)
+# {"fee_wei": 9000, "net_profit_wei": 6000, "net_profit_human": 0.006, "is_profitable": True}
+```
+
+#### Solidity Executor Contract
+
+The flash loan callback (`executeOperation`) must be implemented in Solidity. A full template is available as:
+
+```python
+print(AaveFlashLoan.EXECUTOR_TEMPLATE)
+```
+
+Deploy this contract once, paste your swap logic inside `executeOperation`, then pass its address as `receiver_contract`.
+
+---
+
+### `Infura`
+
+RPC URL builder for Infura endpoints.
+
+```python
+from cryptointerface.providers.infura import Infura
+
+infura = Infura(api_key="YOUR_KEY")
+rpc_url = infura.get_url("42161")   # Arbitrum
+
+# Add a custom endpoint
+infura.add_endpoint(chain_id="10", endpoint="https://optimism-mainnet.infura.io/v3/")
+```
+
+---
+
+## Local Database (DuckDB)
+
+Token and pool data is cached locally in a DuckDB file (`~/.cryptointerface/data.db` by default). All reads/writes are thread-safe via thread-local connections and a write lock.
+
+### Schema
+
+**`tokens`** — `symbol`, `chain_id`, `address`, `decimals`
+
+**`pools_v2`** — `dex`, `chain_id`, `token_0`, `token_1`, `address`
+
+**`pools_v3`** — `dex`, `chain_id`, `token_0`, `token_1`, `fee`, `address`
+
+### CSV Import / Export
+
+```python
+from cryptointerface.periphery.db import (
+    export_tokens_to_csv,
+    export_pools_to_csv,
+    insert_tokens_csv_to_db,
+    insert_pools_csv_to_db,
+)
+
+export_tokens_to_csv("tokens.csv")
+export_pools_to_csv("pools_v2.csv", "pools_v3.csv")
+
+insert_tokens_csv_to_db("tokens.csv")
+insert_pools_csv_to_db("pools_v2.csv", "pools_v3.csv")
+```
+
+---
+
+## Utilities
+
+```python
+from cryptointerface.periphery.utils import to_wei, from_wei
+
+to_wei(1.5, decimals=18)     # 1500000000000000000
+from_wei(1_000_000, decimals=6)  # 1.0
+```
+
+### Enums
+
+```python
+from cryptointerface.periphery.enums import Network, Platform
+
+Network.ARBITRUM.value   # "42161"
+Platform.UNISWAP_V3.value  # "uniswap_v3"
+```
+
+**Networks:** `ETHEREUM`, `OPTIMISM`, `BSC`, `POLYGON`, `BASE`, `ARBITRUM`, `CELO`, `AVALANCHE`, `BLAST`, `ZORA`, `SEPOLIA`
+
+**Platforms:** `UNISWAP_V2`, `UNISWAP_V3`, `SUSHISWAP_V2`, `SUSHISWAP_V3`, `PANCAKESWAP_V2`, `PANCAKESWAP_V3`, `QUICKSWAP_V2`, `QUICKSWAP_V3`, `CAMELOT_V2`, `CAMELOT_V3`, `TRADERJOE_V1`, `AERODROME`, `VELODROME`
+
+---
+
+## Running Tests
+
+```bash
+uv run pytest
+```
+
+Network tests (require a live RPC) are skipped by default unless `SEPOLIA_RPC_URL` is set in your environment.
+
+---
+
+## Dependencies
+
+| Package         | Purpose                      |
+| --------------- | ---------------------------- |
+| `web3`          | EVM RPC interaction          |
+| `duckdb`        | Local persistent storage     |
+| `polars`        | DataFrame operations         |
+| `requests`      | CoinGecko API calls          |
+| `python-dotenv` | Environment variable loading |

cryptointerface-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+cryptointerface/__init__.py,sha256=rCrUO5e1Jt-TnAKz49Tdvi0vTxGoTBFO8i7hG4gn6DM,208
+cryptointerface/dex.py,sha256=XZjUrG_rSD42gR6HPh2L8zauXFBg9YoxMxYyhs7c2Lg,30980
+cryptointerface/flashloan.py,sha256=hKwbI45GgVX2e6zrDiNOEQI70MtnWjq0Tnk6jIkXgwg,11673
+cryptointerface/routes.py,sha256=cuwv1z5MuOQ1L_-ck6gBoLT_bnRZNpduP4rLqUMhJSo,3643
+cryptointerface/token.py,sha256=SszyrMdM_USYHrkP6lmi96_3hwmLfmzZikoDMV9xms4,8808
+cryptointerface/wallet.py,sha256=HdSOt-6-LabM8R7cpj-cDm9kl3l6uZ5QJcozLI0RpqA,1160
+cryptointerface/periphery/config.py,sha256=Pyu54RZSiafOefQ-h-5r0ubkWq3J_plTeE3iyYgFOik,1248
+cryptointerface/periphery/db.py,sha256=NlqywCHZK-JqFCb4OiwxK9JLQCY5ZCoCBpjbq1JuY94,4307
+cryptointerface/periphery/dex_architecture.json,sha256=nShSIgX2ZOhRQi1sV0GzBLW3SNsZ4UihamrQafQIX1g,3838
+cryptointerface/periphery/dex_contracts.json,sha256=nN1dXSY53d0YBfREggbJRPxGkWOK-CJDMOCvRziHneY,13288
+cryptointerface/periphery/dex_contracts.py,sha256=QROcJYi9Jfr9zqTaF3L06bszCPUAacQDIJKvS5aIlNU,1541
+cryptointerface/periphery/enums.py,sha256=1uWJb9xYPDTUnTap4UukHWK4XNwVQszWfebIH2edCt0,783
+cryptointerface/periphery/mapping.py,sha256=RnX7kH76IcsVJhLS54pIyeeID69QZQRNnmCKHgqssN4,2780
+cryptointerface/periphery/utils.py,sha256=ag9tMjJ7ugTL7Cs4PgyYxr5DoiiH31cLEt4NNcEzPak,203
+cryptointerface/providers/endpoints.json,sha256=MJi4KJu73_0As3Nza-vF0XCUr5D_SsQ0zy22T6Vig9Q,1186
+cryptointerface/providers/infura.py,sha256=3o4Ru4FLJXcHvWbrx5fgOVnWJjXElSl5cQvK4p6fcMs,1011
+cryptointerface-0.1.0.dist-info/METADATA,sha256=s6XOY2KzDcFpWnp6PoZyNbtVEylN7PgIK5PU9L0Sln0,10506
+cryptointerface-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+cryptointerface-0.1.0.dist-info/RECORD,,

cryptointerface-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any