@agentlayer.tech/wallet 0.1.15 → 0.1.16

package/agent-wallet/agent_wallet/providers/flash.py

@@ -0,0 +1,186 @@
+"""Flash Trade provider helpers for perps market and position reads."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+from agent_wallet.config import settings
+from agent_wallet.exceptions import ProviderError
+from agent_wallet.http_client import get_client
+
+PROVIDER_NAME = "flash-trade"
+
+
+def _headers() -> dict[str, str]:
+    return {"Accept": "application/json"}
+
+
+def _gateway_base_url() -> str:
+    return os.getenv("PROVIDER_GATEWAY_URL", settings.provider_gateway_url).strip().rstrip("/")
+
+
+def _gateway_headers() -> dict[str, str]:
+    headers = {"Accept": "application/json"}
+    bearer = os.getenv(
+        "PROVIDER_GATEWAY_BEARER_TOKEN",
+        settings.provider_gateway_bearer_token,
+    ).strip()
+    if bearer:
+        headers["Authorization"] = f"Bearer {bearer}"
+    return headers
+
+
+def _gateway_enabled() -> bool:
+    return bool(_gateway_base_url())
+
+
+def _direct_base_url() -> str:
+    return os.getenv("FLASH_API_BASE_URL", settings.flash_api_base_url).strip().rstrip("/")
+
+
+def _direct_enabled() -> bool:
+    return bool(_direct_base_url())
+
+
+def _route_missing(status_code: int, payload: Any) -> bool:
+    if status_code == 404:
+        return True
+    if isinstance(payload, dict):
+        message = str(payload.get("error") or payload.get("message") or "").lower()
+        if "not found" in message or "unknown route" in message:
+            return True
+    return False
+
+
+async def _request_json(
+    url: str,
+    *,
+    params: dict[str, Any] | None,
+    headers: dict[str, str],
+) -> tuple[int, Any]:
+    client = get_client()
+    try:
+        response = await client.get(url, params=params, headers=headers)
+    except httpx.HTTPError as exc:
+        raise ProviderError(
+            PROVIDER_NAME,
+            f"HTTP request failed: {exc}",
+        ) from exc
+    if not response.content:
+        return response.status_code, {}
+    try:
+        return response.status_code, response.json()
+    except ValueError:
+        return response.status_code, response.text[:500]
+
+
+def _unwrap_response(
+    status_code: int,
+    payload: Any,
+    *,
+    operation: str,
+) -> Any:
+    if isinstance(payload, dict) and payload.get("ok") is False:
+        message = str(payload.get("error") or payload.get("message") or f"{operation} failed.")
+        raise ProviderError(PROVIDER_NAME, f"{operation} failed: {message}")
+
+    if status_code != 200:
+        message = payload
+        if isinstance(payload, dict):
+            message = payload.get("error") or payload.get("message") or payload
+        raise ProviderError(PROVIDER_NAME, f"{operation} failed: {message}")
+
+    return payload
+
+
+async def _get_with_fallback(
+    path: str,
+    *,
+    params: dict[str, Any] | None,
+    operation: str,
+) -> Any:
+    if _gateway_enabled():
+        status_code, payload = await _request_json(
+            f"{_gateway_base_url()}{path}",
+            params=params,
+            headers=_gateway_headers(),
+        )
+        if not _route_missing(status_code, payload):
+            return _unwrap_response(status_code, payload, operation=operation)
+
+    if _direct_enabled():
+        direct_variants = [path]
+        if path == "/v1/flash/perps/markets":
+            direct_variants.append("/markets")
+        elif path == "/v1/flash/perps/positions":
+            direct_variants.append("/positions")
+        last_status = 404
+        last_payload: Any = {"error": "not found"}
+        for direct_path in direct_variants:
+            status_code, payload = await _request_json(
+                f"{_direct_base_url()}{direct_path}",
+                params=params,
+                headers=_headers(),
+            )
+            last_status = status_code
+            last_payload = payload
+            if _route_missing(status_code, payload) and direct_path != direct_variants[-1]:
+                continue
+            return _unwrap_response(status_code, payload, operation=operation)
+        return _unwrap_response(last_status, last_payload, operation=operation)
+
+    raise ProviderError(
+        PROVIDER_NAME,
+        (
+            f"{operation} is not configured. "
+            "Expose Flash routes on PROVIDER_GATEWAY_URL or set FLASH_API_BASE_URL."
+        ),
+    )
+
+
+def _normalize_named_list_response(
+    data: Any,
+    *,
+    key: str,
+) -> dict[str, Any]:
+    if isinstance(data, list):
+        return {key: data}
+    if isinstance(data, dict):
+        items = data.get(key)
+        if isinstance(items, list):
+            return data
+        fallback = data.get("data")
+        if isinstance(fallback, list):
+            normalized = dict(data)
+            normalized[key] = fallback
+            return normalized
+    raise ProviderError(PROVIDER_NAME, f"Unexpected {key} response from Flash Trade.")
+
+
+async def fetch_markets(*, pool_name: str | None = None) -> dict[str, Any]:
+    params = {"pool_name": pool_name} if pool_name else None
+    data = await _get_with_fallback(
+        "/v1/flash/perps/markets",
+        params=params,
+        operation="Flash Trade market lookup",
+    )
+    return _normalize_named_list_response(data, key="markets")
+
+
+async def fetch_positions(
+    *,
+    owner: str,
+    pool_name: str | None = None,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {"owner": owner}
+    if pool_name:
+        params["pool_name"] = pool_name
+    data = await _get_with_fallback(
+        "/v1/flash/perps/positions",
+        params=params,
+        operation="Flash Trade position lookup",
+    )
+    return _normalize_named_list_response(data, key="positions")

package/agent-wallet/agent_wallet/providers/flash_sdk_bridge.py

@@ -0,0 +1,251 @@
+"""Local bridge contract for Flash SDK-backed preview generation."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shlex
+from typing import Any
+
+from agent_wallet.config import resolve_solana_rpc_url, settings
+from agent_wallet.exceptions import ProviderError
+
+PROVIDER_NAME = "flash-sdk-bridge"
+
+
+def _bridge_command() -> list[str]:
+    raw = os.getenv("FLASH_SDK_BRIDGE_COMMAND", settings.flash_sdk_bridge_command).strip()
+    if not raw:
+        raise ProviderError(
+            PROVIDER_NAME,
+            "FLASH_SDK_BRIDGE_COMMAND is not configured.",
+        )
+    try:
+        command = shlex.split(raw)
+    except ValueError as exc:
+        raise ProviderError(PROVIDER_NAME, f"Invalid FLASH_SDK_BRIDGE_COMMAND: {exc}") from exc
+    if not command:
+        raise ProviderError(PROVIDER_NAME, "FLASH_SDK_BRIDGE_COMMAND is empty.")
+    return command
+
+
+def _bridge_timeout_seconds() -> float:
+    raw = os.getenv(
+        "FLASH_SDK_BRIDGE_TIMEOUT_SECONDS",
+        str(settings.flash_sdk_bridge_timeout_seconds),
+    ).strip()
+    try:
+        timeout = float(raw)
+    except ValueError as exc:
+        raise ProviderError(
+            PROVIDER_NAME,
+            "FLASH_SDK_BRIDGE_TIMEOUT_SECONDS must be numeric.",
+        ) from exc
+    return max(timeout, 1.0)
+
+
+def _bridge_env(payload: dict[str, Any]) -> dict[str, str]:
+    env = os.environ.copy()
+
+    bridge_mode = env.get("FLASH_SDK_BRIDGE_MODE", "").strip() or settings.flash_sdk_bridge_mode.strip()
+    if bridge_mode:
+        env["FLASH_SDK_BRIDGE_MODE"] = bridge_mode
+
+    if not env.get("SOLANA_RPC_URL", "").strip() and not env.get("RPC_URL", "").strip():
+        network = str(payload.get("network") or settings.solana_network or "mainnet").strip()
+        resolved_rpc_url = resolve_solana_rpc_url(network, settings.solana_rpc_url)
+        if resolved_rpc_url:
+            env["SOLANA_RPC_URL"] = resolved_rpc_url
+
+    return env
+
+
+def _unwrap_bridge_payload(payload: Any, *, operation: str) -> dict[str, Any]:
+    if not isinstance(payload, dict):
+        raise ProviderError(PROVIDER_NAME, f"{operation} returned a non-object response.")
+    if payload.get("ok") is False:
+        message = str(payload.get("error") or f"{operation} failed.")
+        raise ProviderError(PROVIDER_NAME, message)
+    data = payload.get("preview")
+    if isinstance(data, dict):
+        return data
+    data = payload.get("prepared")
+    if isinstance(data, dict):
+        return data
+    if isinstance(payload.get("data"), dict):
+        return dict(payload["data"])
+    return dict(payload)
+
+
+async def _call_bridge(payload: dict[str, Any]) -> dict[str, Any]:
+    command = _bridge_command()
+    env = _bridge_env(payload)
+    try:
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+        )
+    except OSError as exc:
+        raise ProviderError(PROVIDER_NAME, f"Could not start Flash SDK bridge: {exc}") from exc
+
+    stdin_bytes = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    timeout = _bridge_timeout_seconds()
+    try:
+        stdout, stderr = await asyncio.wait_for(
+            process.communicate(stdin_bytes),
+            timeout=timeout,
+        )
+    except asyncio.TimeoutError as exc:
+        process.kill()
+        await process.wait()
+        raise ProviderError(
+            PROVIDER_NAME,
+            f"Flash SDK bridge timed out after {timeout:.1f}s.",
+        ) from exc
+
+    if process.returncode != 0:
+        message = stderr.decode("utf-8", errors="replace").strip() or stdout.decode(
+            "utf-8",
+            errors="replace",
+        ).strip()
+        raise ProviderError(
+            PROVIDER_NAME,
+            f"Flash SDK bridge failed with exit code {process.returncode}: {message[:500]}",
+        )
+
+    try:
+        decoded = json.loads(stdout.decode("utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ProviderError(
+            PROVIDER_NAME,
+            "Flash SDK bridge returned invalid JSON.",
+        ) from exc
+    return decoded
+
+
+async def preview_open_position_same_collateral(
+    *,
+    owner: str,
+    pool_name: str,
+    market_symbol: str,
+    collateral_symbol: str,
+    collateral_amount_raw: str,
+    leverage: str,
+    side: str,
+    network: str,
+) -> dict[str, Any]:
+    payload = {
+        "action": "preview_open_position_same_collateral",
+        "owner": owner,
+        "pool_name": pool_name,
+        "market_symbol": market_symbol,
+        "collateral_symbol": collateral_symbol,
+        "collateral_amount_raw": collateral_amount_raw,
+        "leverage": leverage,
+        "side": side,
+        "network": network,
+    }
+    response = await _call_bridge(payload)
+    return _unwrap_bridge_payload(response, operation="Flash open-position preview")
+
+
+async def get_markets(
+    *,
+    pool_name: str | None,
+    network: str,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "action": "get_markets",
+        "network": network,
+    }
+    if pool_name:
+        payload["pool_name"] = pool_name
+    response = await _call_bridge(payload)
+    return _unwrap_bridge_payload(response, operation="Flash market lookup")
+
+
+async def get_positions(
+    *,
+    owner: str,
+    pool_name: str | None,
+    network: str,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "action": "get_positions",
+        "owner": owner,
+        "network": network,
+    }
+    if pool_name:
+        payload["pool_name"] = pool_name
+    response = await _call_bridge(payload)
+    return _unwrap_bridge_payload(response, operation="Flash position lookup")
+
+
+async def preview_close_position_same_collateral(
+    *,
+    owner: str,
+    pool_name: str,
+    market_symbol: str,
+    side: str,
+    network: str,
+) -> dict[str, Any]:
+    payload = {
+        "action": "preview_close_position_same_collateral",
+        "owner": owner,
+        "pool_name": pool_name,
+        "market_symbol": market_symbol,
+        "side": side,
+        "network": network,
+    }
+    response = await _call_bridge(payload)
+    return _unwrap_bridge_payload(response, operation="Flash close-position preview")
+
+
+async def prepare_open_position_same_collateral(
+    *,
+    owner: str,
+    pool_name: str,
+    market_symbol: str,
+    collateral_symbol: str,
+    collateral_amount_raw: str,
+    leverage: str,
+    side: str,
+    network: str,
+) -> dict[str, Any]:
+    payload = {
+        "action": "prepare_open_position_same_collateral",
+        "owner": owner,
+        "pool_name": pool_name,
+        "market_symbol": market_symbol,
+        "collateral_symbol": collateral_symbol,
+        "collateral_amount_raw": collateral_amount_raw,
+        "leverage": leverage,
+        "side": side,
+        "network": network,
+    }
+    response = await _call_bridge(payload)
+    return _unwrap_bridge_payload(response, operation="Flash open-position prepare")
+
+
+async def prepare_close_position_same_collateral(
+    *,
+    owner: str,
+    pool_name: str,
+    market_symbol: str,
+    side: str,
+    network: str,
+) -> dict[str, Any]:
+    payload = {
+        "action": "prepare_close_position_same_collateral",
+        "owner": owner,
+        "pool_name": pool_name,
+        "market_symbol": market_symbol,
+        "side": side,
+        "network": network,
+    }
+    response = await _call_bridge(payload)
+    return _unwrap_bridge_payload(response, operation="Flash close-position prepare")

package/agent-wallet/agent_wallet/transaction_policy.py

@@ -767,3 +767,82 @@ def verify_provider_kamino_lend_transaction(
         "action": action,
         "verified": True,
     }
+
+
+def verify_provider_flash_transaction(
+    message: Any,
+    *,
+    wallet_address: str,
+    market_address: str,
+    target_custody_address: str,
+    collateral_custody_address: str,
+    action: str,
+    expected_program_ids: list[str],
+    position_address: str | None = None,
+    collateral_mint: str | None = None,
+    loaded_addresses: list[str] | None = None,
+) -> dict[str, Any]:
+    binding = _assert_basic_wallet_binding(
+        message,
+        wallet_address=wallet_address,
+        loaded_addresses=loaded_addresses,
+    )
+    keys = binding["account_keys"]
+    if market_address not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Flash market account."
+        )
+    if target_custody_address not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Flash target custody."
+        )
+    if collateral_custody_address not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Flash collateral custody."
+        )
+    if position_address and position_address not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Flash position account."
+        )
+    if collateral_mint and collateral_mint not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Flash collateral mint."
+        )
+
+    allowed_programs = CORE_PROGRAM_IDS | {pid for pid in expected_program_ids if pid}
+    program_ids = _program_ids(message, loaded_addresses)
+    unknown_program_ids = _assert_program_allowlist(
+        program_ids,
+        allowed_programs=allowed_programs,
+        label=action,
+        reject_unknown=False,
+    )
+    recognized_flash_program_ids = [
+        pid for pid in program_ids if pid in expected_program_ids
+    ]
+    if not recognized_flash_program_ids:
+        raise WalletBackendError(
+            f"{action} transaction does not include the expected Flash program."
+        )
+    return {
+        "wallet_address": wallet_address,
+        "fee_payer": binding["fee_payer"],
+        "required_signer_keys": binding["required_signer_keys"],
+        "required_signature_count": binding["required_signature_count"],
+        "wallet_signer_index": binding["wallet_signer_index"],
+        "sponsored_fee_payer": binding["sponsored_fee_payer"],
+        "program_ids": program_ids,
+        "unknown_program_ids": unknown_program_ids,
+        "recognized_flash_program_ids": recognized_flash_program_ids,
+        "has_recognized_flash_program": True,
+        "non_core_program_ids": [pid for pid in program_ids if pid not in CORE_PROGRAM_IDS],
+        "account_key_count": len(keys),
+        "instruction_count": len(_compiled_instructions(message)),
+        "market_address": market_address,
+        "target_custody_address": target_custody_address,
+        "collateral_custody_address": collateral_custody_address,
+        "position_address": position_address,
+        "collateral_mint": collateral_mint,
+        "action": action,
+        "verified": True,
+    }

package/agent-wallet/agent_wallet/wallet_layer/base.py

@@ -425,6 +425,84 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Jupiter Earn earnings.")
 
+    async def get_flash_trade_markets(
+        self,
+        pool_name: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Flash Trade market lookup.")
+
+    async def get_flash_trade_positions(
+        self,
+        owner: str | None = None,
+        pool_name: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Flash Trade position lookup.")
+
+    async def preview_flash_trade_open_position(
+        self,
+        *,
+        pool_name: str,
+        market_symbol: str,
+        collateral_symbol: str,
+        collateral_amount_raw: str,
+        leverage: str,
+        side: str,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Flash Trade position-open previews.")
+
+    async def preview_flash_trade_close_position(
+        self,
+        *,
+        pool_name: str,
+        market_symbol: str,
+        side: str,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Flash Trade position-close previews.")
+
+    async def prepare_flash_trade_open_position(
+        self,
+        *,
+        pool_name: str,
+        market_symbol: str,
+        collateral_symbol: str,
+        collateral_amount_raw: str,
+        leverage: str,
+        side: str,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Flash Trade position-open prepare.")
+
+    async def prepare_flash_trade_close_position(
+        self,
+        *,
+        pool_name: str,
+        market_symbol: str,
+        side: str,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Flash Trade position-close prepare.")
+
+    async def execute_flash_trade_open_position(
+        self,
+        *,
+        pool_name: str,
+        market_symbol: str,
+        collateral_symbol: str,
+        collateral_amount_raw: str,
+        leverage: str,
+        side: str,
+        approved_preview: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Flash Trade position-open execute.")
+
+    async def execute_flash_trade_close_position(
+        self,
+        *,
+        pool_name: str,
+        market_symbol: str,
+        side: str,
+        approved_preview: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Flash Trade position-close execute.")
+
     async def get_kamino_lend_markets(self) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino market lookup.")