chipi-stack 2.0.0__py3-none-any.whl

chipi_sdk/sessions.py

@@ -0,0 +1,836 @@
+"""Session key management for CHIPI wallets (SNIP-9 compatible)."""
+
+import time
+import secrets
+from typing import Optional
+from starknet_py.net.full_node_client import FullNodeClient
+from starknet_py.net.signer.stark_curve_signer import KeyPair
+
+from .models.session import (
+    SessionKeyData,
+    CreateSessionKeyParams,
+    AddSessionKeyParams,
+    RevokeSessionKeyParams,
+    GetSessionDataParams,
+    SessionDataResponse,
+    ExecuteWithSessionParams,
+    SetSpendingPolicyParams,
+    GetSpendingPolicyParams,
+    RemoveSpendingPolicyParams,
+    SpendingPolicyData,
+)
+from .models.wallet import WalletType
+from .encryption import encrypt_private_key
+from .errors import ChipiSessionError
+from .constants import (
+    WALLET_CLASS_HASHES,
+    WALLET_RPC_ENDPOINTS,
+    SESSION_DEFAULTS,
+    SESSION_ERRORS,
+    SESSION_ENTRYPOINTS,
+)
+from .client import ChipiClient
+from .execute_paymaster import (
+    execute_paymaster_transaction,
+    execute_paymaster_transaction_sync,
+    execute_paymaster_transaction_with_session,
+    execute_paymaster_transaction_with_session_sync,
+)
+
+
+class ChipiSessions:
+    """Session key management for CHIPI wallets."""
+
+    def __init__(self, client: ChipiClient):
+        """
+        Initialize session manager.
+
+        Args:
+            client: Chipi HTTP client
+        """
+        self.client = client
+
+    def _validate_chipi_wallet(
+        self,
+        wallet_type: Optional[WalletType],
+        operation: str,
+        wallet_public_key: Optional[str] = None,
+    ) -> None:
+        """
+        Validate that the wallet is a CHIPI wallet.
+
+        Args:
+            wallet_type: Wallet type
+            operation: Operation name for error messages
+            wallet_public_key: Optional wallet address for logging
+
+        Raises:
+            ChipiSessionError: If wallet type is not CHIPI
+        """
+        if wallet_type != WalletType.CHIPI:
+            print(
+                f"[ChipiSDK:Session:{operation}] Invalid wallet type",
+                {
+                    "provided": wallet_type,
+                    "required": "CHIPI",
+                    "expectedClassHash": WALLET_CLASS_HASHES[WalletType.CHIPI],
+                    "walletAddress": (
+                        wallet_public_key[:15] + "..." if wallet_public_key else "(not provided)"
+                    ),
+                    "hint": "Session keys only work with CHIPI wallets (SNIP-9 compatible)",
+                },
+            )
+            raise ChipiSessionError(
+                f"Session keys require CHIPI wallet type. Got: \"{wallet_type or 'undefined'}\". "
+                f"Session keys are only supported for CHIPI wallets with class hash {WALLET_CLASS_HASHES[WalletType.CHIPI]}",
+                SESSION_ERRORS["INVALID_WALLET_TYPE_FOR_SESSION"],
+            )
+
+    def _to_hex(self, data: bytes) -> str:
+        """
+        Convert bytes to hex string with 0x prefix.
+
+        Args:
+            data: Bytes to convert
+
+        Returns:
+            Hex string with 0x prefix
+        """
+        return "0x" + data.hex()
+
+    def create_session_key(self, params: CreateSessionKeyParams) -> SessionKeyData:
+        """
+        Generate a new session keypair locally.
+
+        This method generates the session keys but does NOT register them on-chain.
+        The returned SessionKeyData should be stored externally by the developer.
+
+        After generating, call `add_session_key_to_contract()` to register on-chain.
+
+        Args:
+            params: Session creation parameters
+
+        Returns:
+            Session key data for external storage
+
+        Raises:
+            ChipiSessionError: If session creation fails
+        """
+        encrypt_key = params.encrypt_key
+        duration_seconds = params.duration_seconds or SESSION_DEFAULTS["DURATION_SECONDS"]
+
+        try:
+            # Generate random private key (32 bytes)
+            raw_private_key = secrets.token_bytes(32)
+            private_key_hex = self._to_hex(raw_private_key)
+
+            # Derive public key using starknet.py
+            key_pair = KeyPair.from_private_key(int(private_key_hex, 16))
+            public_key = hex(key_pair.public_key)
+
+            # Calculate expiration timestamp
+            valid_until = int(time.time()) + duration_seconds
+
+            # Encrypt the private key for storage
+            encrypted_private_key = encrypt_private_key(private_key_hex, encrypt_key)
+
+            return SessionKeyData(
+                public_key=public_key,
+                encrypted_private_key=encrypted_private_key,
+                valid_until=valid_until,
+            )
+        except Exception as error:
+            raise ChipiSessionError(
+                f"Failed to create session key: {str(error)}",
+                SESSION_ERRORS["SESSION_CREATION_FAILED"],
+            )
+
+    async def aadd_session_key_to_contract(
+        self, params: AddSessionKeyParams, bearer_token: str
+    ) -> str:
+        """
+        Register a session key on the smart contract (async).
+
+        Executes a sponsored transaction to call `add_or_update_session_key`.
+        The session must be registered before it can be used for transactions.
+
+        Args:
+            params: Session registration parameters
+            bearer_token: Authentication token
+
+        Returns:
+            Transaction hash
+
+        Raises:
+            ChipiSessionError: If registration fails
+        """
+        encrypt_key = params.encrypt_key
+        wallet = params.wallet
+        session_config = params.session_config
+
+        # Validate CHIPI wallet
+        self._validate_chipi_wallet(
+            wallet.wallet_type, "AddToContract", wallet.public_key
+        )
+
+        try:
+            print(
+                "[ChipiSDK:Session:AddToContract] Registering session on-chain",
+                {
+                    "walletAddress": wallet.public_key[:15] + "...",
+                    "sessionPubKey": session_config.session_public_key[:15] + "...",
+                    "validUntil": time.strftime(
+                        "%Y-%m-%d %H:%M:%S", time.gmtime(session_config.valid_until)
+                    ),
+                    "maxCalls": session_config.max_calls,
+                    "allowedEntrypoints": len(session_config.allowed_entrypoints),
+                },
+            )
+
+            # Build calldata for add_or_update_session_key
+            calldata = [
+                session_config.session_public_key,
+                hex(session_config.valid_until),
+                hex(session_config.max_calls),
+                hex(len(session_config.allowed_entrypoints)),
+                *session_config.allowed_entrypoints,
+            ]
+
+            # Execute via paymaster (owner signature)
+            from .models.transaction import Call
+
+            tx_hash = await execute_paymaster_transaction(
+                params={
+                    "encryptKey": encrypt_key,
+                    "wallet": {**wallet.model_dump(), "walletType": "CHIPI"},
+                    "calls": [
+                        Call(
+                            contractAddress=wallet.public_key,
+                            entrypoint=SESSION_ENTRYPOINTS["ADD_OR_UPDATE"],
+                            calldata=calldata,
+                        ).model_dump()
+                    ],
+                    "saveToDatabase": False,  # Don't record session management txs
+                },
+                bearer_token=bearer_token,
+                client=self.client,
+            )
+
+            print(
+                "[ChipiSDK:Session:AddToContract] Session registered successfully",
+                {
+                    "txHash": tx_hash,
+                    "sessionPubKey": session_config.session_public_key[:15] + "...",
+                },
+            )
+
+            return tx_hash
+        except Exception as error:
+            print(
+                "[ChipiSDK:Session:AddToContract] Registration failed",
+                {"error": str(error)},
+            )
+            raise
+
+    def add_session_key_to_contract(
+        self, params: AddSessionKeyParams, bearer_token: str
+    ) -> str:
+        """
+        Register a session key on the smart contract (sync).
+
+        Args:
+            params: Session registration parameters
+            bearer_token: Authentication token
+
+        Returns:
+            Transaction hash
+        """
+        import asyncio
+        return asyncio.run(self.aadd_session_key_to_contract(params, bearer_token))
+
+    async def arevoke_session_key(
+        self, params: RevokeSessionKeyParams, bearer_token: str
+    ) -> str:
+        """
+        Revoke a session key from the smart contract (async).
+
+        After revocation, the session key can no longer be used for transactions.
+
+        Args:
+            params: Session revocation parameters
+            bearer_token: Authentication token
+
+        Returns:
+            Transaction hash
+        """
+        encrypt_key = params.encrypt_key
+        wallet = params.wallet
+        session_public_key = params.session_public_key
+
+        # Validate CHIPI wallet
+        self._validate_chipi_wallet(wallet.wallet_type, "Revoke", wallet.public_key)
+
+        try:
+            print(
+                "[ChipiSDK:Session:Revoke] Revoking session from contract",
+                {
+                    "walletAddress": wallet.public_key[:15] + "...",
+                    "sessionToRevoke": session_public_key[:15] + "...",
+                },
+            )
+
+            # Execute via paymaster (owner signature)
+            from .models.transaction import Call
+
+            tx_hash = await execute_paymaster_transaction(
+                params={
+                    "encryptKey": encrypt_key,
+                    "wallet": {**wallet.model_dump(), "walletType": "CHIPI"},
+                    "calls": [
+                        Call(
+                            contractAddress=wallet.public_key,
+                            entrypoint=SESSION_ENTRYPOINTS["REVOKE"],
+                            calldata=[session_public_key],
+                        ).model_dump()
+                    ],
+                    "saveToDatabase": False,
+                },
+                bearer_token=bearer_token,
+                client=self.client,
+            )
+
+            print(
+                "[ChipiSDK:Session:Revoke] Session revoked successfully",
+                {
+                    "txHash": tx_hash,
+                    "sessionRevoked": session_public_key[:15] + "...",
+                },
+            )
+
+            return tx_hash
+        except Exception as error:
+            print("[ChipiSDK:Session:Revoke] Revocation failed", {"error": str(error)})
+            raise
+
+    def revoke_session_key(
+        self, params: RevokeSessionKeyParams, bearer_token: str
+    ) -> str:
+        """
+        Revoke a session key from the smart contract (sync).
+
+        Args:
+            params: Session revocation parameters
+            bearer_token: Authentication token
+
+        Returns:
+            Transaction hash
+        """
+        import asyncio
+        return asyncio.run(self.arevoke_session_key(params, bearer_token))
+
+    async def aget_session_data(
+        self, params: GetSessionDataParams
+    ) -> SessionDataResponse:
+        """
+        Query session data from the smart contract (async).
+
+        This is a read-only call that does not require signing or gas.
+
+        Args:
+            params: Query parameters
+
+        Returns:
+            Session data including status and remaining calls
+        """
+        wallet_address = params.wallet_address
+        session_public_key = params.session_public_key
+
+        try:
+            provider = FullNodeClient(node_url=WALLET_RPC_ENDPOINTS[WalletType.CHIPI])
+
+            print(
+                "[ChipiSDK:Session:GetData] Querying session data",
+                {
+                    "walletAddress": wallet_address[:15] + "...",
+                    "sessionPubKey": session_public_key[:15] + "...",
+                },
+            )
+
+            result = await provider.call_contract(
+                call={
+                    "contract_address": int(wallet_address, 16),
+                    "entry_point_selector": get_selector_from_name(
+                        SESSION_ENTRYPOINTS["GET_DATA"]
+                    ),
+                    "calldata": [int(session_public_key, 16)],
+                }
+            )
+
+            # Parse the response
+            if len(result) < 4:
+                print(
+                    "[ChipiSDK:Session:GetData] Unexpected response format",
+                    {"resultLength": len(result)},
+                )
+                return SessionDataResponse(
+                    is_active=False,
+                    valid_until=0,
+                    remaining_calls=0,
+                    allowed_entrypoints=[],
+                )
+
+            is_active = result[0] == 1
+            valid_until = int(result[1])
+            remaining_calls = int(result[2])
+            entrypoints_len = int(result[3])
+            allowed_entrypoints = [hex(val) for val in result[4 : 4 + entrypoints_len]]
+
+            session_data = SessionDataResponse(
+                is_active=is_active,
+                valid_until=valid_until,
+                remaining_calls=remaining_calls,
+                allowed_entrypoints=allowed_entrypoints,
+            )
+
+            print(
+                "[ChipiSDK:Session:GetData] Session data retrieved",
+                {
+                    "isActive": is_active,
+                    "validUntil": time.strftime(
+                        "%Y-%m-%d %H:%M:%S", time.gmtime(valid_until)
+                    ),
+                    "remainingCalls": remaining_calls,
+                    "allowedEntrypointsCount": len(allowed_entrypoints),
+                },
+            )
+
+            return session_data
+        except Exception as error:
+            print(
+                "[ChipiSDK:Session:GetData] Query failed", {"error": str(error)}
+            )
+            # Return inactive session on error
+            return SessionDataResponse(
+                is_active=False,
+                valid_until=0,
+                remaining_calls=0,
+                allowed_entrypoints=[],
+            )
+
+    def get_session_data(self, params: GetSessionDataParams) -> SessionDataResponse:
+        """
+        Query session data from the smart contract (sync).
+
+        Args:
+            params: Query parameters
+
+        Returns:
+            Session data
+        """
+        import asyncio
+        return asyncio.run(self.aget_session_data(params))
+
+    async def aexecute_transaction_with_session(
+        self, params: ExecuteWithSessionParams, bearer_token: str
+    ) -> str:
+        """
+        Execute a gasless transaction using a session key (async).
+
+        The session must be registered on-chain before use.
+        CHIPI wallets only.
+
+        Args:
+            params: Session execution parameters
+            bearer_token: Authentication token
+
+        Returns:
+            Transaction hash
+        """
+        # Validate wallet type if provided
+        if params.wallet.wallet_type and params.wallet.wallet_type != WalletType.CHIPI:
+            raise ChipiSessionError(
+                f"Session execution only supports CHIPI wallets. Got: {params.wallet.wallet_type}",
+                SESSION_ERRORS["INVALID_WALLET_TYPE_FOR_SESSION"],
+            )
+
+        return await execute_paymaster_transaction_with_session(
+            params={
+                "encryptKey": params.encrypt_key,
+                "wallet": {**params.wallet.model_dump(), "walletType": "CHIPI"},
+                "session": params.session.model_dump(),
+                "calls": [call.model_dump() for call in params.calls],
+                "saveToDatabase": True,
+            },
+            bearer_token=bearer_token,
+            client=self.client,
+        )
+
+    def execute_transaction_with_session(
+        self, params: ExecuteWithSessionParams, bearer_token: str
+    ) -> str:
+        """
+        Execute a gasless transaction using a session key (sync).
+
+        Args:
+            params: Session execution parameters
+            bearer_token: Authentication token
+
+        Returns:
+            Transaction hash
+        """
+        # Validate wallet type if provided
+        if params.wallet.wallet_type and params.wallet.wallet_type != WalletType.CHIPI:
+            raise ChipiSessionError(
+                f"Session execution only supports CHIPI wallets. Got: {params.wallet.wallet_type}",
+                SESSION_ERRORS["INVALID_WALLET_TYPE_FOR_SESSION"],
+            )
+
+        return execute_paymaster_transaction_with_session_sync(
+            params={
+                "encryptKey": params.encrypt_key,
+                "wallet": {**params.wallet.model_dump(), "walletType": "CHIPI"},
+                "session": params.session.model_dump(),
+                "calls": [call.model_dump() for call in params.calls],
+                "saveToDatabase": True,
+            },
+            bearer_token=bearer_token,
+            client=self.client,
+        )
+
+
+    # --- Spending Policy Methods ---
+
+    def _split_u256(self, value: int) -> tuple[str, str]:
+        """Split an integer into Cairo u256 (low u128, high u128) hex strings."""
+        mask = (1 << 128) - 1
+        return (hex(value & mask), hex(value >> 128))
+
+    def _join_u256(self, low: int, high: int) -> int:
+        """Reconstruct an integer from Cairo u256 (low, high) parts."""
+        return low + (high << 128)
+
+    async def aset_spending_policy(
+        self, params: SetSpendingPolicyParams, bearer_token: str
+    ) -> str:
+        """
+        Set a spending policy for a session key + token pair (async).
+
+        Args:
+            params: Spending policy parameters
+            bearer_token: Authentication token
+
+        Returns:
+            Transaction hash
+        """
+        encrypt_key = params.encrypt_key
+        wallet = params.wallet
+        config = params.spending_policy_config
+
+        # Validate wallet type if provided (backward compat: omitted = assume CHIPI)
+        if wallet.wallet_type and wallet.wallet_type != WalletType.CHIPI:
+            raise ChipiSessionError(
+                f"Spending policies only support CHIPI wallets. Got: {wallet.wallet_type}",
+                SESSION_ERRORS["INVALID_WALLET_TYPE_FOR_SESSION"],
+            )
+
+        # Validate config
+        u256_max = (1 << 256) - 1
+        u64_max = (1 << 64) - 1
+
+        if not config.token or config.token.strip() == "":
+            raise ChipiSessionError(
+                f"Invalid token address for spending policy: \"{config.token}\"",
+                SESSION_ERRORS["INVALID_SPENDING_POLICY"],
+            )
+        if not isinstance(config.window_seconds, int) or config.window_seconds <= 0 or config.window_seconds > u64_max:
+            raise ChipiSessionError(
+                f"Invalid window duration: {config.window_seconds}. Must be a positive integer within u64 range.",
+                SESSION_ERRORS["INVALID_SPENDING_POLICY"],
+            )
+        if config.max_per_call < 0 or config.max_per_call > u256_max:
+            raise ChipiSessionError(
+                "Invalid max_per_call: must be >= 0 and <= 2^256 - 1",
+                SESSION_ERRORS["INVALID_SPENDING_POLICY"],
+            )
+        if config.max_per_window < 0 or config.max_per_window > u256_max:
+            raise ChipiSessionError(
+                "Invalid max_per_window: must be >= 0 and <= 2^256 - 1",
+                SESSION_ERRORS["INVALID_SPENDING_POLICY"],
+            )
+        if config.max_per_window > 0 and config.max_per_call > config.max_per_window:
+            raise ChipiSessionError(
+                "Invalid spending policy: max_per_call cannot exceed max_per_window",
+                SESSION_ERRORS["INVALID_SPENDING_POLICY"],
+            )
+
+        try:
+            print(
+                "[ChipiSDK:Session:SetSpendingPolicy] Setting spending policy",
+                {
+                    "walletAddress": wallet.public_key[:15] + "...",
+                    "sessionPubKey": config.session_public_key[:15] + "...",
+                    "token": config.token[:15] + "...",
+                    "maxPerCall": str(config.max_per_call),
+                    "maxPerWindow": str(config.max_per_window),
+                    "windowSeconds": config.window_seconds,
+                },
+            )
+
+            max_per_call_low, max_per_call_high = self._split_u256(config.max_per_call)
+            max_per_window_low, max_per_window_high = self._split_u256(config.max_per_window)
+
+            calldata = [
+                config.session_public_key,
+                config.token,
+                max_per_call_low,
+                max_per_call_high,
+                max_per_window_low,
+                max_per_window_high,
+                hex(config.window_seconds),
+            ]
+
+            from .models.transaction import Call
+
+            tx_hash = await execute_paymaster_transaction(
+                params={
+                    "encryptKey": encrypt_key,
+                    "wallet": {**wallet.model_dump(), "walletType": "CHIPI"},
+                    "calls": [
+                        Call(
+                            contractAddress=wallet.public_key,
+                            entrypoint=SESSION_ENTRYPOINTS["SET_SPENDING_POLICY"],
+                            calldata=calldata,
+                        ).model_dump()
+                    ],
+                    "saveToDatabase": False,
+                },
+                bearer_token=bearer_token,
+                client=self.client,
+            )
+
+            print(
+                "[ChipiSDK:Session:SetSpendingPolicy] Spending policy set successfully",
+                {"txHash": tx_hash},
+            )
+
+            return tx_hash
+        except Exception as error:
+            print(
+                "[ChipiSDK:Session:SetSpendingPolicy] Failed",
+                {"error": str(error)},
+            )
+            raise
+
+    def set_spending_policy(
+        self, params: SetSpendingPolicyParams, bearer_token: str
+    ) -> str:
+        """Set a spending policy for a session key + token pair (sync)."""
+        import asyncio
+        return asyncio.run(self.aset_spending_policy(params, bearer_token))
+
+    async def aget_spending_policy(
+        self, params: GetSpendingPolicyParams
+    ) -> SpendingPolicyData:
+        """
+        Query a spending policy from the smart contract (async).
+
+        Read-only — no signature or gas required.
+
+        Args:
+            params: Query parameters
+
+        Returns:
+            Spending policy data
+        """
+        wallet_address = params.wallet_address
+        session_public_key = params.session_public_key
+        token = params.token
+
+        if not token or token.strip() == "":
+            raise ChipiSessionError(
+                f"Invalid token address for spending policy query: \"{token}\"",
+                SESSION_ERRORS["INVALID_SPENDING_POLICY"],
+            )
+
+        try:
+            provider = FullNodeClient(node_url=WALLET_RPC_ENDPOINTS[WalletType.CHIPI])
+
+            print(
+                "[ChipiSDK:Session:GetSpendingPolicy] Querying spending policy",
+                {
+                    "walletAddress": wallet_address[:15] + "...",
+                    "sessionPubKey": session_public_key[:15] + "...",
+                    "token": token[:15] + "...",
+                },
+            )
+
+            result = await provider.call_contract(
+                call={
+                    "contract_address": int(wallet_address, 16),
+                    "entry_point_selector": get_selector_from_name(
+                        SESSION_ENTRYPOINTS["GET_SPENDING_POLICY"]
+                    ),
+                    "calldata": [int(session_public_key, 16), int(token, 16)],
+                }
+            )
+
+            if len(result) < 8:
+                print(
+                    "[ChipiSDK:Session:GetSpendingPolicy] Unexpected response format",
+                    {"resultLength": len(result)},
+                )
+                return SpendingPolicyData(
+                    max_per_call=0,
+                    max_per_window=0,
+                    window_seconds=0,
+                    spent_in_window=0,
+                    window_start=0,
+                )
+
+            policy_data = SpendingPolicyData(
+                max_per_call=self._join_u256(int(result[0]), int(result[1])),
+                max_per_window=self._join_u256(int(result[2]), int(result[3])),
+                window_seconds=int(result[4]),
+                spent_in_window=self._join_u256(int(result[5]), int(result[6])),
+                window_start=int(result[7]),
+            )
+
+            print(
+                "[ChipiSDK:Session:GetSpendingPolicy] Spending policy retrieved",
+                {
+                    "maxPerCall": str(policy_data.max_per_call),
+                    "maxPerWindow": str(policy_data.max_per_window),
+                    "windowSeconds": policy_data.window_seconds,
+                },
+            )
+
+            return policy_data
+        except Exception as error:
+            import re
+            error_msg = str(error)
+            not_found_patterns = [
+                r"entry point.*not found",
+                r"requested entrypoint was not found",
+                r"invalid message selector",
+                r"contract not found",
+                r"is not deployed",
+            ]
+            is_not_found = any(re.search(p, error_msg, re.IGNORECASE) for p in not_found_patterns)
+
+            if is_not_found:
+                print(
+                    "[ChipiSDK:Session:GetSpendingPolicy] No policy found",
+                    {"walletAddress": wallet_address[:15] + "..."},
+                )
+                return SpendingPolicyData(
+                    max_per_call=0,
+                    max_per_window=0,
+                    window_seconds=0,
+                    spent_in_window=0,
+                    window_start=0,
+                )
+
+            print(
+                "[ChipiSDK:Session:GetSpendingPolicy] RPC/network error",
+                {"error": error_msg},
+            )
+            raise
+
+    def get_spending_policy(self, params: GetSpendingPolicyParams) -> SpendingPolicyData:
+        """Query a spending policy from the smart contract (sync)."""
+        import asyncio
+        return asyncio.run(self.aget_spending_policy(params))
+
+    async def aremove_spending_policy(
+        self, params: RemoveSpendingPolicyParams, bearer_token: str
+    ) -> str:
+        """
+        Remove a spending policy for a session key + token pair (async).
+
+        Args:
+            params: Policy removal parameters
+            bearer_token: Authentication token
+
+        Returns:
+            Transaction hash
+        """
+        encrypt_key = params.encrypt_key
+        wallet = params.wallet
+        session_public_key = params.session_public_key
+        token = params.token
+
+        # Validate wallet type if provided (backward compat: omitted = assume CHIPI)
+        if wallet.wallet_type and wallet.wallet_type != WalletType.CHIPI:
+            raise ChipiSessionError(
+                f"Spending policies only support CHIPI wallets. Got: {wallet.wallet_type}",
+                SESSION_ERRORS["INVALID_WALLET_TYPE_FOR_SESSION"],
+            )
+
+        if not token or token.strip() == "":
+            raise ChipiSessionError(
+                f"Invalid token address for spending policy removal: \"{token}\"",
+                SESSION_ERRORS["INVALID_SPENDING_POLICY"],
+            )
+
+        try:
+            print(
+                "[ChipiSDK:Session:RemoveSpendingPolicy] Removing spending policy",
+                {
+                    "walletAddress": wallet.public_key[:15] + "...",
+                    "sessionPubKey": session_public_key[:15] + "...",
+                    "token": token[:15] + "...",
+                },
+            )
+
+            from .models.transaction import Call
+
+            tx_hash = await execute_paymaster_transaction(
+                params={
+                    "encryptKey": encrypt_key,
+                    "wallet": {**wallet.model_dump(), "walletType": "CHIPI"},
+                    "calls": [
+                        Call(
+                            contractAddress=wallet.public_key,
+                            entrypoint=SESSION_ENTRYPOINTS["REMOVE_SPENDING_POLICY"],
+                            calldata=[session_public_key, token],
+                        ).model_dump()
+                    ],
+                    "saveToDatabase": False,
+                },
+                bearer_token=bearer_token,
+                client=self.client,
+            )
+
+            print(
+                "[ChipiSDK:Session:RemoveSpendingPolicy] Spending policy removed",
+                {"txHash": tx_hash},
+            )
+
+            return tx_hash
+        except Exception as error:
+            print(
+                "[ChipiSDK:Session:RemoveSpendingPolicy] Failed",
+                {"error": str(error)},
+            )
+            raise
+
+    def remove_spending_policy(
+        self, params: RemoveSpendingPolicyParams, bearer_token: str
+    ) -> str:
+        """Remove a spending policy for a session key + token pair (sync)."""
+        import asyncio
+        return asyncio.run(self.aremove_spending_policy(params, bearer_token))
+
+
+def get_selector_from_name(name: str) -> int:
+    """
+    Get selector from function name.
+
+    Args:
+        name: Function name
+
+    Returns:
+        Selector as integer
+    """
+    from starknet_py.hash.selector import get_selector_from_name as _get_selector
+    return _get_selector(name)