@agentlayer.tech/wallet 0.1.30 → 0.1.32

package/agent-wallet/agent_wallet/transaction_policy.py

@@ -406,230 +406,6 @@ def verify_provider_swap_simulation_result(
     }
 
 
-def verify_provider_houdini_transaction(
-    message: Any,
-    *,
-    wallet_address: str,
-    deposit_address: str,
-    amount_raw: int,
-    is_native_input: bool,
-    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"]
-    program_ids = _program_ids(message, loaded_addresses)
-    unknown_program_ids = _assert_program_allowlist(
-        program_ids,
-        allowed_programs=CORE_PROGRAM_IDS,
-        label="Houdini private swap funding",
-        reject_unknown=False,
-    )
-
-    matched_native_lamports = 0
-    matched_token_amount = 0
-    parsed_transfers: list[dict[str, Any]] = []
-
-    for instruction in _compiled_instructions(message):
-        instruction_accounts = _instruction_account_keys(
-            message,
-            instruction,
-            loaded_addresses=loaded_addresses,
-        )
-        data = _instruction_data_bytes(instruction)
-        program_id_index = int(getattr(instruction, "program_id_index", -1))
-        if program_id_index < 0 or program_id_index >= len(keys):
-            raise WalletBackendError("Provider transaction contains an invalid program id index.")
-        program_id = _account_keys(message, loaded_addresses)[program_id_index]
-
-        if (
-            is_native_input
-            and program_id == SYSTEM_PROGRAM_ID
-            and len(data) >= 12
-            and len(instruction_accounts) >= 2
-        ):
-            instruction_type = struct.unpack_from("<I", data, 0)[0]
-            if instruction_type == 2:
-                lamports = struct.unpack_from("<Q", data, 4)[0]
-                recipient = instruction_accounts[1]
-                parsed_transfers.append(
-                    {
-                        "program_id": program_id,
-                        "recipient": recipient,
-                        "amount_raw": str(lamports),
-                        "kind": "system-transfer",
-                    }
-                )
-                if recipient == deposit_address:
-                    matched_native_lamports += lamports
-            continue
-
-        if program_id not in {TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID} or len(instruction_accounts) < 2:
-            continue
-
-        if not data:
-            continue
-        instruction_tag = data[0]
-        if instruction_tag == 3 and len(data) >= 9 and len(instruction_accounts) >= 2:
-            token_amount = struct.unpack_from("<Q", data, 1)[0]
-            recipient = instruction_accounts[1]
-            parsed_transfers.append(
-                {
-                    "program_id": program_id,
-                    "recipient": recipient,
-                    "amount_raw": str(token_amount),
-                    "kind": "spl-transfer",
-                    "mint": None,
-                }
-            )
-            if not is_native_input and recipient == deposit_address:
-                matched_token_amount += token_amount
-            continue
-
-        if instruction_tag == 12 and len(data) >= 10 and len(instruction_accounts) >= 3:
-            token_amount = struct.unpack_from("<Q", data, 1)[0]
-            mint = instruction_accounts[1]
-            recipient = instruction_accounts[2]
-            parsed_transfers.append(
-                {
-                    "program_id": program_id,
-                    "recipient": recipient,
-                    "amount_raw": str(token_amount),
-                    "kind": "spl-transfer-checked",
-                    "mint": mint,
-                }
-            )
-            if (
-                not is_native_input
-                and recipient == deposit_address
-                and (token_mint is None or mint == token_mint)
-            ):
-                matched_token_amount += token_amount
-
-    if is_native_input:
-        if matched_native_lamports != amount_raw:
-            raise WalletBackendError(
-                "Houdini funding transaction does not transfer the approved native SOL amount to the expected deposit address."
-            )
-    else:
-        if matched_token_amount != amount_raw:
-            raise WalletBackendError(
-                "Houdini funding transaction does not transfer the approved SPL token amount to the expected deposit address."
-            )
-
-    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,
-        "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)),
-        "deposit_address": deposit_address,
-        "amount_raw": str(amount_raw),
-        "is_native_input": is_native_input,
-        "token_mint": token_mint,
-        "parsed_transfers": parsed_transfers,
-        "verified": True,
-    }
-
-
-def verify_provider_houdini_simulation_result(
-    simulation_value: dict[str, Any],
-    *,
-    wallet_address: str,
-    wallet_account_index: int | None,
-    is_native_input: bool,
-    token_mint: str | None,
-    amount_raw: int,
-    native_sol_extra_spend_allowance_lamports: int = (
-        DEFAULT_NATIVE_SOL_EXTRA_SPEND_ALLOWANCE_LAMPORTS
-    ),
-) -> dict[str, Any]:
-    if not isinstance(simulation_value, dict):
-        raise WalletBackendError(
-            "Houdini funding transaction simulation returned an unexpected payload.",
-            code="transaction_simulation_invalid",
-        )
-
-    if simulation_value.get("err") is not None:
-        raise WalletBackendError(
-            "Houdini funding transaction simulation failed.",
-            code="transaction_simulation_failed",
-            details={"simulation": simulation_value},
-        )
-
-    token_deltas = _wallet_token_deltas_by_mint(
-        simulation_value,
-        wallet_address=wallet_address,
-    )
-    native_delta = _native_lamport_delta(
-        simulation_value,
-        wallet_account_index=wallet_account_index,
-    )
-    warnings: list[str] = []
-    enforced_checks: list[str] = ["simulation_err_is_none"]
-
-    if is_native_input:
-        if native_delta is None:
-            warnings.append("native_input_delta_unavailable")
-        else:
-            max_spend = max(amount_raw, 0) + max(native_sol_extra_spend_allowance_lamports, 0)
-            if -native_delta > max_spend:
-                raise WalletBackendError(
-                    "Houdini funding transaction simulation spends more native SOL than approved.",
-                    code="houdini_simulation_overspend",
-                    details={
-                        "approved_input_amount_raw": str(amount_raw),
-                        "native_delta_lamports": str(native_delta),
-                        "allowed_extra_lamports": str(
-                            native_sol_extra_spend_allowance_lamports
-                        ),
-                    },
-                )
-            enforced_checks.append("native_input_spend_within_approved_amount")
-    else:
-        if not token_mint:
-            raise WalletBackendError("token_mint is required for SPL Houdini simulation checks.")
-        input_delta = token_deltas.get(token_mint)
-        if input_delta is None:
-            warnings.append("token_input_delta_unavailable")
-        elif -input_delta > amount_raw:
-            raise WalletBackendError(
-                "Houdini funding transaction simulation spends more SPL token than approved.",
-                code="houdini_simulation_overspend",
-                details={
-                    "token_mint": token_mint,
-                    "approved_input_amount_raw": str(amount_raw),
-                    "input_delta_raw": str(input_delta),
-                },
-            )
-        else:
-            enforced_checks.append("token_input_spend_within_approved_amount")
-
-    return {
-        "verified": True,
-        "simulation_err": None,
-        "wallet_address": wallet_address,
-        "wallet_account_index": wallet_account_index,
-        "token_mint": token_mint,
-        "amount_raw": str(amount_raw),
-        "is_native_input": is_native_input,
-        "token_deltas": {mint: str(delta) for mint, delta in sorted(token_deltas.items())},
-        "native_delta_lamports": str(native_delta) if native_delta is not None else None,
-        "enforced_checks": enforced_checks,
-        "warnings": warnings,
-    }
-
-
 def verify_provider_bags_transaction(
     message: Any,
     *,
@@ -673,44 +449,6 @@ def verify_provider_bags_transaction(
     }
 
 
-def verify_provider_lend_transaction(
-    message: Any,
-    *,
-    wallet_address: str,
-    asset_mint: str,
-    action: str,
-) -> dict[str, Any]:
-    binding = _assert_basic_wallet_binding(message, wallet_address=wallet_address)
-    keys = binding["account_keys"]
-    if asset_mint not in keys:
-        raise WalletBackendError(
-            f"{action} transaction does not reference the expected asset mint."
-        )
-    program_ids = _program_ids(message)
-    unknown_program_ids = _assert_program_allowlist(
-        program_ids,
-        allowed_programs=CORE_PROGRAM_IDS,
-        label=action,
-        reject_unknown=False,
-    )
-    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,
-        "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)),
-        "asset_mint": asset_mint,
-        "action": action,
-        "verified": True,
-    }
-
-
 def verify_provider_kamino_lend_transaction(
     message: Any,
     *,

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

@@ -328,46 +328,6 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Solana-origin LI.FI swap previews.")
 
-    async def preview_solana_private_swap(
-        self,
-        *,
-        input_token: str,
-        output_token: str,
-        destination_address: str,
-        amount_ui: float,
-        use_xmr: bool = False,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Solana private swap previews.")
-
-    async def execute_solana_private_swap(
-        self,
-        *,
-        input_token: str,
-        output_token: str,
-        destination_address: str,
-        amount_ui: float,
-        use_xmr: bool = False,
-        approved_preview: dict[str, Any] | None = None,
-        existing_order: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Solana private swaps.")
-
-    async def get_solana_private_swap_status(
-        self,
-        *,
-        multi_id: str | None = None,
-        houdini_id: str | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Solana private swap status lookup.")
-
-    async def continue_solana_private_swap(
-        self,
-        *,
-        approved_preview: dict[str, Any],
-        existing_order: dict[str, Any],
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support continuing Solana private swaps.")
-
     async def execute_solana_lifi_cross_chain_swap(
         self,
         *,
@@ -410,22 +370,6 @@ class AgentWalletBackend(ABC):
     async def get_jupiter_staked_jup(self, address: str | None = None) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Jupiter staked JUP lookup.")
 
-    async def get_jupiter_earn_tokens(self) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn token lookup.")
-
-    async def get_jupiter_earn_positions(
-        self,
-        users: list[str] | None = None,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn positions.")
-
-    async def get_jupiter_earn_earnings(
-        self,
-        user: str | None = None,
-        positions: list[str] | None = None,
-    ) -> 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,
@@ -639,50 +583,6 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino repays.")
 
-    async def preview_jupiter_earn_deposit(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn deposit previews.")
-
-    async def prepare_jupiter_earn_deposit(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn deposit preparation.")
-
-    async def execute_jupiter_earn_deposit(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn deposits.")
-
-    async def preview_jupiter_earn_withdraw(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn withdraw previews.")
-
-    async def prepare_jupiter_earn_withdraw(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(
-            f"{self.name} does not support Jupiter Earn withdraw preparation."
-        )
-
-    async def execute_jupiter_earn_withdraw(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support Jupiter Earn withdrawals.")
-
     async def preview_close_empty_token_accounts(
         self,
         limit: int = 8,