@agentlayer.tech/wallet 0.1.66 → 0.1.68

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

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import json
+import time
 from typing import Any
 
 from agent_wallet.config import normalize_solana_network, settings
@@ -9,6 +11,41 @@ from agent_wallet.exceptions import ProviderError
 from agent_wallet.http_client import get_client
 
 KAMINO_BUILD_TIMEOUT_SECONDS = 20.0
+# Discovery data only (market/vault catalogs and rate metrics) — never
+# user-specific data such as obligations, positions, rewards, or portfolios.
+# Catalogs change when Kamino ships a market/vault (days); rate metrics drift
+# slower than the API's own aggregation window over these TTLs. The cache is
+# long-lived only inside the resident read worker; cold CLI runs start empty.
+MARKETS_CACHE_TTL_SECONDS = 600.0
+RESERVES_CACHE_TTL_SECONDS = 180.0
+EARN_VAULTS_CACHE_TTL_SECONDS = 600.0
+EARN_VAULT_METRICS_CACHE_TTL_SECONDS = 180.0
+_DISCOVERY_CACHE_MAX_ENTRIES = 128
+_discovery_cache: dict[str, tuple[float, str]] = {}
+
+
+def _discovery_cache_get(cache_key: str) -> Any | None:
+    entry = _discovery_cache.get(cache_key)
+    if entry is None:
+        return None
+    expires_at, payload_text = entry
+    if expires_at <= time.monotonic():
+        _discovery_cache.pop(cache_key, None)
+        return None
+    return json.loads(payload_text)
+
+
+def _discovery_cache_set(cache_key: str, payload: Any, ttl_seconds: float) -> None:
+    try:
+        payload_text = json.dumps(payload)
+    except (TypeError, ValueError):
+        return
+    if len(_discovery_cache) >= _DISCOVERY_CACHE_MAX_ENTRIES:
+        for stale_key in sorted(_discovery_cache, key=lambda key: _discovery_cache[key][0])[
+            : len(_discovery_cache) - _DISCOVERY_CACHE_MAX_ENTRIES + 1
+        ]:
+            _discovery_cache.pop(stale_key, None)
+    _discovery_cache[cache_key] = (time.monotonic() + ttl_seconds, payload_text)
 
 
 def _normalized_api_base() -> str:
@@ -48,6 +85,10 @@ def _env_name(network: str) -> str:
 
 async def fetch_lend_markets() -> dict[str, Any]:
     """Fetch Kamino lending markets for the configured program id."""
