@agentlayer.tech/wallet 0.1.15 → 0.1.17

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

@@ -11,7 +11,7 @@ from decimal import Decimal, InvalidOperation
 from typing import Any
 
 from agent_wallet.models import AgentWalletCapabilities, SolanaWalletState
-from agent_wallet.providers import bags, houdini, jupiter, kamino, lifi, solana_rpc
+from agent_wallet.providers import bags, flash, flash_sdk_bridge, houdini, jupiter, kamino, lifi, solana_rpc
 from agent_wallet.solana_stake import (
     STAKE_STATE_V2_SIZE,
     deactivate_stake as build_deactivate_stake_instruction,
@@ -26,6 +26,7 @@ from agent_wallet.solana_tx import (
 )
 from agent_wallet.transaction_policy import (
     verify_provider_bags_transaction,
+    verify_provider_flash_transaction,
     verify_provider_kamino_lend_transaction,
     verify_provider_lend_transaction,
     verify_provider_swap_simulation_result,
@@ -155,6 +156,21 @@ def _require_positive_decimal_string(value: Any, *, field_name: str) -> str:
     return normalized or "0"
 
 
+def _normalize_flash_symbol(value: Any, *, field_name: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise WalletBackendError(f"{field_name} must be a non-empty string.")
+    return value.strip().upper()
+
+
+def _normalize_flash_side(value: Any) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise WalletBackendError("side must be a non-empty string.")
+    normalized = value.strip().lower()
+    if normalized not in {"long", "short"}:
+        raise WalletBackendError("side must be 'long' or 'short'.")
+    return normalized
+
+
 def _coerce_positive_int_from_any(value: Any) -> int | None:
     if value is None or value == "":
         return None
@@ -2338,6 +2354,10 @@ class SolanaWalletBackend(AgentWalletBackend):
         if self.network != "mainnet":
             raise WalletBackendError(f"{feature} is only enabled for Solana mainnet.")
 
+    def _require_mainnet_flash(self, feature: str) -> None:
+        if self.network != "mainnet":
+            raise WalletBackendError(f"{feature} is only enabled for Solana mainnet.")
+
     def _require_mainnet_kamino(self, feature: str) -> None:
         if self.network != "mainnet":
             raise WalletBackendError(f"{feature} is only enabled for Solana mainnet.")
@@ -2481,6 +2501,608 @@ class SolanaWalletBackend(AgentWalletBackend):
             "source": "jupiter-lend",
         }
 
+    async def get_flash_trade_markets(
+        self,
+        pool_name: str | None = None,
+    ) -> dict[str, Any]:
+        self._require_mainnet_flash("Flash Trade")
+        normalized_pool_name: str | None = None
+        if pool_name is not None:
+            if not isinstance(pool_name, str) or not pool_name.strip():
+                raise WalletBackendError("pool_name must be a non-empty string when provided.")
+            normalized_pool_name = pool_name.strip()
+        try:
+            data = await flash.fetch_markets(pool_name=normalized_pool_name)
+        except ProviderError:
+            data = await flash_sdk_bridge.get_markets(
+                pool_name=normalized_pool_name,
+                network=self.network,
+            )
+        markets = data.get("markets")
+        if not isinstance(markets, list):
+            markets = []
+        return {
+            "chain": "solana",
+            "network": self.network,
+            "pool_name": normalized_pool_name,
+            "market_count": len(markets),
+            "markets": markets,
+            "raw": data,
+            "source": str(data.get("source") or "flash-trade"),
+        }
+
+    async def get_flash_trade_positions(
+        self,
+        owner: str | None = None,
+        pool_name: str | None = None,
+    ) -> dict[str, Any]:
+        self._require_mainnet_flash("Flash Trade")
+        wallet_address = owner or self.address
+        if not wallet_address:
+            raise WalletBackendError(
+                "A wallet address is required for Flash Trade position lookup."
+            )
+        wallet_address = validate_solana_address(wallet_address)
+        normalized_pool_name: str | None = None
+        if pool_name is not None:
+            if not isinstance(pool_name, str) or not pool_name.strip():
+                raise WalletBackendError("pool_name must be a non-empty string when provided.")
+            normalized_pool_name = pool_name.strip()
+        try:
+            data = await flash.fetch_positions(
+                owner=wallet_address,
+                pool_name=normalized_pool_name,
+            )
+        except ProviderError:
+            data = await flash_sdk_bridge.get_positions(
+                owner=wallet_address,
+                pool_name=normalized_pool_name,
+                network=self.network,
+            )
+        positions = data.get("positions")
+        if not isinstance(positions, list):
+            positions = []
+        return {
+            "chain": "solana",
+            "network": self.network,
+            "owner": wallet_address,
+            "pool_name": normalized_pool_name,
+            "position_count": len(positions),
+            "positions": positions,
+            "raw": data,
+            "source": str(data.get("source") or "flash-trade"),
+        }
+
+    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]:
+        self._require_mainnet_flash("Flash Trade")
+        owner = await self.get_address()
+        if not owner:
+            raise WalletBackendError(
+                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
+            )
+        normalized_pool_name = str(pool_name).strip()
+        if not normalized_pool_name:
+            raise WalletBackendError("pool_name is required.")
+        normalized_market_symbol = _normalize_flash_symbol(
+            market_symbol,
+            field_name="market_symbol",
+        )
+        normalized_collateral_symbol = _normalize_flash_symbol(
+            collateral_symbol,
+            field_name="collateral_symbol",
+        )
+        normalized_collateral_amount_raw = _require_positive_integer_string(
+            collateral_amount_raw,
+            field_name="collateral_amount_raw",
+        )
+        normalized_leverage = _require_positive_decimal_string(leverage, field_name="leverage")
+        normalized_side = _normalize_flash_side(side)
+        market_snapshot = await self.get_flash_trade_markets(pool_name=normalized_pool_name)
+        matching_market = next(
+            (
+                item
+                for item in market_snapshot["markets"]
+                if isinstance(item, dict)
+                and str(item.get("market_symbol") or item.get("symbol") or "").strip().upper()
+                == normalized_market_symbol
+                and str(item.get("side") or "").strip().lower() == normalized_side
+                and str(item.get("collateral_symbol") or "").strip().upper()
+                == normalized_collateral_symbol
+            ),
+            None,
+        )
+        if matching_market is None:
+            raise WalletBackendError(
+                "Requested Flash market is not available in the selected pool for the requested collateral and side."
+            )
+        bridge_preview = await flash_sdk_bridge.preview_open_position(
+            owner=owner,
+            pool_name=normalized_pool_name,
+            market_symbol=normalized_market_symbol,
+            collateral_symbol=normalized_collateral_symbol,
+            collateral_amount_raw=normalized_collateral_amount_raw,
+            leverage=normalized_leverage,
+            side=normalized_side,
+            network=self.network,
+        )
+        return {
+            "chain": "solana",
+            "network": self.network,
+            "mode": "preview",
+            "asset_type": "flash-trade-open-position",
+            "owner": owner,
+            "pool_name": normalized_pool_name,
+            "market_symbol": normalized_market_symbol,
+            "collateral_symbol": normalized_collateral_symbol,
+            "collateral_amount_raw": normalized_collateral_amount_raw,
+            "leverage": normalized_leverage,
+            "side": normalized_side,
+            "market": matching_market,
+            "sign_only": self.sign_only,
+            "can_send": self.get_capabilities().can_send_transaction,
+            "source": "flash-sdk-bridge",
+            **bridge_preview,
+        }
+
+    async def preview_flash_trade_close_position(
+        self,
+        *,
+        pool_name: str,
+        market_symbol: str,
+        side: str,
+    ) -> dict[str, Any]:
+        self._require_mainnet_flash("Flash Trade")
+        owner = await self.get_address()
+        if not owner:
+            raise WalletBackendError(
+                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
+            )
+        normalized_pool_name = str(pool_name).strip()
+        if not normalized_pool_name:
+            raise WalletBackendError("pool_name is required.")
+        normalized_market_symbol = _normalize_flash_symbol(
+            market_symbol,
+            field_name="market_symbol",
+        )
+        normalized_side = _normalize_flash_side(side)
+        positions_snapshot = await self.get_flash_trade_positions(
+            owner=owner,
+            pool_name=normalized_pool_name,
+        )
+        matching_position = next(
+            (
+                item
+                for item in positions_snapshot["positions"]
+                if isinstance(item, dict)
+                and str(item.get("symbol") or item.get("marketSymbol") or "").strip().upper()
+                == normalized_market_symbol
+                and str(item.get("side") or "").strip().lower() == normalized_side
+            ),
+            None,
+        )
+        if matching_position is None:
+            raise WalletBackendError(
+                "No matching Flash position was found for the selected market, side, and pool."
+            )
+        bridge_preview = await flash_sdk_bridge.preview_close_position_same_collateral(
+            owner=owner,
+            pool_name=normalized_pool_name,
+            market_symbol=normalized_market_symbol,
+            side=normalized_side,
+            network=self.network,
+        )
+        return {
+            "chain": "solana",
+            "network": self.network,
+            "mode": "preview",
+            "asset_type": "flash-trade-close-position",
+            "owner": owner,
+            "pool_name": normalized_pool_name,
+            "market_symbol": normalized_market_symbol,
+            "side": normalized_side,
+            "position": matching_position,
+            "sign_only": self.sign_only,
+            "can_send": self.get_capabilities().can_send_transaction,
+            "source": "flash-sdk-bridge",
+            **bridge_preview,
+        }
+
+    async def _prepare_flash_trade_transaction(
+        self,
+        *,
+        preview: dict[str, Any],
+        bridge_prepared: dict[str, Any],
+        action: str,
+        asset_type: str,
+    ) -> dict[str, Any]:
+        bridge_mode = str(bridge_prepared.get("bridge_mode") or "").strip().lower()
+        if bridge_mode == "mock":
+            prepared = {
+                "chain": "solana",
+                "network": self.network,
+                "mode": "prepare",
+                "asset_type": asset_type,
+                "owner": preview.get("owner"),
+                "pool_name": preview.get("pool_name"),
+                "market_symbol": preview.get("market_symbol"),
+                "collateral_symbol": preview.get("collateral_symbol"),
+                "collateral_amount_raw": preview.get("collateral_amount_raw"),
+                "leverage": preview.get("leverage"),
+                "side": preview.get("side"),
+                "signed": False,
+                "broadcasted": False,
+                "confirmed": False,
+                "sign_only": self.sign_only,
+                "source": "flash-sdk-bridge",
+                "bridge_mode": "mock",
+                "mock_prepare_only": True,
+                "mock_warning": (
+                    f"{action} is running in FLASH_SDK_BRIDGE_MODE=mock. "
+                    "Prepare returns a dry-run execution plan only; execute is disabled until the bridge runs in real mode."
+                ),
+                "build_response": bridge_prepared,
+            }
+            for key in (
+                "estimated_size_usd",
+                "estimated_size_amount_raw",
+                "estimated_collateral_usd",
+                "estimated_collateral_amount_raw",
+                "estimated_entry_price",
+                "estimated_liquidation_price",
+                "estimated_entry_fee_usd",
+                "estimated_total_fee_usd",
+                "estimated_fee_rate_bps",
+                "estimated_available_liquidity_usd",
+                "estimated_borrow_fee_rate",
+                "position_size_usd",
+                "position_size_amount_raw",
+                "close_amount_raw",
+                "estimated_receive_amount_usd",
+                "estimated_mark_price",
+                "estimated_existing_liquidation_price",
+                "estimated_new_liquidation_price",
+                "estimated_profit_usd",
+                "estimated_loss_usd",
+                "estimated_settled_pnl_usd",
+                "estimated_exit_fee_usd",
+                "estimated_total_fees_usd",
+                "estimated_existing_leverage",
+                "estimated_new_leverage",
+                "is_profitable",
+                "is_solvent",
+                "is_partial_close",
+                "position_pubkey",
+            ):
+                if key in preview:
+                    prepared[key] = preview[key]
+            return prepared
+
+        if not self.signer:
+            raise WalletBackendError("Solana signer is not configured.")
+        try:
+            from solders.transaction import VersionedTransaction
+        except ImportError as exc:
+            raise WalletBackendError(
+                "solana and solders packages are required for Flash Trade transaction signing."
+            ) from exc
+
+        owner = str(preview.get("owner") or await self.get_address() or "").strip()
+        if not owner:
+            raise WalletBackendError(
+                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
+            )
+        transaction_base64 = str(bridge_prepared.get("transaction_base64") or "").strip()
+        if not transaction_base64:
+            raise WalletBackendError(f"{action} bridge response is missing transaction_base64.")
+
+        unsigned_transaction = VersionedTransaction.from_bytes(base64.b64decode(transaction_base64))
+        loaded_addresses = await self._resolve_versioned_message_lookup_addresses(
+            unsigned_transaction.message
+        )
+        market_address = validate_solana_address(str(bridge_prepared.get("market_address") or ""))
+        target_custody_address = validate_solana_address(
+            str(bridge_prepared.get("target_custody_address") or "")
+        )
+        collateral_custody_address = validate_solana_address(
+            str(bridge_prepared.get("collateral_custody_address") or "")
+        )
+        position_address_raw = str(bridge_prepared.get("position_address") or "").strip() or None
+        collateral_mint_raw = str(bridge_prepared.get("collateral_mint") or "").strip() or None
+        expected_program_ids_raw = bridge_prepared.get("expected_program_ids")
+        if not isinstance(expected_program_ids_raw, list) or not expected_program_ids_raw:
+            raise WalletBackendError(f"{action} bridge response is missing expected_program_ids.")
+        expected_program_ids = [
+            validate_solana_address(str(value))
+            for value in expected_program_ids_raw
+            if str(value).strip()
+        ]
+        verification = verify_provider_flash_transaction(
+            unsigned_transaction.message,
+            wallet_address=owner,
+            market_address=market_address,
+            target_custody_address=target_custody_address,
+            collateral_custody_address=collateral_custody_address,
+            action=action,
+            expected_program_ids=expected_program_ids,
+            position_address=(
+                validate_solana_address(position_address_raw)
+                if position_address_raw is not None
+                else None
+            ),
+            collateral_mint=(
+                validate_solana_mint(collateral_mint_raw)
+                if collateral_mint_raw is not None
+                else None
+            ),
+            loaded_addresses=loaded_addresses,
+        )
+        signed_transaction_base64 = await self._sign_versioned_provider_transaction(
+            transaction_base64=transaction_base64,
+            wallet_signer_index=int(verification.get("wallet_signer_index") or 0),
+        )
+        prepared = {
+            "chain": "solana",
+            "network": self.network,
+            "mode": "prepare",
+            "asset_type": asset_type,
+            "owner": owner,
+            "pool_name": preview.get("pool_name"),
+            "market_symbol": preview.get("market_symbol"),
+            "collateral_symbol": preview.get("collateral_symbol"),
+            "collateral_amount_raw": preview.get("collateral_amount_raw"),
+            "leverage": preview.get("leverage"),
+            "side": preview.get("side"),
+            "transaction_base64": signed_transaction_base64,
+            "transaction_encoding": str(bridge_prepared.get("transaction_encoding") or "base64"),
+            "transaction_format": str(bridge_prepared.get("transaction_format") or "versioned"),
+            "last_valid_block_height": bridge_prepared.get("last_valid_block_height"),
+            "latest_blockhash": bridge_prepared.get("latest_blockhash"),
+            "signed": True,
+            "broadcasted": False,
+            "confirmed": False,
+            "verification": verification,
+            "sign_only": self.sign_only,
+            "source": "flash-sdk-bridge",
+            "build_response": bridge_prepared,
+        }
+        for key in (
+            "estimated_size_usd",
+            "estimated_size_amount_raw",
+            "estimated_collateral_usd",
+            "estimated_collateral_amount_raw",
+            "estimated_entry_price",
+            "estimated_liquidation_price",
+            "estimated_entry_fee_usd",
+            "estimated_total_fee_usd",
+            "estimated_fee_rate_bps",
+            "estimated_available_liquidity_usd",
+            "estimated_borrow_fee_rate",
+            "position_size_usd",
+            "position_size_amount_raw",
+            "close_amount_raw",
+            "estimated_receive_amount_usd",
+            "estimated_mark_price",
+            "estimated_existing_liquidation_price",
+            "estimated_new_liquidation_price",
+            "estimated_profit_usd",
+            "estimated_loss_usd",
+            "estimated_settled_pnl_usd",
+            "estimated_exit_fee_usd",
+            "estimated_total_fees_usd",
+            "estimated_existing_leverage",
+            "estimated_new_leverage",
+            "is_profitable",
+            "is_solvent",
+            "is_partial_close",
+            "position_pubkey",
+        ):
+            if key in preview:
+                prepared[key] = preview[key]
+        return prepared
+
+    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]:
+        preview = await self.preview_flash_trade_open_position(
+            pool_name=pool_name,
+            market_symbol=market_symbol,
+            collateral_symbol=collateral_symbol,
+            collateral_amount_raw=collateral_amount_raw,
+            leverage=leverage,
+            side=side,
+        )
+        bridge_prepared = await flash_sdk_bridge.prepare_open_position(
+            owner=str(preview["owner"]),
+            pool_name=str(preview["pool_name"]),
+            market_symbol=str(preview["market_symbol"]),
+            collateral_symbol=str(preview["collateral_symbol"]),
+            collateral_amount_raw=str(preview["collateral_amount_raw"]),
+            leverage=str(preview["leverage"]),
+            side=str(preview["side"]),
+            network=self.network,
+        )
+        return await self._prepare_flash_trade_transaction(
+            preview=preview,
+            bridge_prepared=bridge_prepared,
+            action="Flash Trade open position",
+            asset_type="flash-trade-open-position",
+        )
+
+    async def _prepare_flash_trade_open_position_from_preview(
+        self,
+        preview: dict[str, Any],
+    ) -> dict[str, Any]:
+        bridge_prepared = await flash_sdk_bridge.prepare_open_position(
+            owner=str(preview["owner"]),
+            pool_name=str(preview["pool_name"]),
+            market_symbol=str(preview["market_symbol"]),
+            collateral_symbol=str(preview["collateral_symbol"]),
+            collateral_amount_raw=str(preview["collateral_amount_raw"]),
+            leverage=str(preview["leverage"]),
+            side=str(preview["side"]),
+            network=self.network,
+        )
+        return await self._prepare_flash_trade_transaction(
+            preview=preview,
+            bridge_prepared=bridge_prepared,
+            action="Flash Trade open position",
+            asset_type="flash-trade-open-position",
+        )
+
+    async def prepare_flash_trade_close_position(
+        self,
+        *,
+        pool_name: str,
+        market_symbol: str,
+        side: str,
+    ) -> dict[str, Any]:
+        preview = await self.preview_flash_trade_close_position(
+            pool_name=pool_name,
+            market_symbol=market_symbol,
+            side=side,
+        )
+        bridge_prepared = await flash_sdk_bridge.prepare_close_position_same_collateral(
+            owner=str(preview["owner"]),
+            pool_name=str(preview["pool_name"]),
+            market_symbol=str(preview["market_symbol"]),
+            side=str(preview["side"]),
+            network=self.network,
+        )
+        return await self._prepare_flash_trade_transaction(
+            preview=preview,
+            bridge_prepared=bridge_prepared,
+            action="Flash Trade close position",
+            asset_type="flash-trade-close-position",
+        )
+
+    async def _prepare_flash_trade_close_position_from_preview(
+        self,
+        preview: dict[str, Any],
+    ) -> dict[str, Any]:
+        bridge_prepared = await flash_sdk_bridge.prepare_close_position_same_collateral(
+            owner=str(preview["owner"]),
+            pool_name=str(preview["pool_name"]),
+            market_symbol=str(preview["market_symbol"]),
+            side=str(preview["side"]),
+            network=self.network,
+        )
+        return await self._prepare_flash_trade_transaction(
+            preview=preview,
+            bridge_prepared=bridge_prepared,
+            action="Flash Trade close position",
+            asset_type="flash-trade-close-position",
+        )
+
+    async def _execute_prepared_flash_trade_transaction(
+        self,
+        prepared: dict[str, Any],
+    ) -> dict[str, Any]:
+        if str(prepared.get("bridge_mode") or "").strip().lower() == "mock":
+            raise WalletBackendError(
+                "Flash Trade execute is unavailable while FLASH_SDK_BRIDGE_MODE=mock. Switch the Flash SDK bridge to real mode first."
+            )
+        result = await self._execute_prepared_provider_transaction(
+            prepared,
+            source="flash-sdk-bridge",
+        )
+        for key in (
+            "pool_name",
+            "market_symbol",
+            "collateral_symbol",
+            "collateral_amount_raw",
+            "leverage",
+            "side",
+            "estimated_size_usd",
+            "estimated_size_amount_raw",
+            "estimated_collateral_usd",
+            "estimated_collateral_amount_raw",
+            "estimated_entry_price",
+            "estimated_liquidation_price",
+            "estimated_entry_fee_usd",
+            "estimated_total_fee_usd",
+            "position_size_usd",
+            "position_size_amount_raw",
+            "close_amount_raw",
+            "estimated_receive_amount_usd",
+            "estimated_mark_price",
+            "estimated_existing_liquidation_price",
+            "estimated_new_liquidation_price",
+            "estimated_profit_usd",
+            "estimated_loss_usd",
+            "estimated_settled_pnl_usd",
+            "estimated_exit_fee_usd",
+            "estimated_total_fees_usd",
+            "position_pubkey",
+            "verification",
+        ):
+            if key in prepared:
+                result[key] = prepared[key]
+        if "build_response" in prepared:
+            result["build_response"] = prepared["build_response"]
+        return result
+
+    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]:
+        preview = (
+            dict(approved_preview)
+            if isinstance(approved_preview, dict)
+            else await self.preview_flash_trade_open_position(
+                pool_name=pool_name,
+                market_symbol=market_symbol,
+                collateral_symbol=collateral_symbol,
+                collateral_amount_raw=collateral_amount_raw,
+                leverage=leverage,
+                side=side,
+            )
+        )
+        prepared = await self._prepare_flash_trade_open_position_from_preview(preview)
+        return await self._execute_prepared_flash_trade_transaction(prepared)
+
+    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]:
+        preview = (
+            dict(approved_preview)
+            if isinstance(approved_preview, dict)
+            else await self.preview_flash_trade_close_position(
+                pool_name=pool_name,
+                market_symbol=market_symbol,
+                side=side,
+            )
+        )
+        prepared = await self._prepare_flash_trade_close_position_from_preview(preview)
+        return await self._execute_prepared_flash_trade_transaction(prepared)
+
     async def get_kamino_lend_markets(self) -> dict[str, Any]:
         self._require_mainnet_kamino("Kamino lending")
         data = await kamino.fetch_lend_markets()

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.15"
+version = "0.1.17"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [