agentstr 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

agentstr/marketplace.py

@@ -1,163 +1,1131 @@
+import ast
+import json
 import logging
-from typing import Optional
-from . import nostr 
+import re
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
+
+from agentstr.nostr import (
+    EventId,
+    Keys,
+    NostrClient,
+    ProductData,
+    ShippingCost,
+    ShippingMethod,
+    StallData,
+)
 
 try:
     from phi.tools import Toolkit
 except ImportError:
-    raise ImportError("`phidata` not installed. Please install using `pip install phidata`")
+    raise ImportError(
+        "`phidata` not installed. Please install using `pip install phidata`"
+    )
 
-try: 
-    import asyncio
-except ImportError:
-    raise ImportError("`asyncio` not installed. Please install using `pip install asyncio`")
+from pydantic import BaseModel, ConfigDict, Field, validate_call
 
-class MerchantProfile():
 
-    logger = logging.getLogger("MerchantProfile")
-    
-    def __init__(
-        self,
-        name: str,
-        about: str,
-        picture: str,
-        nsec: Optional[str] = None
-    ):
-        """Initialize the Merchant profile.
+class Profile:
+
+    logger = logging.getLogger("Profile")
+    WEB_URL: str = "https://primal.net/p/"
+
+    def __init__(self, name: str, about: str, picture: str, nsec: Optional[str] = None):
+        """Initialize the profile.
 
         Args:
             name: Name for the merchant
             about: brief description about the merchant
             picture: url to a png file with a picture for the merchant
