feat(core): add support for creator fee update

src/monitoring/block_event_processor.py

@@ -7,9 +7,11 @@ import json
 import struct
 from typing import Any
 
+import base58
 from solders.pubkey import Pubkey
 from solders.transaction import VersionedTransaction
 
+from core.pubkeys import PumpAddresses
 from trading.base import TokenInfo
 from utils.logger import get_logger
 
@@ -41,7 +43,7 @@ class PumpEventProcessor:
             with open("idl/pump_fun_idl.json") as f:
                 return json.load(f)
         except Exception as e:
-            logger.error(f"Failed to load IDL: {str(e)}")
+            logger.error(f"Failed to load IDL: {e!s}")
             # Create a minimal IDL with just what we need
             return {
                 "instructions": [
@@ -111,6 +113,8 @@ class PumpEventProcessor:
                 decoded_args = self._decode_create_instruction(
                     ix_data, create_ix, account_keys
                 )
+                creator = Pubkey.from_string(decoded_args["creator"])
+                creator_vault = self._find_creator_vault(creator)
 
                 return TokenInfo(
                     name=decoded_args["name"],
@@ -122,10 +126,12 @@ class PumpEventProcessor:
                         decoded_args["associatedBondingCurve"]
                     ),
                     user=Pubkey.from_string(decoded_args["user"]),
+                    creator=creator,
+                    creator_vault=creator_vault,
                 )
 
         except Exception as e:
-            logger.error(f"Error processing transaction: {str(e)}")
+            logger.error(f"Error processing transaction: {e!s}")
 
         return None
 
@@ -151,8 +157,8 @@ class PumpEventProcessor:
                 offset += 4
                 value = ix_data[offset : offset + length].decode("utf-8")
                 offset += length
-            elif arg["type"] == "publicKey":
-                value = base64.b64encode(ix_data[offset : offset + 32]).decode("utf-8")
+            elif arg["type"] == "pubkey":
+                value = base58.b58encode(ix_data[offset : offset + 32]).decode("utf-8")
                 offset += 32
             else:
                 logger.warning(f"Unsupported type: {arg['type']}")
@@ -166,3 +172,22 @@ class PumpEventProcessor:
         args["user"] = str(accounts[7])
 
         return args
+    
+    def _find_creator_vault(self, creator: Pubkey) -> Pubkey:
+        """
+        Find the creator vault for a creator.
+
+        Args:
+            creator: Creator address
+
+        Returns:
+            Creator vault address
+        """
+        derived_address, _ = Pubkey.find_program_address(
+            [
+                b"creator-vault",
+                bytes(creator)
+            ],
+            PumpAddresses.PROGRAM,
+        )
+        return derived_address

src/monitoring/geyser_event_processor.py

@@ -5,8 +5,10 @@ Event processing for pump.fun tokens using Geyser data.
 import struct
 from typing import Final
 
+import base58
 from solders.pubkey import Pubkey
 
+from core.pubkeys import PumpAddresses
 from trading.base import TokenInfo
 from utils.logger import get_logger
 
@@ -55,6 +57,12 @@ class GeyserEventProcessor:
                 offset += length
                 return value
             
+            def read_pubkey():
+                nonlocal offset
+                value = base58.b58encode(instruction_data[offset : offset + 32]).decode("utf-8")
+                offset += 32
+                return Pubkey.from_string(value)
+            
             # Helper to get account key
             def get_account_key(index):
                 if index >= len(accounts):
@@ -67,11 +75,14 @@ class GeyserEventProcessor:
             name = read_string()
             symbol = read_string()
             uri = read_string()
+            creator = read_pubkey()
 
             mint = get_account_key(0)
             bonding_curve = get_account_key(2)
             associated_bonding_curve = get_account_key(3)
             user = get_account_key(7)
+
+            creator_vault = self._find_creator_vault(creator)
             
             if not all([mint, bonding_curve, associated_bonding_curve, user]):
                 logger.warning("Missing required account keys in token creation")
@@ -85,8 +96,29 @@ class GeyserEventProcessor:
                 bonding_curve=bonding_curve,
                 associated_bonding_curve=associated_bonding_curve,
                 user=user,
+                creator=creator,
+                creator_vault=creator_vault,
             )
             
         except Exception as e:
             logger.error(f"Failed to process transaction data: {e}")
             return None
+    
+    def _find_creator_vault(self, creator: Pubkey) -> Pubkey:
+        """
+        Find the creator vault for a creator.
+
+        Args:
+            creator: Creator address
+
+        Returns:
+            Creator vault address
+        """
+        derived_address, _ = Pubkey.find_program_address(
+            [
+                b"creator-vault",
+                bytes(creator)
+            ],
+            PumpAddresses.PROGRAM,
+        )
+        return derived_address

src/monitoring/logs_event_processor.py

@@ -9,7 +9,7 @@ from typing import Final
 import base58
 from solders.pubkey import Pubkey
 
-from core.pubkeys import SystemAddresses
+from core.pubkeys import PumpAddresses, SystemAddresses
 from trading.base import TokenInfo
 from utils.logger import get_logger
 
@@ -62,6 +62,8 @@ class LogsEventProcessor:
                         associated_curve = self._find_associated_bonding_curve(
                             mint, bonding_curve
                         )
+                        creator = Pubkey.from_string(parsed_data["creator"])
+                        creator_vault = self._find_creator_vault(creator)
                         
                         return TokenInfo(
                             name=parsed_data["name"],
@@ -71,6 +73,8 @@ class LogsEventProcessor:
                             bonding_curve=bonding_curve,
                             associated_bonding_curve=associated_curve,
                             user=Pubkey.from_string(parsed_data["user"]),
+                            creator=creator,
+                            creator_vault=creator_vault,
                         )
                 except Exception as e:
                     logger.error(f"Failed to process log data: {e}")
@@ -106,6 +110,7 @@ class LogsEventProcessor:
             ("mint", "publicKey"),
             ("bondingCurve", "publicKey"),
             ("user", "publicKey"),
+            ("creator", "publicKey"),
         ]
 
         try:
@@ -149,3 +154,22 @@ class LogsEventProcessor:
             SystemAddresses.ASSOCIATED_TOKEN_PROGRAM,
         )
         return derived_address
+    
+    def _find_creator_vault(self, creator: Pubkey) -> Pubkey:
+        """
+        Find the creator vault for a creator.
+
+        Args:
+            creator: Creator address
+
+        Returns:
+            Creator vault address
+        """
+        derived_address, _ = Pubkey.find_program_address(
+            [
+                b"creator-vault",
+                bytes(creator)
+            ],
+            PumpAddresses.PROGRAM,
+        )
+        return derived_address