+    cache_key = f"markets:{settings.kamino_program_id}"
+    cached = _discovery_cache_get(cache_key)
+    if cached is not None:
+        return cached
     client = get_client()
     response = await client.get(
         f"{_normalized_api_base()}/v2/kamino-market",
@@ -55,11 +96,85 @@ async def fetch_lend_markets() -> dict[str, Any]:
     )
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
-    return _normalize_named_list_response(
+    result = _normalize_named_list_response(
         response.json(),
         key="markets",
         provider_name="kamino",
     )
+    _discovery_cache_set(cache_key, result, MARKETS_CACHE_TTL_SECONDS)
+    return result
+
+
+async def fetch_portfolio(*, user: str) -> dict[str, Any]:
+    """Fetch the unified Kamino product portfolio for one wallet."""
+    client = get_client()
+    response = await client.get(f"{_normalized_api_base()}/portfolio/{user}")
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    data = response.json()
+    if not isinstance(data, dict):
+        raise ProviderError("kamino", "Unexpected portfolio response from Kamino.")
+    return data
+
+
+async def fetch_earn_vaults() -> dict[str, Any]:
+    """Fetch the list of Kamino Earn vaults."""
+    cache_key = "earn_vaults"
+    cached = _discovery_cache_get(cache_key)
+    if cached is not None:
+        return cached
+    client = get_client()
+    response = await client.get(f"{_normalized_api_base()}/kvaults/vaults")
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    result = _normalize_named_list_response(
+        response.json(),
+        key="vaults",
+        provider_name="kamino",
+    )
+    _discovery_cache_set(cache_key, result, EARN_VAULTS_CACHE_TTL_SECONDS)
+    return result
+
+
+async def fetch_earn_vault_metrics(*, vault: str, network: str) -> dict[str, Any]:
+    """Fetch APY/TVL metrics for one Kamino Earn vault."""
+    env = _env_name(network)
+    cache_key = f"earn_vault_metrics:{vault}:{env}"
+    cached = _discovery_cache_get(cache_key)
+    if cached is not None:
+        return cached
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/kvaults/{vault}/metrics",
+        params={"env": env},
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    data = response.json()
+    if not isinstance(data, dict):
+        raise ProviderError("kamino", "Unexpected vault metrics response from Kamino.")
+    _discovery_cache_set(cache_key, data, EARN_VAULT_METRICS_CACHE_TTL_SECONDS)
+    return data
+
+
+async def fetch_earn_user_positions(
+    *,
+    user: str,
+    network: str,
+) -> dict[str, Any]:
+    """Fetch all Kamino Earn vault positions for a wallet."""
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/kvaults/users/{user}/positions",
+        params={"env": _env_name(network)},
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    return _normalize_named_list_response(
+        response.json(),
+        key="positions",
+        provider_name="kamino",
+    )
 
 
 async def fetch_lend_market_reserves(
@@ -68,18 +183,25 @@ async def fetch_lend_market_reserves(
     network: str,
 ) -> dict[str, Any]:
     """Fetch reserve metrics for one Kamino lending market."""
+    env = _env_name(network)
+    cache_key = f"reserves:{market}:{env}"
+    cached = _discovery_cache_get(cache_key)
+    if cached is not None:
+        return cached
     client = get_client()
     response = await client.get(
         f"{_normalized_api_base()}/kamino-market/{market}/reserves/metrics",
-        params={"env": _env_name(network)},
+        params={"env": env},
     )
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
-    return _normalize_named_list_response(
+    result = _normalize_named_list_response(
         response.json(),
         key="reserves",
         provider_name="kamino",
     )
+    _discovery_cache_set(cache_key, result, RESERVES_CACHE_TTL_SECONDS)
+    return result
 
 
 async def fetch_lend_user_obligations(
@@ -236,3 +358,47 @@ async def build_lend_repay_transaction(
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
     return _normalized_tx_response(response.json(), provider_name="kamino")
+
+
+async def build_earn_deposit_transaction(
+    *,
+    wallet: str,
+    kvault: str,
+    amount_ui: str,
+) -> dict[str, Any]:
+    """Build an unsigned Kamino Earn deposit transaction."""
+    client = get_client()
+    response = await client.post(
+        f"{_normalized_api_base()}/ktx/kvault/deposit",
+        json={
+            "wallet": wallet,
+            "kvault": kvault,
+            "amount": amount_ui,
+        },
+        timeout=KAMINO_BUILD_TIMEOUT_SECONDS,
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    return _normalized_tx_response(response.json(), provider_name="kamino")
+
+
+async def build_earn_withdraw_transaction(
+    *,
+    wallet: str,
+    kvault: str,
+    amount_ui: str,
+) -> dict[str, Any]:
+    """Build an unsigned Kamino Earn withdraw transaction."""
+    client = get_client()
+    response = await client.post(
+        f"{_normalized_api_base()}/ktx/kvault/withdraw",
+        json={
+            "wallet": wallet,
+            "kvault": kvault,
+            "amount": amount_ui,
+        },
+        timeout=KAMINO_BUILD_TIMEOUT_SECONDS,
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    return _normalized_tx_response(response.json(), provider_name="kamino")

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

@@ -7,6 +7,7 @@ import hashlib
 import json
 import logging
 import time
+from types import SimpleNamespace
 from typing import Any
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
@@ -428,11 +429,16 @@ def _evm_exact_execution_supported(backend: AgentWalletBackend) -> bool:
 
 
 def _evm_payment_requirement_supported(requirement: dict[str, Any]) -> bool:
-    if _trim(requirement.get("scheme")).lower() != "exact":
-        return False
+    scheme = _trim(requirement.get("scheme")).lower()
     extra = _extract_requirement_extra(requirement)
-    transfer_method = _trim(extra.get("assetTransferMethod")).lower()
-    return transfer_method in {"", "eip3009", "transferwithauthorization"}
+    if scheme == "exact":
+        transfer_method = _trim(extra.get("assetTransferMethod")).lower()
+        return transfer_method in {"", "eip3009", "transferwithauthorization"}
+    if scheme == "upto":
+        # The upto Permit2 payload needs the facilitator's address up front;
+        # without it the SDK signer raises instead of falling back cleanly.
+        return bool(_trim(extra.get("facilitatorAddress")))
+    return False
 
 
 def _wallet_x402_support_summary(backend: AgentWalletBackend) -> dict[str, Any]:
@@ -478,7 +484,7 @@ def _requirement_compatibility(requirement: dict[str, Any], backend: AgentWallet
         )
     elif chain == "evm":
         planned_execution_supported = (
-            scheme == "exact"
+            scheme in {"exact", "upto"}
             and network in set(wallet_summary["planned_execution_networks"])
             and _evm_payment_requirement_supported(requirement)
         )
@@ -491,10 +497,12 @@ def _requirement_compatibility(requirement: dict[str, Any], backend: AgentWallet
         reason = (
             "Executable now through the local Solana exact buyer flow."
             if chain == "solana"
-            else "Executable now through the local EVM exact buyer flow."
+            else f"Executable now through the local EVM {scheme or 'exact'} buyer flow."
         )
     elif chain == "evm" and scheme == "exact" and not _evm_payment_requirement_supported(requirement):
         reason = "This EVM exact payment requires a transfer method that is not enabled in the current wallet runtime."
+    elif chain == "evm" and scheme == "upto" and not _evm_payment_requirement_supported(requirement):
+        reason = "This EVM upto payment is missing a facilitatorAddress in its extra data, so it cannot be signed."
     elif planned_execution_supported and wallet_network_matches:
         reason = "Wallet network matches, but this backend does not yet expose a supported x402 signer path."
     elif planned_execution_supported:
@@ -527,11 +535,16 @@ def _select_preferred_requirement(
     if not candidates:
         return None
 
-    def sort_key(item: dict[str, Any]) -> tuple[int, int]:
+    def sort_key(item: dict[str, Any]) -> tuple[int, int, int]:
+        # Prefer upto over exact: upto settles for actual usage against a
+        # signed cap, which fits metered/usage-priced endpoints better than
+        # exact's fixed charge. Ties within a scheme still favor the cheapest
+        # declared amount.
+        scheme_rank = 0 if _trim(item.get("scheme")).lower() == "upto" else 1
         amount = _trim(item.get("amount"))
         if amount.isdigit():
-            return (0, int(amount))
-        return (1, 0)
+            return (scheme_rank, 0, int(amount))
+        return (scheme_rank, 1, 0)
 
     return sorted(candidates, key=sort_key)[0]
 
@@ -728,10 +741,10 @@ def _validate_payment_requirement(
         )
 
     scheme = _trim(selected.get("scheme")).lower()
-    if scheme != "exact":
+    if scheme not in {"exact", "upto"}:
         raise ProviderError(
             "x402-validate",
-            f"Unsupported x402 payment scheme '{scheme or 'unknown'}'. Only 'exact' is supported.",
+            f"Unsupported x402 payment scheme '{scheme or 'unknown'}'. Only 'exact' and 'upto' are supported.",
             details={"request_url": request_url, "selected_payment": selected},
         )
 
@@ -846,6 +859,24 @@ def _select_sdk_payment_requirement(
     )
 
 
+# The `upto` Permit2 signature authorizes the (merchant + facilitator) pair to
+# settle any amount in [0, cap] until `max_timeout_seconds` elapses, with no
+# on-chain check beyond the deadline itself. A merchant-declared timeout with
+# no upper bound would extend that facilitator-discretion window indefinitely,
+# so cap it defensively before signing. `exact` amounts are fixed in the
+# signature, so this cap only applies to `upto`.
+MAX_UPTO_DEADLINE_SECONDS = 7 * 24 * 60 * 60  # 7 days
+
+
+def _cap_upto_deadline(requirement: Any) -> Any:
+    if _trim(getattr(requirement, "scheme", "")).lower() != "upto":
+        return requirement
+    timeout = getattr(requirement, "max_timeout_seconds", None)
+    if not isinstance(timeout, int) or timeout <= MAX_UPTO_DEADLINE_SECONDS:
+        return requirement
+    return requirement.model_copy(update={"max_timeout_seconds": MAX_UPTO_DEADLINE_SECONDS})
+
+
 def _build_selected_payment_required_payload(
     payment_required: Any,
     *,
@@ -855,6 +886,7 @@ def _build_selected_payment_required_payload(
         payment_required,
         selected_payment=selected_payment,
     )
+    selected_requirement = _cap_upto_deadline(selected_requirement)
     return payment_required.model_copy(update={"accepts": [selected_requirement]})
 
 
@@ -904,9 +936,18 @@ def _load_x402_evm_sdk() -> dict[str, Any]:
             "x402 EVM execution requires EVM support.",
             details={"hint": 'Install dependencies so `x402[httpx,evm]` is available in the wallet runtime.'},
         ) from exc
+    try:
+        from x402.mechanisms.evm.upto import UptoEvmScheme
+    except ImportError as exc:
+        raise ProviderError(
+            "x402-sdk",
+            "x402 EVM upto-scheme execution requires the upto mechanism module.",
+            details={"hint": 'Install dependencies so `x402[httpx,evm]` is available in the wallet runtime.'},
+        ) from exc
     sdk.update(
         {
             "register_exact_evm_client": register_exact_evm_client,
+            "UptoEvmScheme": UptoEvmScheme,
         }
     )
     return sdk
@@ -916,6 +957,67 @@ def _load_x402_sdk() -> dict[str, Any]:
     return _load_x402_common_sdk()
 
 
+def _load_x402_siwx_sdk() -> dict[str, Any]:
+    try:
+        from x402.extensions.sign_in_with_x import (
+            SIGN_IN_WITH_X,
+            CreateSIWxClientExtensionOptions,
+            create_siwx_client_extension,
+        )
+    except ImportError as exc:
+        raise ProviderError(
+            "x402-sdk",
+            "x402 sign-in-with-x execution requires the SIWx extension module.",
+            details={"hint": 'Install dependencies so `x402[httpx,evm,svm]` is available in the wallet runtime.'},
+        ) from exc
+    return {
+        "SIGN_IN_WITH_X": SIGN_IN_WITH_X,
+        "CreateSIWxClientExtensionOptions": CreateSIWxClientExtensionOptions,
+        "create_siwx_client_extension": create_siwx_client_extension,
+    }
+
+
+async def _maybe_attach_siwx_header(
+    *,
+    payment_required: Any,
+    signer: Any,
+    headers: dict[str, str],
+) -> dict[str, str]:
+    """Attach a Sign-In-With-X header when the merchant declares that extension.
+
+    Some x402 gateways require proving wallet ownership via SIWx alongside the
+    payment signature; without it those requests are rejected even with a
+    valid payment. Best-effort: any failure to build the SIWx credential falls
+    back to paying without it, matching the upstream SDK's own
+    on_payment_required hook contract (which swallows exceptions the same way).
+    """
+    extensions = getattr(payment_required, "extensions", None) or {}
+    if not extensions:
+        return headers
+    try:
+        sdk = _load_x402_siwx_sdk()
+    except ProviderError:
+        return headers
+    if sdk["SIGN_IN_WITH_X"] not in extensions:
+        return headers
+    extension = sdk["create_siwx_client_extension"](
+        sdk["CreateSIWxClientExtensionOptions"](signers=[signer])
+    )
+    context = SimpleNamespace(payment_required=payment_required)
+    try:
+        result = await extension.transport_hooks.http.on_payment_required(None, context)
+    except Exception as exc:
+        log.warning(
+            "x402 SIWx header build failed; continuing without it",
+            extra={"error_type": type(exc).__name__, "error": str(exc) or None},
+        )
+        return headers
+    siwx_headers = getattr(result, "headers", None) if result is not None else None
+    if not siwx_headers:
+        return headers
+    return {**headers, **siwx_headers}
+
+
 def _build_solana_sdk_signer(backend: AgentWalletBackend) -> Any:
     signer = getattr(backend, "signer", None)
     if signer is None or not hasattr(signer, "export_keypair_bytes"):
@@ -959,15 +1061,30 @@ def _build_evm_sdk_signer(backend: AgentWalletBackend, address: str) -> Any:
             "The active EVM backend does not expose an x402 exact typed-data signer.",
         )
 
+    class _NoEthAccountSentinel:
+        """Truthy placeholder with neither `.sign_message` nor `.address`.
+
+        x402's SIWx sign_evm_message() treats a signer with `.account` unset
+        but both `.sign_message` and `.address` present as an eth_account-style
+        wallet, and calls `.sign_message(SignableMessage)` positionally instead
+        of our keyword-based `sign_message(message=..., account=...)`. Exposing
+        a benign `.account` here short-circuits that fallback so the SDK
+        reaches our intended call path.
+        """
+
     class _OpenClawEvmX402Signer:
         def __init__(self, wallet_backend: AgentWalletBackend, wallet_address: str):
             self._wallet_backend = wallet_backend
             self._address = wallet_address
+            self.account = _NoEthAccountSentinel()
 
         @property
         def address(self) -> str:
             return self._address
 
+        async def sign_message(self, *, message: str, account: Any = None) -> str:
+            return await self._wallet_backend.sign_message(message)
+
         def sign_typed_data(
             self,
             domain: Any,
@@ -1022,9 +1139,10 @@ async def _create_payment_headers(
                 "No direct Solana RPC URL is available for the x402 SDK signer path.",
                 details={"network": _backend_network(backend)},
             )
+        solana_signer = _build_solana_sdk_signer(backend)
         sdk["register_exact_svm_client"](
             client,
-            _build_solana_sdk_signer(backend),
+            solana_signer,
             networks=str(selected_payment["network"]),
             rpc_url=sdk_rpc_url,
         )
@@ -1041,7 +1159,10 @@ async def _create_payment_headers(
                     "error": str(exc) or None,
                 },
             ) from exc
-        return sdk["x402HTTPClientBase"]().encode_payment_signature_header(payment_payload)
+        headers = sdk["x402HTTPClientBase"]().encode_payment_signature_header(payment_payload)
+        return await _maybe_attach_siwx_header(
+            payment_required=payment_required, signer=solana_signer, headers=headers
+        )
 
     if chain == "evm":
         sdk = _load_x402_evm_sdk()
@@ -1054,13 +1175,18 @@ async def _create_payment_headers(
         address = await backend.get_address()
         if not isinstance(address, str) or not address.strip():
             raise ProviderError("x402-evm", "The active EVM backend did not resolve a payer address.")
-        sdk["register_exact_evm_client"](
-            client,
-            _build_evm_sdk_signer(backend, address.strip()),
-            networks=str(selected_payment["network"]),
-        )
+        evm_signer = _build_evm_sdk_signer(backend, address.strip())
+        network = str(selected_payment["network"])
+        sdk["register_exact_evm_client"](client, evm_signer, networks=network)
+        # `upto` reuses the same typed-data signer as `exact`; registering both
+        # lets the SDK settle whichever scheme the merchant's accepted
+        # requirement (already narrowed to one entry above) turns out to use.
+        client.register(network, sdk["UptoEvmScheme"](evm_signer))
         payment_payload = await client.create_payment_payload(selected_payload)
-        return sdk["x402HTTPClientBase"]().encode_payment_signature_header(payment_payload)
+        headers = sdk["x402HTTPClientBase"]().encode_payment_signature_header(payment_payload)
+        return await _maybe_attach_siwx_header(
+            payment_required=payment_required, signer=evm_signer, headers=headers
+        )
 
     raise ProviderError(
         "x402-http",

package/agent-wallet/agent_wallet/transaction_policy.py

@@ -18,6 +18,7 @@ JUPITER_V6_PROGRAM_ID = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5Nt7NQYjN"
 JUPITER_ULTRA_EXACT_OUT_PROGRAM_ID = "j1o2qRpjcyUwEvwtcfhEQefh773ZgjxcVRry7LDqg5X"
 JUPITER_DCA_PROGRAM_ID = "DCA265Vj8a7wYymQG8LqM3m7A4QeV9hiC7VYh4S6Jsa"
 KAMINO_LEND_PROGRAM_ID = "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
+KAMINO_EARN_PROGRAM_ID = "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd"
 NATIVE_SOL_MINT = "So11111111111111111111111111111111111111112"
 DEFAULT_NATIVE_SOL_EXTRA_SPEND_ALLOWANCE_LAMPORTS = 10_000_000
 
@@ -45,6 +46,7 @@ FORBIDDEN_PROGRAMS = {
 }
 KAMINO_ALLOWED_PROGRAMS = CORE_PROGRAM_IDS | {
     KAMINO_LEND_PROGRAM_ID,
+    KAMINO_EARN_PROGRAM_ID,
 }
 
 
@@ -513,6 +515,64 @@ def verify_provider_kamino_lend_transaction(
     }
 
 
+def verify_provider_kamino_earn_transaction(
+    message: Any,
+    *,
+    wallet_address: str,
+    vault_address: str,
+    action: str,
+    vault_token_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 vault_address not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Kamino Earn vault."
+        )
+    if vault_token_mint and vault_token_mint not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Kamino Earn vault token mint."
+        )
+    program_ids = _program_ids(message, loaded_addresses)
+    unknown_program_ids = _assert_program_allowlist(
+        program_ids,
+        allowed_programs=KAMINO_ALLOWED_PROGRAMS,
+        label=action,
+        reject_unknown=False,
+    )
+    recognized_kamino_program_ids = [
+        pid for pid in program_ids if pid == KAMINO_EARN_PROGRAM_ID
+    ]
+    if not recognized_kamino_program_ids:
+        raise WalletBackendError(
+            f"{action} transaction does not include the expected Kamino Earn 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_kamino_program_ids": recognized_kamino_program_ids,
+        "has_recognized_kamino_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)),
+        "vault_address": vault_address,
+        "vault_token_mint": vault_token_mint,
+        "action": action,
+        "verified": True,
+    }
+
+
 def verify_provider_flash_transaction(
     message: Any,
     *,