-            nsec: private key to be used by this Merchant 
+            nsec: optional private key to be used by this Merchant
         """
 
         # Set log handling for MerchantProfile
-        if not MerchantProfile.logger.hasHandlers():
+        if not Profile.logger.hasHandlers():
             console_handler = logging.StreamHandler()
             console_handler.setLevel(logging.INFO)
-            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+            formatter = logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            )
             console_handler.setFormatter(formatter)
-            MerchantProfile.logger.addHandler(console_handler)
-        
+            Profile.logger.addHandler(console_handler)
+
         self.name = name
         self.about = about
         self.picture = picture
 
         if nsec:
             self.private_key = nsec
-            keys = nostr.Keys.parse(self.private_key)
+            keys = Keys.parse(self.private_key)
             self.public_key = keys.public_key().to_bech32()
-            MerchantProfile.logger.info(f"Pre-defined private key reused for {self.name}: {self.private_key}")
-            MerchantProfile.logger.info(f"Pre-defined public key reused for {self.name}: {self.public_key}")
+            Profile.logger.info(
+                f"Pre-defined private key reused for {self.name}: {self.private_key}"
+            )
+            Profile.logger.info(
+                f"Pre-defined public key reused for {self.name}: {self.public_key}"
+            )
         else:
-            keys = nostr.Keys.generate()
+            keys = Keys.generate()
             self.private_key = keys.secret_key().to_bech32()
             self.public_key = keys.public_key().to_bech32()
-            MerchantProfile.logger.info(f"New private key created for {self.name}: {self.private_key}")
-            MerchantProfile.logger.info(f"New public key created for {self.name}: {self.public_key}")
-            
-    def merchant_profile_to_str(self) -> str:
+            Profile.logger.info(
+                f"New private key created for {self.name}: {self.private_key}"
+            )
+            Profile.logger.info(
+                f"New public key created for {self.name}: {self.public_key}"
+            )
+
+        self.url = str(self.WEB_URL) + str(self.public_key)
+
+    def __str__(self) -> str:
         return (
-            f"Merchant name: {self.name}. "
-            f"Merchant description: {self.about}. "
-            f"Merchant picture URL: {self.picture}. "
-            f"Private key: {self.private_key}. "
-            f"Public key: {self.public_key}."
-    )
+            "Merchant Profile:\n"
+            "Name = {}\n"
+            "Description = {}\n"
+            "Picture = {}\n"
+            "URL = {}\n"
+            "Private key = {}\n"
+            "Public key = {}".format(
+                self.name,
+                self.about,
+                self.picture,
+                self.url,
+                self.private_key,
+                self.public_key,
+            )
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "description": self.about,
+            "picture": self.picture,
+            "public key": self.public_key,
+            "private key": self.private_key,
+        }
 
-    def get_public_key(self) -> str:
-        return self.public_key
-    
-    def get_private_key(self) -> str:
-        return self.private_key
-    
-    def get_name(self) -> str:
-        return self.name
-    
     def get_about(self) -> str:
+        """
+        Returns a description of the Merchant
+
+        Returns:
+            str: description of the Merchant
+        """
         return self.about
-    
+
+    def get_name(self) -> str:
+        """
+        Returns the Merchant's name
+
+        Returns:
+            str: Merchant's name
+        """
+        return self.name
+
     def get_picture(self) -> str:
+        """
+        Returns the picture associated with the Merchant.
+
+        Returns:
+            str: URL to the picture associated with the Merchant
+        """
         return self.picture
-        
+
+    def get_private_key(self) -> str:
+        """
+        Returns the private key.
+
+        Returns:
+            str: private key in bech32 format
+        """
+        return str(self.private_key)
+
+    def get_public_key(self) -> str:
+        """
+        Returns the public key.
+
+        Returns:
+            str: public key in bech32 format
+        """
+        return str(self.public_key)
+
+    def get_url(self) -> str:
+        return str(self.url)
+
+
+class MerchantProduct(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    id: str
+    stall_id: str
+    name: str
+    description: str
+    images: List[str]
+    currency: str
+    price: float
+    quantity: int
+    shipping: List[ShippingCost]
+    categories: Optional[List[str]] = []
+    specs: Optional[List[List[str]]] = []
+
+    @classmethod
+    def from_product_data(cls, product: ProductData) -> "MerchantProduct":
+        return cls(
+            id=product.id,
+            stall_id=product.stall_id,
+            name=product.name,
+            description=product.description,
+            images=product.images,
+            currency=product.currency,
+            price=product.price,
+            quantity=product.quantity,
+            shipping=product.shipping,
+            categories=product.categories if product.categories is not None else [],
+            specs=product.specs if product.specs is not None else [],
+        )
+
+    def to_product_data(self) -> ProductData:
+        return ProductData(
+            id=self.id,
+            stall_id=self.stall_id,
+            name=self.name,
+            description=self.description,
+            images=self.images,
+            currency=self.currency,
+            price=self.price,
+            quantity=self.quantity,
+            shipping=self.shipping,
+            categories=self.categories,
+            specs=self.specs,
+        )
+
+    def to_dict(self) -> dict:
+        """
+        Returns a dictionary representation of the MerchantProduct.
+        ShippingCost class is not serializable, so we need to convert it to a dictionary.
+
+        Returns:
+            dict: dictionary representation of the MerchantProduct
+        """
+        shipping_dicts = []
+        for shipping in self.shipping:
+            shipping_dicts.append({"id": shipping.id, "cost": shipping.cost})
+
+        return {
+            "id": self.id,
+            "stall_id": self.stall_id,
+            "name": self.name,
+            "description": self.description,
+            "images": self.images,
+            "currency": self.currency,
+            "price": self.price,
+            "quantity": self.quantity,
+            "shipping": shipping_dicts,
+            "categories": self.categories,
+            "specs": self.specs,
+        }
+
+
+class MerchantStall(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    id: str
+    name: str
+    description: str
+    currency: str
+    shipping: List[ShippingMethod]
+
+    @classmethod
+    def from_stall_data(cls, stall: StallData) -> "MerchantStall":
+        return cls(
+            id=stall.id(),
+            name=stall.name(),
+            description=stall.description(),
+            currency=stall.currency(),
+            shipping=stall.shipping(),
+        )
+
+    def to_stall_data(self) -> StallData:
+        return StallData(
+            self.id,
+            self.name,
+            self.description,
+            self.currency,
+            self.shipping,  # No conversion needed
+        )
+
+    def to_dict(self) -> dict:
+        """
+        Returns a dictionary representation of the MerchantStall.
+        ShippingMethod class is not serializable, so we need to convert it to a dictionary.
+        We can only access cost and id from the ShippingMethod class. We can't access name or regions.
+
+        Returns:
+            dict: dictionary representation of the MerchantStall
+        """
+        shipping_dicts = []
+        for shipping in self.shipping:
+            shipping_dicts.append(
+                {
+                    "cost": shipping.get_shipping_cost().cost,
+                    "id": shipping.get_shipping_cost().id,
+                }
+            )
+
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "currency": self.currency,
+            "shipping zones": [shipping_dicts],
+        }
 
 
 class Merchant(Toolkit):
+    """
+    Merchant is a toolkit that allows a merchant to publish products and stalls to Nostr.
+
+    TBD:
+    - Better differentiation between products and stalls in the database and products and stalls published.
+
+    """
+
+    from pydantic import ConfigDict
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, extra="allow", validate_assignment=True
+    )
+
+    _nostr_client: Optional[NostrClient] = None
+    product_db: List[Tuple[MerchantProduct, Optional[EventId]]] = []
+    stall_db: List[Tuple[MerchantStall, Optional[EventId]]] = []
 
-    WEB_URL: str = "http://njump.me/"
-    
     def __init__(
         self,
-        merchant_profile: MerchantProfile,
+        merchant_profile: Profile,
         relay: str,
+        stalls: List[MerchantStall],
+        products: List[MerchantProduct],
     ):
         """Initialize the Merchant toolkit.
 
         Args:
             merchant_profile: profile of the merchant using this agent
             relay: Nostr relay to use for communications
+            stalls: list of stalls managed by this merchant
+            products: list of products sold by this merchant
         """
         super().__init__(name="merchant")
         self.relay = relay
         self.merchant_profile = merchant_profile
+        self._nostr_client = NostrClient(
+            self.relay, self.merchant_profile.get_private_key()
+        )
+
+        # initialize the Product DB with no event id
+        self.product_db = [(product, None) for product in products]
 
-        # Register all methods
-        self.register(self.publish_merchant_profile)
-        self.register(self.get_merchant_url)
-    
-    def publish_merchant_profile(
-        self
+        # initialize the Stall DB with no event id
+        self.stall_db = [(stall, None) for stall in stalls]
+
+        # Register wrapped versions of the methods
+        self.register(self.get_profile)
+        self.register(self.get_relay)
+        self.register(self.get_products)
+        self.register(self.get_stalls)
+        self.register(self.publish_all_products)
+        self.register(self.publish_all_stalls)
+        self.register(self.publish_new_product)
+        self.register(self.publish_product_by_name)
+        self.register(self.publish_products_by_stall_name)
+        self.register(self.publish_profile)
+        self.register(self.publish_new_stall)
+        self.register(self.publish_stall_by_name)
+        self.register(self.remove_all_products)
+        self.register(self.remove_all_stalls)
+        self.register(self.remove_product_by_name)
+        self.register(self.remove_stall_by_name)
+
+    def get_profile(self) -> str:
+        """
+        Retrieves merchant profile in JSON format
+
+        Returns:
+            str: merchant profile in JSON format
+        """
+        return json.dumps(self.merchant_profile.to_dict())
+
+    def get_relay(self) -> str:
+        return self.relay
+
+    def get_products(self) -> str:
+        """
+        Retrieves all the merchant products
+
+        Returns:
+            str: JSON string containing all products
+        """
+        return json.dumps([p.to_dict() for p, _ in self.product_db])
+
+    def get_stalls(self) -> str:
+        """
+        Retrieves all the merchant stalls in JSON format
+
+        Returns:
+            str: JSON string containing all stalls
+        """
+        return json.dumps([s.to_dict() for s, _ in self.stall_db])
+
+    def publish_all_products(
+        self,
     ) -> str:
         """
-        Publishes the merchant profile on Nostr
+        Publishes or updates all products in the Merchant's Product DB
 
         Returns:
-            str: with event id and other details if successful or "error" string if unsuccesful
+            str: JSON array with status of all product publishing operations
         """
-        # Run the async pubilshing function synchronously
-        return asyncio.run(self._async_publish_merchant_profile())
-    
-    async def _async_publish_merchant_profile(
-        self
+
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        results = []
+
+        for i, (product, _) in enumerate(self.product_db):
+            try:
+                # Convert MerchantProduct to ProductData for nostr_client
+                product_data = product.to_product_data()
+                # Publish using the SDK's synchronous method
+                event_id = self._nostr_client.publish_product(product_data)
+                self.product_db[i] = (product, event_id)
+                results.append(
+                    {
+                        "status": "success",
+                        "event_id": str(event_id),
+                        "product_name": product.name,
+                    }
+                )
+            except Exception as e:
+                Profile.logger.error(f"Unable to publish product {product}. Error {e}")
+                results.append(
+                    {"status": "error", "message": str(e), "product_name": product.name}
+                )
+
+        return json.dumps(results)
+
+    def publish_all_stalls(
+        self,
     ) -> str:
         """
