wayfinder-paths 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

wayfinder_paths/core/clients/test_ledger_client.py

@@ -0,0 +1,448 @@
+import asyncio
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from wayfinder_paths.core.adapters.models import LEND, SWAP, UNLEND
+from wayfinder_paths.core.clients.LedgerClient import LedgerClient
+
+
+@pytest.fixture
+def temp_ledger_dir():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        yield Path(tmpdir)
+
+
+@pytest.fixture
+def ledger_client(temp_ledger_dir):
+    return LedgerClient(ledger_dir=temp_ledger_dir)
+
+
+@pytest.fixture
+def test_wallet_address():
+    return "0x1234567890abcdef1234567890abcdef12345678"
+
+
+class TestLedgerClientInitialization:
+    def test_creates_ledger_directory(self, temp_ledger_dir):
+        assert not (temp_ledger_dir / "transactions.json").exists()
+
+        LedgerClient(ledger_dir=temp_ledger_dir)
+
+        assert (temp_ledger_dir / "transactions.json").exists()
+        assert (temp_ledger_dir / "snapshots.json").exists()
+
+    def test_initializes_empty_json_files(self, ledger_client, temp_ledger_dir):
+        transactions_data = json.loads(
+            (temp_ledger_dir / "transactions.json").read_text()
+        )
+        snapshots_data = json.loads((temp_ledger_dir / "snapshots.json").read_text())
+
+        assert transactions_data == {"transactions": []}
+        assert snapshots_data == {"snapshots": []}
+
+
+class TestDepositOperations:
+    @pytest.mark.asyncio
+    async def test_add_deposit(self, ledger_client, test_wallet_address):
+        result = await ledger_client.add_strategy_deposit(
+            wallet_address=test_wallet_address,
+            chain_id=1,
+            token_address="0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+            token_amount="1000.0",
+            usd_value="1000.0",
+            strategy_name="Test Strategy",
+            data={"note": "Test deposit"},
+        )
+
+        assert result["status"] == "success"
+        assert "transaction_id" in result
+        assert "timestamp" in result
+
+    @pytest.mark.asyncio
+    async def test_deposit_creates_transaction_record(
+        self, ledger_client, test_wallet_address, temp_ledger_dir
+    ):
+        await ledger_client.add_strategy_deposit(
+            wallet_address=test_wallet_address,
+            chain_id=1,
+            token_address="0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+            token_amount="1000.0",
+            usd_value="1000.0",
+            strategy_name="Test Strategy",
+        )
+
+        data = json.loads((temp_ledger_dir / "transactions.json").read_text())
+        transactions = data["transactions"]
+
+        assert len(transactions) == 1
+        assert transactions[0]["operation"] == "DEPOSIT"
+        assert transactions[0]["wallet_address"] == test_wallet_address
+        assert transactions[0]["usd_value"] == "1000.0"
+        assert transactions[0]["strategy_name"] == "Test Strategy"
+
+
+class TestWithdrawalOperations:
+    @pytest.mark.asyncio
+    async def test_add_withdrawal(self, ledger_client, test_wallet_address):
+        result = await ledger_client.add_strategy_withdraw(
+            wallet_address=test_wallet_address,
+            chain_id=1,
+            token_address="0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+            token_amount="500.0",
+            usd_value="500.0",
+            strategy_name="Test Strategy",
+        )
+
+        assert result["status"] == "success"
+        assert "transaction_id" in result
+
+
+class TestOperationRecording:
+    @pytest.mark.asyncio
+    async def test_add_swap_operation(self, ledger_client, test_wallet_address):
+        swap_op = SWAP(
+            adapter="TestAdapter",
+            from_token_id="usd-coin-base",
+            to_token_id="aerodrome-usdc-base",
+            from_amount="1000000000",
+            to_amount="1000000000",
+            from_amount_usd=1000.0,
+            to_amount_usd=1000.0,
+            transaction_hash="0xabc123",
+            transaction_chain_id=8453,
+        )
+
+        result = await ledger_client.add_strategy_operation(
+            wallet_address=test_wallet_address,
+            operation_data=swap_op.model_dump(mode="json"),
+            usd_value="1000.0",
+            strategy_name="Test Strategy",
+        )
+
+        assert result["status"] == "success"
+
+    @pytest.mark.asyncio
+    async def test_add_lend_operation(self, ledger_client, test_wallet_address):
+        lend_op = LEND(
+            adapter="TestAdapter",
+            token_address="0xTokenAddress",
+            pool_address="0xPoolContract",
+            amount="1000000000",
+            amount_usd=1000.0,
+            transaction_hash="0xdef456",
+            transaction_chain_id=8453,
+        )
+
+        result = await ledger_client.add_strategy_operation(
+            wallet_address=test_wallet_address,
+            operation_data=lend_op.model_dump(mode="json"),
+            usd_value="1000.0",
+        )
+
+        assert result["status"] == "success"
+
+    @pytest.mark.asyncio
+    async def test_add_unlend_operation(self, ledger_client, test_wallet_address):
+        unlend_op = UNLEND(
+            adapter="TestAdapter",
+            token_address="0xTokenAddress",
+            pool_address="0xPoolContract",
+            amount="1000000000",
+            amount_usd=1000.0,
+            transaction_hash="0xghi789",
+            transaction_chain_id=8453,
+        )
+
+        result = await ledger_client.add_strategy_operation(
+            wallet_address=test_wallet_address,
+            operation_data=unlend_op.model_dump(mode="json"),
+            usd_value="1000.0",
+        )
+
+        assert result["status"] == "success"
+
+    @pytest.mark.asyncio
+    async def test_operation_stores_op_data(
+        self, ledger_client, test_wallet_address, temp_ledger_dir
+    ):
+        swap_op = SWAP(
+            adapter="TestAdapter",
+            from_token_id="token-a",
+            to_token_id="token-b",
+            from_amount="100",
+            to_amount="95",
+            from_amount_usd=100.0,
+            to_amount_usd=95.0,
+            transaction_hash="0xjkl012",
+            transaction_chain_id=8453,
+        )
+
+        await ledger_client.add_strategy_operation(
+            wallet_address=test_wallet_address,
+            operation_data=swap_op.model_dump(mode="json"),
+            usd_value="100.0",
+        )
+
+        data = json.loads((temp_ledger_dir / "transactions.json").read_text())
+        transaction = data["transactions"][0]
+
+        assert transaction["operation"] == "STRAT_OP"
+        assert "data" in transaction
+        assert "op_data" in transaction["data"]
+        assert transaction["data"]["op_data"]["type"] == "SWAP"
+        assert transaction["usd_value"] == "100.0"
+        assert "id" in transaction
+        assert "timestamp" in transaction
+        assert "wallet_address" in transaction
+        # Stored minimal; amount/token_address derived when formatting
+        assert transaction["amount"] == "0"
+        assert transaction["token_address"] == ""
+
+        # Formatted output derives amount/token_address from op_data
+        list_result = await ledger_client.get_strategy_transactions(
+            wallet_address=test_wallet_address
+        )
+        txn = list_result["transactions"][0]
+        assert txn["amount"] == "95"
+        assert txn["token_address"] == "token-b"
+
+
+class TestTransactionRetrieval:
+    @pytest.mark.asyncio
+    async def test_get_empty_transactions(self, ledger_client, test_wallet_address):
+        result = await ledger_client.get_strategy_transactions(
+            wallet_address=test_wallet_address
+        )
+
+        assert result["transactions"] == []
+        assert result["total"] == 0
+
+    @pytest.mark.asyncio
+    async def test_get_transactions_filters_by_wallet(
+        self, ledger_client, test_wallet_address
+    ):
+        await ledger_client.add_strategy_deposit(
+            wallet_address=test_wallet_address,
+            chain_id=1,
+            token_address="0xTest",
+            token_amount="100",
+            usd_value="100",
+        )
+
+        await ledger_client.add_strategy_deposit(
+            wallet_address="0xDifferentWallet",
+            chain_id=1,
+            token_address="0xTest",
+            token_amount="200",
+            usd_value="200",
+        )
+
+        result = await ledger_client.get_strategy_transactions(
+            wallet_address=test_wallet_address
+        )
+
+        assert result["total"] == 1
+        # Return shape is StrategyTransaction (no wallet_address in list items)
+        tx = result["transactions"][0]
+        assert tx["operation"] == "DEPOSIT"
+        assert tx["amount"] == "100"
+        assert tx["token_address"] == "0xTest"
+        assert tx["usd_value"] == "100"
+
+    @pytest.mark.asyncio
+    async def test_get_transactions_pagination(
+        self, ledger_client, test_wallet_address
+    ):
+        for i in range(5):
+            await ledger_client.add_strategy_deposit(
+                wallet_address=test_wallet_address,
+                chain_id=1,
+                token_address="0xTest",
+                token_amount=str(100 * (i + 1)),
+                usd_value=str(100 * (i + 1)),
+            )
+
+        result = await ledger_client.get_strategy_transactions(
+            wallet_address=test_wallet_address, limit=2, offset=0
+        )
+
+        assert result["total"] == 5
+        assert len(result["transactions"]) == 2
+        assert result["limit"] == 2
+        assert result["offset"] == 0
+
+        result = await ledger_client.get_strategy_transactions(
+            wallet_address=test_wallet_address, limit=2, offset=2
+        )
+
+        assert len(result["transactions"]) == 2
+        assert result["offset"] == 2
+
+    @pytest.mark.asyncio
+    async def test_get_latest_transactions(self, ledger_client, test_wallet_address):
+        # get_strategy_latest_transactions returns only STRAT_OP (limit 80), matching vault
+        for i in range(3):
+            await ledger_client.add_strategy_operation(
+                wallet_address=test_wallet_address,
+                operation_data={"type": "SWAP", "to_token_id": f"token-{i}"},
+                usd_value=str(i),
+            )
+
+        result = await ledger_client.get_strategy_latest_transactions(
+            wallet_address=test_wallet_address
+        )
+
+        assert len(result["transactions"]) == 3
+        assert result["limit"] == 80
+        assert result["offset"] == 0
+        assert result["total"] == 3
+        # Should be sorted by timestamp descending (most recent first)
+
+
+class TestNetDepositCalculation:
+    @pytest.mark.asyncio
+    async def test_net_deposit_empty(self, ledger_client, test_wallet_address):
+        result = await ledger_client.get_strategy_net_deposit(
+            wallet_address=test_wallet_address
+        )
+
+        assert result == 0.0
+
+    @pytest.mark.asyncio
+    async def test_net_deposit_only_deposits(self, ledger_client, test_wallet_address):
+        await ledger_client.add_strategy_deposit(
+            wallet_address=test_wallet_address,
+            chain_id=1,
+            token_address="0xTest",
+            token_amount="1000",
+            usd_value="1000",
+        )
+
+        await ledger_client.add_strategy_deposit(
+            wallet_address=test_wallet_address,
+            chain_id=1,
+            token_address="0xTest",
+            token_amount="500",
+            usd_value="500",
+        )
+
+        result = await ledger_client.get_strategy_net_deposit(
+            wallet_address=test_wallet_address
+        )
+
+        assert result == 1500.0
+
+    @pytest.mark.asyncio
+    async def test_net_deposit_with_withdrawals(
+        self, ledger_client, test_wallet_address
+    ):
+        await ledger_client.add_strategy_deposit(
+            wallet_address=test_wallet_address,
+            chain_id=1,
+            token_address="0xTest",
+            token_amount="1000",
+            usd_value="1000",
+        )
+
+        await ledger_client.add_strategy_withdraw(
+            wallet_address=test_wallet_address,
+            chain_id=1,
+            token_address="0xTest",
+            token_amount="300",
+            usd_value="300",
+        )
+
+        result = await ledger_client.get_strategy_net_deposit(
+            wallet_address=test_wallet_address
+        )
+
+        assert result == 700.0
+
+
+class TestSnapshotRecording:
+    @pytest.mark.asyncio
+    async def test_record_snapshot(self, ledger_client, test_wallet_address):
+        await ledger_client.strategy_snapshot(
+            wallet_address=test_wallet_address,
+            strat_portfolio_value=1050.0,
+            net_deposit=1000.0,
+            strategy_status={"current_pool": "test-pool", "apy": "5.2%"},
+            gas_available=0.01,
+            gassed_up=True,
+        )
+
+        # Verify snapshot was saved (no return value)
+        # We verify by reading the file
+        # This is done indirectly through the client
+
+    @pytest.mark.asyncio
+    async def test_snapshot_creates_record(
+        self, ledger_client, test_wallet_address, temp_ledger_dir
+    ):
+        await ledger_client.strategy_snapshot(
+            wallet_address=test_wallet_address,
+            strat_portfolio_value=1050.0,
+            net_deposit=1000.0,
+            strategy_status={"pool": "test"},
+            gas_available=0.01,
+            gassed_up=True,
+        )
+
+        data = json.loads((temp_ledger_dir / "snapshots.json").read_text())
+        snapshots = data["snapshots"]
+
+        assert len(snapshots) == 1
+        assert snapshots[0]["wallet_address"] == test_wallet_address
+        assert snapshots[0]["portfolio_value"] == 1050.0
+        assert snapshots[0]["net_deposit"] == 1000.0
+        assert snapshots[0]["gas_available"] == 0.01
+        assert snapshots[0]["gassed_up"] is True
+        assert snapshots[0]["strategy_status"] == {"pool": "test"}
+
+    @pytest.mark.asyncio
+    async def test_multiple_snapshots(
+        self, ledger_client, test_wallet_address, temp_ledger_dir
+    ):
+        for i in range(3):
+            await ledger_client.strategy_snapshot(
+                wallet_address=test_wallet_address,
+                strat_portfolio_value=1000.0 + (i * 10),
+                net_deposit=1000.0,
+                strategy_status={"iteration": i},
+                gas_available=0.01,
+                gassed_up=True,
+            )
+
+        data = json.loads((temp_ledger_dir / "snapshots.json").read_text())
+        snapshots = data["snapshots"]
+
+        assert len(snapshots) == 3
+        assert snapshots[0]["portfolio_value"] == 1000.0
+        assert snapshots[1]["portfolio_value"] == 1010.0
+        assert snapshots[2]["portfolio_value"] == 1020.0
+
+
+class TestConcurrency:
+    @pytest.mark.asyncio
+    async def test_concurrent_writes(self, ledger_client, test_wallet_address):
+        async def add_deposit(amount):
+            await ledger_client.add_strategy_deposit(
+                wallet_address=test_wallet_address,
+                chain_id=1,
+                token_address="0xTest",
+                token_amount=str(amount),
+                usd_value=str(amount),
+            )
+
+        # Execute multiple deposits concurrently
+        await asyncio.gather(*[add_deposit(i * 100) for i in range(5)])
+
+        result = await ledger_client.get_strategy_transactions(
+            wallet_address=test_wallet_address
+        )
+
+        # All 5 transactions should be recorded
+        assert result["total"] == 5

wayfinder_paths/core/config.py

@@ -1,4 +1,5 @@
 import json
+import os
 from pathlib import Path
 from typing import Any
 
@@ -37,3 +38,14 @@ def get_api_base_url() -> str:
     if api_url and isinstance(api_url, str):
         return api_url.strip()
     return "https://wayfinder.ai/api/v1"
+
+
+def get_api_key() -> str | None:
+    """Get API key from config or environment."""
+    # Check config first
+    system = CONFIG.get("system", {}) if isinstance(CONFIG, dict) else {}
+    api_key = system.get("api_key")
+    if api_key and isinstance(api_key, str):
+        return api_key.strip()
+    # Fall back to environment variable
+    return os.environ.get("WAYFINDER_API_KEY")

wayfinder_paths/core/constants/__init__.py

@@ -37,6 +37,15 @@ from wayfinder_paths.core.constants.contracts import (
     ZERO_ADDRESS,
 )
 
+from .hyperliquid import (
+    ARBITRUM_USDC_ADDRESS,
+    ARBITRUM_USDC_TOKEN_ID,
+    DEFAULT_HYPERLIQUID_BUILDER_FEE,
+    DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP,
+    HYPE_FEE_WALLET,
+    HYPERLIQUID_BRIDGE_ADDRESS,
+)
+
 __all__ = [
     "NATIVE_TOKEN_SENTINEL",
     "ZERO_ADDRESS",
@@ -70,4 +79,10 @@ __all__ = [
     "SUPPORTED_CHAINS",
     "POA_MIDDLEWARE_CHAIN_IDS",
     "PRE_EIP_1559_CHAIN_IDS",
+    "HYPERLIQUID_BRIDGE_ADDRESS",
+    "ARBITRUM_USDC_ADDRESS",
+    "ARBITRUM_USDC_TOKEN_ID",
+    "HYPE_FEE_WALLET",
+    "DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP",
+    "DEFAULT_HYPERLIQUID_BUILDER_FEE",
 ]

wayfinder_paths/core/constants/base.py

@@ -6,7 +6,12 @@ SUGGESTED_GAS_PRICE_MULTIPLIER = 1.5
 
 DEFAULT_SLIPPAGE = 0.005
 
-DEFAULT_HTTP_TIMEOUT = 30.0
+# Timeout constants (seconds)
+# Base L2 (and some RPC providers) can occasionally take >2 minutes to index/return receipts,
+# even if the transaction is eventually mined. A longer timeout reduces false negatives that
+# can lead to unsafe retry behavior (nonce gaps, duplicate swaps, etc.).
+DEFAULT_HTTP_TIMEOUT = 30.0  # HTTP client timeout
+DEFAULT_TRANSACTION_TIMEOUT = 180  # Transaction receipt timeout (seconds)
 
 ADAPTER_BALANCE = "BALANCE"
 ADAPTER_BRAP = "BRAP"

wayfinder_paths/core/constants/contracts.py

@@ -1,36 +1,49 @@
-ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
-NATIVE_TOKEN_SENTINEL = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
-
-BASE_WETH = "0x4200000000000000000000000000000000000006"
-BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-BASE_WSTETH = "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452"
-
-MOONWELL_M_USDC = "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22"
-MOONWELL_M_WETH = "0x628ff693426583D9a7FB391E54366292F509D457"
-MOONWELL_M_WSTETH = "0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b"
-MOONWELL_COMPTROLLER = "0xfbb21d0380bee3312b33c4353c8936a0f13ef26c"
-MOONWELL_REWARD_DISTRIBUTOR = "0xe9005b078701e2a0948d2eac43010d35870ad9d2"
-MOONWELL_WELL_TOKEN = "0xA88594D404727625A9437C3f886C7643872296AE"
+from eth_utils import to_checksum_address
 
-ENSO_ROUTER = "0xf75584ef6673ad213a685a1b58cc0330b8ea22cf"
-
-HYPEREVM_WHYPE = "0x5555555555555555555555555555555555555555"
-HYPERCORE_SENTINEL_ADDRESS = "0x2222222222222222222222222222222222222222"
+ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
+NATIVE_TOKEN_SENTINEL = to_checksum_address(
+    "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
+)
+
+BASE_WETH = to_checksum_address("0x4200000000000000000000000000000000000006")
+BASE_USDC = to_checksum_address("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913")
+BASE_WSTETH = to_checksum_address("0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452")
+
+MOONWELL_M_USDC = to_checksum_address("0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22")
+MOONWELL_M_WETH = to_checksum_address("0x628ff693426583D9a7FB391E54366292F509D457")
+MOONWELL_M_WSTETH = to_checksum_address("0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b")
+MOONWELL_COMPTROLLER = to_checksum_address("0xfBb21d0380beE3312B33c4353c8936a0F13EF26C")
+MOONWELL_REWARD_DISTRIBUTOR = to_checksum_address(
+    "0xe9005b078701e2A0948D2EaC43010D35870Ad9d2"
+)
+MOONWELL_WELL_TOKEN = to_checksum_address("0xA88594D404727625A9437C3f886C7643872296AE")
+
+ENSO_ROUTER = to_checksum_address("0xF75584eF6673aD213a685a1B58Cc0330B8eA22Cf")
+
+HYPEREVM_WHYPE = to_checksum_address("0x5555555555555555555555555555555555555555")
+HYPERCORE_SENTINEL_ADDRESS = to_checksum_address(
+    "0x2222222222222222222222222222222222222222"
+)
 HYPERCORE_SENTINEL_VALUE = 100_000_000_000
 
-HYPERLEND_POOL = "0x00A89d7a5A02160f20150EbEA7a2b5E4879A1A8b"
-HYPERLEND_WRAPPED_TOKEN_GATEWAY = "0x49558c794ea2aC8974C9F27886DDfAa951E99171"
+HYPERLEND_POOL = to_checksum_address("0x00A89d7a5A02160f20150EbEA7a2b5E4879A1A8b")
+HYPERLEND_WRAPPED_TOKEN_GATEWAY = to_checksum_address(
+    "0x49558c794ea2aC8974C9F27886DDfAa951E99171"
+)
+
+PRJX_ROUTER = to_checksum_address("0x1EbDFC75FfE3ba3de61E7138a3E8706aC841Af9B")
+PRJX_NPM = to_checksum_address("0xeaD19AE861c29bBb2101E834922B2FEee69B9091")
 
-PRJX_ROUTER = "0x1ebdfc75ffe3ba3de61e7138a3e8706ac841af9b"
-PRJX_NPM = "0xeAd19AE861c29bBb2101E834922B2FEee69B9091"
+ARBITRUM_USDC = to_checksum_address("0xaf88d065e77c8cC2239327C5EDb3A432268e5831")
 
-ARBITRUM_USDC = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+HYPERLIQUID_BRIDGE = to_checksum_address("0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7")
 
-HYPERLIQUID_BRIDGE = "0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7"
+BOROS_ROUTER = to_checksum_address("0x8080808080dab95efed788a9214e400ba552def6")
+BOROS_MARKET_HUB = to_checksum_address("0x1080808080f145b14228443212e62447c112adad")
 
-USDT_ETHEREUM = "0xdac17f958d2ee523a2206206994597c13d831ec7"
-USDT_POLYGON = "0xc2132d05d31c914a87c6611c10748aeb04b58e8f"
-USDT_BSC = "0x55d398326f99059ff775485246999027b3197955"
+USDT_ETHEREUM = to_checksum_address("0xdAC17F958D2ee523a2206206994597C13D831ec7")
+USDT_POLYGON = to_checksum_address("0xc2132D05D31c914a87C6611C10748AEb04B58e8F")
+USDT_BSC = to_checksum_address("0x55d398326f99059fF775485246999027B3197955")
 
 TOKENS_REQUIRING_APPROVAL_RESET: set[tuple[int, str]] = {
     (1, USDT_ETHEREUM),

wayfinder_paths/core/constants/erc20_abi.py

@@ -1,4 +1,3 @@
-# Standard ERC20 ABI - includes common functions needed for token operations
 ERC20_ABI = [
     {
         "constant": True,

wayfinder_paths/core/constants/hyperlend_abi.py

@@ -1,4 +1,3 @@
-# Minimal Pool ABI for supply and deposit operations
 POOL_ABI = [
     {
         "name": "supply",
@@ -37,7 +36,6 @@ POOL_ABI = [
     },
 ]
 
-# Protocol Data Provider ABI for reserve token addresses and user data
 PROTOCOL_DATA_PROVIDER_ABI = [
     {
         "type": "function",
@@ -71,7 +69,6 @@ PROTOCOL_DATA_PROVIDER_ABI = [
     },
 ]
 
-# Wrapped Token Gateway ABI for native token operations
 WRAPPED_TOKEN_GATEWAY_ABI = [
     {
         "type": "function",
@@ -126,7 +123,6 @@ WRAPPED_TOKEN_GATEWAY_ABI = [
     },
 ]
 
-# WETH ABI for native token wrapping
 WETH_ABI = [
     {
         "inputs": [],

wayfinder_paths/core/constants/hyperliquid.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any
+
+HYPERLIQUID_BRIDGE_ADDRESS: str = "0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7"
+ARBITRUM_USDC_ADDRESS: str = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+ARBITRUM_USDC_TOKEN_ID: str = "usd-coin-arbitrum"
+HYPE_FEE_WALLET: str = "0xaA1D89f333857eD78F8434CC4f896A9293EFE65c"
+
+# Tenths of a basis point: 30 -> 0.030% (3 bps)
+DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP: int = 30
+
+DEFAULT_HYPERLIQUID_BUILDER_FEE: dict[str, Any] = {
+    "b": HYPE_FEE_WALLET,
+    "f": DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP,
+}