-        Asynchronous method to publish the merchant profile on Nostr
+        Publishes or updates all stalls managed by the merchant and adds the corresponding EventId to the Stall DB
 
         Returns:
-            str: with event id and other details if successful or "error" string if unsuccesful
+            str: JSON array with status of all stall publishing operations
         """
-        
-        nostr_client = nostr.NostrClient(self.relay, self.merchant_profile.get_private_key())
-        
-        # Connect to the relay
-        outcome = await nostr_client.connect()
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+        results = []
 
-        # Check if the operation resulted in an error
-        if outcome == nostr.NostrClient.ERROR:
-            return nostr.NostrClient.ERROR
-        else:
-            eventid = await nostr_client.publish_profile(
+        for i, (stall, _) in enumerate(self.stall_db):
+            try:
+                # Convert MerchantStall to StallData for nostr_client
+                stall_data = stall.to_stall_data()
+                event_id = self._nostr_client.publish_stall(stall_data)
+                self.stall_db[i] = (stall, event_id)
+                results.append(
+                    {
+                        "status": "success",
+                        "event_id": str(event_id),
+                        "stall_name": stall.name,
+                    }
+                )
+            except Exception as e:
+                Profile.logger.error(f"Unable to publish stall {stall}. Error {e}")
+                results.append(
+                    {"status": "error", "message": str(e), "stall_name": stall.name}
+                )
+
+        return json.dumps(results)
+
+    def publish_new_product(self, product: MerchantProduct) -> str:
+        """
+        Publishes a new product that is not currently in the Merchant's Product DB and adds it to the Product DB
+
+        Args:
+            product: MerchantProduct to be published
+
+        Returns:
+            str: JSON string with status of the operation
+        """
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        try:
+            # Convert MerchantProduct to ProductData for nostr_client
+            product_data = product.to_product_data()
+            # Publish using the SDK's synchronous method
+            event_id = self._nostr_client.publish_product(product_data)
+            # we need to add the product event id to the product db
+            self.product_db.append((product, event_id))
+            return json.dumps(
+                {
+                    "status": "success",
+                    "event_id": str(event_id),
+                    "product_name": product.name,
+                }
+            )
+        except Exception as e:
+            return json.dumps(
+                {"status": "error", "message": str(e), "product_name": product.name}
+            )
+
+    def publish_product_by_name(self, arguments: str) -> str:
+        """
+        Publishes or updates a given product from the Merchant's Product DB
+        Args:
+            arguments: JSON string that may contain {"name": "product_name"} or just "product_name"
+
+        Returns:
+            str: JSON string with status of the operation
+        """
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        try:
+            # Try to parse as JSON first
+            if isinstance(arguments, dict):
+                parsed = arguments
+            else:
+                parsed = json.loads(arguments)
+            name = parsed.get(
+                "name", parsed
+            )  # Get name if exists, otherwise use whole value
+        except json.JSONDecodeError:
+            # If not JSON, use the raw string
+            name = arguments
+
+        # iterate through all products searching for the right name
+        for i, (product, _) in enumerate(self.product_db):
+            if product.name == name:
+                try:
+                    # Convert MerchantProduct to ProductData for nostr_client
+                    product_data = product.to_product_data()
+                    # Publish using the SDK's synchronous method
+                    event_id = self._nostr_client.publish_product(product_data)
+                    # Update the product_db with the new event_id
+                    self.product_db[i] = (product, event_id)
+                    return json.dumps(
+                        {
+                            "status": "success",
+                            "event_id": str(event_id),
+                            "product_name": product.name,
+                        }
+                    )
+                except Exception as e:
+                    return json.dumps(
+                        {
+                            "status": "error",
+                            "message": str(e),
+                            "product_name": product.name,
+                        }
+                    )
+
+        # If we are here, then we didn't find a match
+        return json.dumps(
+            {
+                "status": "error",
+                "message": f"Product '{name}' not found in database",
+                "product_name": name,
+            }
+        )
+
+    def publish_products_by_stall_name(self, arguments: Union[str, dict]) -> str:
+        """
+        Publishes or updates all products sold by the merchant in a given stall
+
+        Args:
+            arguments: str or dict with the stall name. Can be in formats:
+                - {"name": "stall_name"}
+                - {"arguments": "{\"name\": \"stall_name\"}"}
+                - "stall_name"
+
+        Returns:
+            str: JSON array with status of all product publishing operations
+        """
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        try:
+            # Parse arguments to get stall_name
+            stall_name: str
+            if isinstance(arguments, str):
+                try:
+                    parsed = json.loads(arguments)
+                    if isinstance(parsed, dict):
+                        raw_name: Optional[Any] = parsed.get("name")
+                        stall_name = str(raw_name) if raw_name is not None else ""
+                    else:
+                        stall_name = arguments
+                except json.JSONDecodeError:
+                    stall_name = arguments
+            else:
+                if "arguments" in arguments:
+                    nested = json.loads(arguments["arguments"])
+                    if isinstance(nested, dict):
+                        raw_name = nested.get("name")
+                        stall_name = str(raw_name) if raw_name is not None else ""
+                    else:
+                        raw_name = nested
+                        stall_name = str(raw_name) if raw_name is not None else ""
+                else:
+                    raw_name = arguments.get("name", arguments)
+                    stall_name = str(raw_name) if raw_name is not None else ""
+
+            results = []
+            stall_id = None
+
+            # Find stall ID
+            for stall, _ in self.stall_db:
+                if stall.name == stall_name:
+                    stall_id = stall.id
+                    break
+
+            if stall_id is None:
+                return json.dumps(
+                    [
+                        {
+                            "status": "error",
+                            "message": f"Stall '{stall_name}' not found in database",
+                            "stall_name": stall_name,
+                        }
+                    ]
+                )
+
+            # Publish products
+            for i, (product, _) in enumerate(self.product_db):
+                if product.stall_id == stall_id:
+                    try:
+                        product_data = product.to_product_data()
+                        event_id = self._nostr_client.publish_product(product_data)
+                        self.product_db[i] = (product, event_id)
+                        results.append(
+                            {
+                                "status": "success",
+                                "event_id": str(event_id),
+                                "product_name": product.name,
+                                "stall_name": stall_name,
+                            }
+                        )
+                    except Exception as e:
+                        results.append(
+                            {
+                                "status": "error",
+                                "message": str(e),
+                                "product_name": product.name,
+                                "stall_name": stall_name,
+                            }
+                        )
+
+            if not results:
+                return json.dumps(
+                    [
+                        {
+                            "status": "error",
+                            "message": f"No products found in stall '{stall_name}'",
+                            "stall_name": stall_name,
+                        }
+                    ]
+                )
+
+            return json.dumps(results)
+
+        except Exception as e:
+            return json.dumps(
+                [{"status": "error", "message": str(e), "arguments": str(arguments)}]
+            )
+
+    def publish_profile(self) -> str:
+        """
+        Publishes the profile on Nostr
+
+        Returns:
+            str: JSON of the event that published the profile
+
+        Raises:
+            RuntimeError: if it can't publish the event
+        """
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        try:
+            event_id = self._nostr_client.publish_profile(
                 self.merchant_profile.get_name(),
                 self.merchant_profile.get_about(),
-                self.merchant_profile.get_picture()
-            )
-
-            # Check if the operation resulted in an error
-            if eventid == nostr.NostrClient.ERROR:
-                return nostr.NostrClient.ERROR
-        
-            # Return the event ID and merchant profile details
-            return eventid + self.merchant_profile.merchant_profile_to_str()
-    
-    def get_merchant_url(
-        self
-    ) -> str:
+                self.merchant_profile.get_picture(),
+            )
+            return json.dumps(event_id.__dict__)
+        except Exception as e:
+            raise RuntimeError(f"Unable to publish the profile: {e}")
+
+    def publish_new_stall(self, stall: MerchantStall) -> str:
         """
-        Returns URL with merchant profile
+        Publishes a new stall that is not currently in the Merchant's Stall DB and adds it to the Stall DB
+
+        Args:
+            stall: MerchantStall to be published
 
         Returns:
-            str: valid URL with merchant profile
+            str: JSON string with status of the operation
         """
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        try:
+            # Convert to StallData for SDK
+            stall_data = stall.to_stall_data()
+            # Publish using the SDK's synchronous method
+            event_id = self._nostr_client.publish_stall(stall_data)
+            # we need to add the stall event id to the stall db
+            self.stall_db.append((stall, event_id))
+            return json.dumps(
+                {
+                    "status": "success",
+                    "event_id": str(event_id),
+                    "stall_name": stall.name,
+                }
+            )
+        except Exception as e:
+            return json.dumps(
+                {"status": "error", "message": str(e), "stall_name": stall.name}
+            )
+
+    def publish_stall_by_name(self, arguments: Union[str, dict]) -> str:
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        try:
+            # Parse arguments to get stall_name
+            stall_name: str
+            if isinstance(arguments, str):
+                try:
+                    # Try to parse as JSON first
+                    parsed = json.loads(arguments)
+                    if isinstance(parsed, dict):
+                        raw_name: Optional[Any] = parsed.get("name")
+                        stall_name = str(raw_name) if raw_name is not None else ""
+                    else:
+                        stall_name = arguments
+                except json.JSONDecodeError:
+                    # If not JSON, use the raw string
+                    stall_name = arguments
+            else:
+                # Handle dict input
+                if "arguments" in arguments:
+                    nested = json.loads(arguments["arguments"])
+                    if isinstance(nested, dict):
+                        raw_name = nested.get("name")
+                        stall_name = str(raw_name) if raw_name is not None else ""
+                    else:
+                        raw_name = nested
+                        stall_name = str(raw_name) if raw_name is not None else ""
+                else:
+                    raw_name = arguments.get("name", arguments)
+                    stall_name = str(raw_name) if raw_name is not None else ""
+
+            # Find and publish stall
+            for i, (stall, _) in enumerate(self.stall_db):
+                if stall.name == stall_name:
+                    try:
+                        stall_data = stall.to_stall_data()
+                        event_id = self._nostr_client.publish_stall(stall_data)
+                        self.stall_db[i] = (stall, event_id)
+                        return json.dumps(
+                            {
+                                "status": "success",
+                                "event_id": str(event_id),
+                                "stall_name": stall.name,
+                            }
+                        )
+                    except Exception as e:
+                        return json.dumps(
+                            [
+                                {
+                                    "status": "error",
+                                    "message": str(e),
+                                    "stall_name": stall.name,
+                                }
+                            ]
+                        )
+
+            # Stall not found
+            return json.dumps(
+                [
+                    {
+                        "status": "error",
+                        "message": f"Stall '{stall_name}' not found in database",
+                        "stall_name": stall_name,
+                    }
+                ]
+            )
 
-        return self.WEB_URL + self.merchant_profile.get_public_key()
+        except Exception as e:
+            return json.dumps(
+                [{"status": "error", "message": str(e), "stall_name": "unknown"}]
+            )
+
+    def remove_all_products(self) -> str:
+        """
+        Removes all published products from Nostr
+
+        Returns:
+            str: JSON array with status of all product removal operations
+        """
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        results = []
+
+        for i, (product, event_id) in enumerate(self.product_db):
+            if event_id is None:
+                results.append(
+                    {
+                        "status": "skipped",
+                        "message": f"Product '{product.name}' has not been published yet",
+                        "product_name": product.name,
+                    }
+                )
+                continue
+
+            try:
+                # Delete the event using the SDK's method
+                self._nostr_client.delete_event(
+                    event_id, reason=f"Product '{product.name}' removed"
+                )
+                # Remove the event_id, keeping the product in the database
+                self.product_db[i] = (product, None)
+                results.append(
+                    {
+                        "status": "success",
+                        "message": f"Product '{product.name}' removed",
+                        "product_name": product.name,
+                        "event_id": str(event_id),
+                    }
+                )
+            except Exception as e:
+                results.append(
+                    {"status": "error", "message": str(e), "product_name": product.name}
+                )
+
+        return json.dumps(results)
+
+    def remove_all_stalls(self) -> str:
+        """
+        Removes all stalls and their products from Nostr
+
+        Returns:
+            str: JSON array with status of all removal operations
+        """
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        results = []
+
+        # First remove all products from all stalls
+        for i, (stall, _) in enumerate(self.stall_db):
+            stall_name = stall.name
+            stall_id = stall.id
+
+            # Remove all products in this stall
+            for j, (product, event_id) in enumerate(self.product_db):
+                if product.stall_id == stall_id:
+                    if event_id is None:
+                        results.append(
+                            {
+                                "status": "skipped",
+                                "message": f"Product '{product.name}' has not been published yet",
+                                "product_name": product.name,
+                                "stall_name": stall_name,
+                            }
+                        )
+                        continue
+
+                    try:
+                        self._nostr_client.delete_event(
+                            event_id,
+                            reason=f"Stall for product '{product.name}' removed",
+                        )
+                        self.product_db[j] = (product, None)
+                        results.append(
+                            {
+                                "status": "success",
+                                "message": f"Product '{product.name}' removed",
+                                "product_name": product.name,
+                                "stall_name": stall_name,
+                                "event_id": str(event_id),
+                            }
+                        )
+                    except Exception as e:
+                        results.append(
+                            {
+                                "status": "error",
+                                "message": str(e),
+                                "product_name": product.name,
+                                "stall_name": stall_name,
+                            }
+                        )
+
+            # Now remove the stall itself
+            _, stall_event_id = self.stall_db[i]
+            if stall_event_id is None:
+                results.append(
+                    {
+                        "status": "skipped",
+                        "message": f"Stall '{stall_name}' has not been published yet",
+                        "stall_name": stall_name,
+                    }
+                )
+            else:
+                try:
+                    self._nostr_client.delete_event(
+                        stall_event_id, reason=f"Stall '{stall_name}' removed"
+                    )
+                    self.stall_db[i] = (stall, None)
+                    results.append(
+                        {
+                            "status": "success",
+                            "message": f"Stall '{stall_name}' removed",
+                            "stall_name": stall_name,
+                            "event_id": str(stall_event_id),
+                        }
+                    )
+                except Exception as e:
+                    results.append(
+                        {"status": "error", "message": str(e), "stall_name": stall_name}
+                    )
+
+        return json.dumps(results)
+
+    def remove_product_by_name(self, arguments: str) -> str:
+        """
+        Deletes a product with the given name from Nostr
+
+        Args:
+            arguments: JSON string that may contain {"name": "product_name"} or just "product_name"
+
+        Returns:
+            str: JSON string with status of the operation
+        """
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        try:
+            # Try to parse as JSON first
+            if isinstance(arguments, dict):
+                parsed = arguments
+            else:
+                parsed = json.loads(arguments)
+            name = parsed.get(
+                "name", parsed
+            )  # Get name if exists, otherwise use whole value
+        except json.JSONDecodeError:
+            # If not JSON, use the raw string
+            name = arguments
+
+        # Find the product and its event_id in the product_db
+        for i, (product, event_id) in enumerate(self.product_db):
+            if product.name == name:
+                if event_id is None:
+                    return json.dumps(
+                        {
+                            "status": "error",
+                            "message": f"Product '{name}' has not been published yet",
+                            "product_name": name,
+                        }
+                    )
+
+                try:
+                    # Delete the event using the SDK's method
+                    self._nostr_client.delete_event(
+                        event_id, reason=f"Product '{name}' removed"
+                    )
+                    # Remove the event_id, keeping the product in the database
+                    self.product_db[i] = (product, None)
+                    return json.dumps(
+                        {
+                            "status": "success",
+                            "message": f"Product '{name}' removed",
+                            "product_name": name,
+                            "event_id": str(event_id),
+                        }
+                    )
+                except Exception as e:
+                    return json.dumps(
+                        {"status": "error", "message": str(e), "product_name": name}
+                    )
+
+        # If we get here, we didn't find the product
+        return json.dumps(
+            {
+                "status": "error",
+                "message": f"Product '{name}' not found in database",
+                "product_name": name,
+            }
+        )
+
+    def remove_stall_by_name(self, arguments: Union[str, dict]) -> str:
+        """Remove a stall and its products by name
+
+        Args:
+            arguments: str or dict with the stall name. Can be in formats:
+                - {"name": "stall_name"}
+                - {"arguments": "{\"name\": \"stall_name\"}"}
+                - "stall_name"
+
+        Returns:
+            str: JSON array with status of the operation
+        """
+        if self._nostr_client is None:
+            raise ValueError("NostrClient not initialized")
+
+        try:
+            # Parse arguments to get stall_name
+            stall_name: str
+            if isinstance(arguments, str):
+                try:
+                    parsed = json.loads(arguments)
+                    if isinstance(parsed, dict):
+                        raw_name: Optional[Any] = parsed.get("name")
+                        stall_name = str(raw_name) if raw_name is not None else ""
+                    else:
+                        stall_name = arguments
+                except json.JSONDecodeError:
+                    stall_name = arguments
+            else:
+                if "arguments" in arguments:
+                    nested = json.loads(arguments["arguments"])
+                    if isinstance(nested, dict):
+                        raw_name = nested.get("name")
+                        stall_name = str(raw_name) if raw_name is not None else ""
+                    else:
+                        raw_name = nested
+                        stall_name = str(raw_name) if raw_name is not None else ""
+                else:
+                    raw_name = arguments.get("name", arguments)
+                    stall_name = str(raw_name) if raw_name is not None else ""
+
+            results = []
+            stall_index = None
+            stall_id = None
+
+            # Find the stall and its event_id in the stall_db
+            for i, (stall, event_id) in enumerate(self.stall_db):
+                if stall.name == stall_name:
+                    stall_index = i
+                    stall_id = stall.id
+                    break
+
+            # If stall_id is empty, then we found no match
+            if stall_id is None:
+                return json.dumps(
+                    [
+                        {
+                            "status": "error",
+                            "message": f"Stall '{stall_name}' not found in database",
+                            "stall_name": stall_name,
+                        }
+                    ]
+                )
+
+            # First remove all products in this stall
+            for i, (product, event_id) in enumerate(self.product_db):
+                if product.stall_id == stall_id:
+                    if event_id is None:
+                        results.append(
+                            {
+                                "status": "skipped",
+                                "message": f"Product '{product.name}' has not been published yet",
+                                "product_name": product.name,
+                                "stall_name": stall_name,
+                            }
+                        )
+                        continue
+
+                    try:
+                        self._nostr_client.delete_event(
+                            event_id, reason=f"Stall for '{product.name}' removed"
+                        )
+                        self.product_db[i] = (product, None)
+                        results.append(
+                            {
+                                "status": "success",
+                                "message": f"Product '{product.name}' removed",
+                                "product_name": product.name,
+                                "stall_name": stall_name,
+                                "event_id": str(event_id),
+                            }
+                        )
+                    except Exception as e:
+                        results.append(
+                            {
+                                "status": "error",
+                                "message": str(e),
+                                "product_name": product.name,
+                                "stall_name": stall_name,
+                            }
+                        )
+
+            # Now remove the stall itself
+            if stall_index is not None:
+                _, stall_event_id = self.stall_db[stall_index]
+                if stall_event_id is None:
+                    results.append(
+                        {
+                            "status": "skipped",
+                            "message": f"Stall '{stall_name}' has not been published yet",
+                            "stall_name": stall_name,
+                        }
+                    )
+                else:
+                    try:
+                        self._nostr_client.delete_event(
+                            stall_event_id, reason=f"Stall '{stall_name}' removed"
+                        )
+                        self.stall_db[stall_index] = (
+                            self.stall_db[stall_index][0],
+                            None,
+                        )
+                        results.append(
+                            {
+                                "status": "success",
+                                "message": f"Stall '{stall_name}' removed",
+                                "stall_name": stall_name,
+                                "event_id": str(stall_event_id),
+                            }
+                        )
+                    except Exception as e:
+                        results.append(
+                            {
+                                "status": "error",
+                                "message": str(e),
+                                "stall_name": stall_name,
+                            }
+                        )
+
+            return json.dumps(results)
+
+        except Exception as e:
+            return json.dumps(
+                [{"status": "error", "message": str(e), "stall_name": "unknown"}]
+            )
+
+    def get_event_id(self, response: Any) -> str:
+        """Convert any response to a string event ID.
+
+        Args:
+            response: Response that might contain an event ID
+
+        Returns:
+            str: String representation of event ID or empty string if None
+        """
+        if response is None:
+            return ""
+        return str(response)