├── README.md
└── pump_fun_ws
    ├── pf_mints_ws.py
    ├── pf_trade_ws.py
    └── pump_swap_pool_ws.py


/README.md:
--------------------------------------------------------------------------------
 1 | ## Pump Fun Websocket ##
 2 | 
 3 | Monitors Pump Fun mint, trade events, and Pump Swap Pool creation in real-time via WebSocket, using a WSS URL from providers like Helius or QuickNode. 
 4 | 
 5 | This code can be adapted for use in a sniper bot or copy trading bot.
 6 | 
 7 | If you can - please support my work and donate to: 3pPK76GL5ChVFBHND54UfBMtg36Bsh1mzbQPTbcK89PD
 8 | 
 9 | ```
10 | pip install websocket-client solders construct
11 | ```
12 | 
13 | ## Contact ##
14 | 
15 | My services are for hire. Contact me if you need help integrating the code into your own project.
16 | 
17 | Telegram: @AL_THE_BOT_FATHER
18 | 


--------------------------------------------------------------------------------
/pump_fun_ws/pf_mints_ws.py:
--------------------------------------------------------------------------------
  1 | import websocket
  2 | import json
  3 | import base64
  4 | from solders.pubkey import Pubkey  # type: ignore
  5 | import struct
  6 | 
  7 | WSS = "wss://mainnet.helius-rpc.com/?api-key="
  8 | 
  9 | def parse_event_data(data_hex):
 10 |     try:
 11 |         data_bytes = bytes.fromhex(data_hex)
 12 |         offset = 8
 13 | 
 14 |         def read_length_prefixed_string(data, offset):
 15 |             try:
 16 |                 length = struct.unpack('<I', data[offset:offset + 4])[0]
 17 |                 offset += 4
 18 |                 string_data = data[offset:offset + length]
 19 |                 offset += length
 20 |                 return string_data.decode('utf-8').strip('\x00'), offset
 21 |             except Exception as e:
 22 |                 print(f"Error reading length-prefixed string: {e}")
 23 |                 raise
 24 | 
 25 |         def read_pubkey(data, offset):
 26 |             try:
 27 |                 pubkey_data = data[offset:offset + 32]
 28 |                 offset += 32
 29 |                 pubkey = str(Pubkey.from_bytes(pubkey_data))
 30 |                 return pubkey, offset
 31 |             except Exception as e:
 32 |                 print(f"Error reading pubkey: {e}")
 33 |                 raise
 34 | 
 35 |         event_data = {}
 36 |         event_data['name'], offset = read_length_prefixed_string(data_bytes, offset)
 37 |         event_data['symbol'], offset = read_length_prefixed_string(data_bytes, offset)
 38 |         event_data['uri'], offset = read_length_prefixed_string(data_bytes, offset)
 39 |         event_data['mint'], offset = read_pubkey(data_bytes, offset)
 40 |         event_data['bonding_curve'], offset = read_pubkey(data_bytes, offset)
 41 |         event_data['user'], offset = read_pubkey(data_bytes, offset)
 42 | 
 43 |         return event_data
 44 |     except Exception as e:
 45 |         print(f"Error parsing event data: {e}")
 46 |         raise
 47 | 
 48 | def on_message(ws, message):
 49 |     try:
 50 |         log_data = json.loads(message)
 51 |     except json.JSONDecodeError as e:
 52 |         print(f"JSON decode error: {e}")
 53 |         return
 54 | 
 55 |     logs = log_data.get("params", {}).get("result", {}).get("value", {}).get("logs", [])
 56 | 
 57 |     if "Instruction: InitializeMint2" in ''.join(logs):
 58 |         for log_entry in logs:
 59 |             if "Program data: " in log_entry and not log_entry.startswith("Program data: vdt/"):
 60 |                 try:
 61 |                     program_data_base64 = log_entry.split("Program data: ")[1]
 62 |                     program_data_bytes = base64.b64decode(program_data_base64)
 63 |                     program_data_hex = program_data_bytes.hex()
 64 |                 except Exception as e:
 65 |                     print(f"Error decoding base64 program data: {e}")
 66 |                     continue
 67 | 
 68 |                 try:
 69 |                     event_data = parse_event_data(program_data_hex)
 70 |                     event_data_json = json.dumps(event_data)
 71 |                     print(f"{event_data_json},")
 72 |                 except Exception as e:
 73 |                     print(f"Error processing event data: {e}")
 74 | 
 75 | def on_error(ws, error):
 76 |     print(f"WebSocket error: {error}")
 77 | 
 78 | def on_close(ws, close_status_code, close_msg):
 79 |     print("WebSocket connection closed")
 80 | 
 81 | def on_open(ws):
 82 |     request = {
 83 |         "jsonrpc": "2.0",
 84 |         "id": 1,
 85 |         "method": "logsSubscribe",
 86 |         "params": [
 87 |             {"mentions": ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"]},
 88 |             {"commitment": "processed"}
 89 |         ]
 90 |     }
 91 |     try:
 92 |         ws.send(json.dumps(request))
 93 |         print("Subscribed to logs...")
 94 |     except Exception as e:
 95 |         print(f"Error sending subscription request: {e}")
 96 | 
 97 | def start_websocket():
 98 |     ws = websocket.WebSocketApp(WSS,
 99 |                                 on_message=on_message,
100 |                                 on_error=on_error,
101 |                                 on_close=on_close)
102 |     ws.on_open = on_open
103 |     ws.run_forever()
104 | 
105 | if __name__ == "__main__":
106 |     try:
107 |         start_websocket()
108 |     except Exception as e:
109 |         print(f"Unexpected error in main event loop: {e}")
110 | 


--------------------------------------------------------------------------------
/pump_fun_ws/pf_trade_ws.py:
--------------------------------------------------------------------------------
  1 | import websocket
  2 | import json
  3 | import base64
  4 | from solders.pubkey import Pubkey  # type: ignore
  5 | from construct import Struct, Padding, Int64ul, Flag, Bytes
  6 | 
  7 | WSS = "wss://mainnet.helius-rpc.com/?api-key="
  8 | 
  9 | trade = Struct(
 10 |     Padding(8),
 11 |     "mint" / Bytes(32),
 12 |     "solAmount" / Int64ul,
 13 |     "tokenAmount" / Int64ul,
 14 |     "isBuy" / Flag,
 15 |     "user" / Bytes(32),
 16 |     "timestamp" / Int64ul,
 17 |     "virtualSolReserves" / Int64ul,
 18 |     "virtualTokenReserves" / Int64ul
 19 | )
 20 | 
 21 | def format_trade(parsed_data, txn_sig):
 22 |     try:
 23 |         return {
 24 |             "mint": str(Pubkey.from_bytes(bytes(parsed_data.mint))),
 25 |             "sol_amount": parsed_data.solAmount / 10**9,
 26 |             "token_amount": parsed_data.tokenAmount / 10**6,
 27 |             "is_buy": parsed_data.isBuy,
 28 |             "user": str(Pubkey.from_bytes(bytes(parsed_data.user))),
 29 |             "timestamp": parsed_data.timestamp,
 30 |             "virtual_sol_reserves": parsed_data.virtualSolReserves,
 31 |             "virtual_token_reserves": parsed_data.virtualTokenReserves,
 32 |             "txn_sig": txn_sig
 33 |         }
 34 |     except Exception as e:
 35 |         print(f"Error formatting trade data: {e}")
 36 |         return None
 37 | 
 38 | def on_message(ws, message):
 39 |     try:
 40 |         log_data = json.loads(message)
 41 |     except json.JSONDecodeError as e:
 42 |         print(f"JSON decode error: {e}")
 43 |         return
 44 | 
 45 |     try:
 46 |         result_value = log_data.get("params", {}).get("result", {}).get("value", {})
 47 |         txn_sig = result_value.get("signature", "")
 48 |         logs = result_value.get("logs", [])
 49 |     except Exception as e:
 50 |         print(f"Error extracting data from log response: {e}")
 51 |         return
 52 | 
 53 |     if "Program log: Instruction: Buy" in logs and "Program log: Instruction: Sell" not in logs:
 54 |         for log_entry in logs:
 55 |             if "Program data: vdt/" in log_entry:
 56 |                 try:
 57 |                     program_data_base64 = str(log_entry).split("Program data: ")[1]
 58 |                     program_data_bytes = base64.b64decode(program_data_base64)
 59 |                 except Exception as e:
 60 |                     print(f"Error decoding base64 program data: {e}")
 61 |                     continue
 62 | 
 63 |                 try:
 64 |                     parsed_data = trade.parse(program_data_bytes)
 65 |                     trade_data = format_trade(parsed_data, txn_sig)
 66 |                     if trade_data:
 67 |                         print(trade_data)
 68 |                 except Exception as e:
 69 |                     print(f"Error parsing or formatting trade data: {e}")
 70 | 
 71 | def on_error(ws, error):
 72 |     print(f"WebSocket error: {error}")
 73 | 
 74 | def on_close(ws, close_status_code, close_msg):
 75 |     print("WebSocket connection closed")
 76 | 
 77 | def on_open(ws):
 78 |     request = {
 79 |         "jsonrpc": "2.0",
 80 |         "id": 1,
 81 |         "method": "logsSubscribe",
 82 |         "params": [
 83 |             {"mentions": ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"]},
 84 |             {"commitment": "processed"}
 85 |         ]
 86 |     }
 87 |     try:
 88 |         ws.send(json.dumps(request))
 89 |         print("Subscribed to logs...")
 90 |     except Exception as e:
 91 |         print(f"Error sending subscription request: {e}")
 92 | 
 93 | def start_websocket():
 94 |     ws = websocket.WebSocketApp(WSS,
 95 |                                 on_message=on_message,
 96 |                                 on_error=on_error,
 97 |                                 on_close=on_close)
 98 |     ws.on_open = on_open
 99 |     ws.run_forever()
100 | 
101 | if __name__ == "__main__":
102 |     try:
103 |         start_websocket()
104 |     except Exception as e:
105 |         print(f"Unexpected error in main event loop: {e}")


--------------------------------------------------------------------------------
/pump_fun_ws/pump_swap_pool_ws.py:
--------------------------------------------------------------------------------
  1 | import websocket
  2 | import json
  3 | import base64
  4 | import time
  5 | from solders.pubkey import Pubkey  # type: ignore
  6 | from construct import Padding, Struct, Int64sl, Int16ul, Int8ul, Int64ul, Bytes
  7 | 
  8 | WSS = "wss://mainnet.helius-rpc.com/?api-key="
  9 | 
 10 | CREATE_POOL_EVENT_LAYOUT = Struct(
 11 |     Padding(8),
 12 |     "timestamp" / Int64sl,             # i64: signed 64-bit integer
 13 |     "index" / Int16ul,                 # u16: unsigned 16-bit integer
 14 |     "creator" / Bytes(32),             # pubkey: 32 bytes
 15 |     "base_mint" / Bytes(32),           # pubkey: 32 bytes
 16 |     "quote_mint" / Bytes(32),          # pubkey: 32 bytes
 17 |     "base_mint_decimals" / Int8ul,     # u8: unsigned 8-bit integer
 18 |     "quote_mint_decimals" / Int8ul,    # u8: unsigned 8-bit integer
 19 |     "base_amount_in" / Int64ul,        # u64: unsigned 64-bit integer
 20 |     "quote_amount_in" / Int64ul,       # u64: unsigned 64-bit integer
 21 |     "pool_base_amount" / Int64ul,      # u64: unsigned 64-bit integer
 22 |     "pool_quote_amount" / Int64ul,     # u64: unsigned 64-bit integer
 23 |     "minimum_liquidity" / Int64ul,     # u64: unsigned 64-bit integer
 24 |     "initial_liquidity" / Int64ul,     # u64: unsigned 64-bit integer
 25 |     "lp_token_amount_out" / Int64ul,   # u64: unsigned 64-bit integer
 26 |     "pool_bump" / Int8ul,              # u8: unsigned 8-bit integer
 27 |     "pool" / Bytes(32),                # pubkey: 32 bytes
 28 |     "lp_mint" / Bytes(32),             # pubkey: 32 bytes
 29 |     "user_base_token_account" / Bytes(32),   # pubkey: 32 bytes
 30 |     "user_quote_token_account" / Bytes(32)     # pubkey: 32 bytes
 31 | )
 32 | 
 33 | def decode_event(program_data_base64):
 34 |     try:
 35 |         parsed_data = CREATE_POOL_EVENT_LAYOUT.parse(base64.b64decode(program_data_base64))
 36 |         
 37 |         json_data = {
 38 |             "timestamp": parsed_data.timestamp,
 39 |             "index": parsed_data.index,
 40 |             "creator": str(Pubkey.from_bytes(parsed_data.creator)),
 41 |             "base_mint": str(Pubkey.from_bytes(parsed_data.base_mint)),
 42 |             "quote_mint": str(Pubkey.from_bytes(parsed_data.quote_mint)),
 43 |             "base_mint_decimals": parsed_data.base_mint_decimals,
 44 |             "quote_mint_decimals": parsed_data.quote_mint_decimals,
 45 |             "base_amount_in": parsed_data.base_amount_in,
 46 |             "quote_amount_in": parsed_data.quote_amount_in,
 47 |             "pool_base_amount": parsed_data.pool_base_amount,
 48 |             "pool_quote_amount": parsed_data.pool_quote_amount,
 49 |             "minimum_liquidity": parsed_data.minimum_liquidity,
 50 |             "initial_liquidity": parsed_data.initial_liquidity,
 51 |             "lp_token_amount_out": parsed_data.lp_token_amount_out,
 52 |             "pool_bump": parsed_data.pool_bump,
 53 |             "pool": str(Pubkey.from_bytes(parsed_data.pool)),
 54 |             "lp_mint": str(Pubkey.from_bytes(parsed_data.lp_mint)),
 55 |             "user_base_token_account": str(Pubkey.from_bytes(parsed_data.user_base_token_account)),
 56 |             "user_quote_token_account": str(Pubkey.from_bytes(parsed_data.user_quote_token_account))
 57 |         }
 58 |         return json_data
 59 |     except:
 60 |         return None
 61 | 
 62 | def on_message(ws, message):
 63 |     try:
 64 |         log_data = json.loads(message)
 65 |     except json.JSONDecodeError as e:
 66 |         print(f"JSON decode error: {e}")
 67 |         return
 68 | 
 69 |     logs = log_data.get("params", {}).get("result", {}).get("value", {}).get("logs", [])
 70 | 
 71 |     if "Program log: Instruction: CreatePool" in ''.join(logs):
 72 |         for log_entry in logs:
 73 |             if "Program data: " in log_entry:
 74 |                 try:
 75 |                     program_data_base64 = str(log_entry).split("Program data: ")[1]
 76 |                     print(program_data_base64)
 77 |                     event_data_json = decode_event(program_data_base64)
 78 |                     if event_data_json:
 79 |                         print(f"{event_data_json}")
 80 |                 except Exception as e:
 81 |                     print(f"Error processing event data: {e}")
 82 | 
 83 | def on_error(ws, error):
 84 |     print(f"WebSocket error: {error}")
 85 | 
 86 | def on_close(ws, close_status_code, close_msg):
 87 |     print("WebSocket connection closed")
 88 | 
 89 | def on_open(ws):
 90 |     request = {
 91 |         "jsonrpc": "2.0",
 92 |         "id": 1,
 93 |         "method": "logsSubscribe",
 94 |         "params": [
 95 |             {"mentions": ["pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"]},
 96 |             {"commitment": "processed"}
 97 |         ]
 98 |     }
 99 |     try:
100 |         ws.send(json.dumps(request))
101 |         print("Subscribed to logs...")
102 |     except Exception as e:
103 |         print(f"Error sending subscription request: {e}")
104 | 
105 | def start_websocket():
106 |     while True:
107 |         ws = websocket.WebSocketApp(WSS,
108 |                                     on_message=on_message,
109 |                                     on_error=on_error,
110 |                                     on_close=on_close)
111 |         ws.on_open = on_open
112 |         ws.run_forever()
113 |         print("WebSocket connection lost. Reconnecting in 1 second...")
114 |         time.sleep(1)
115 | 
116 | if __name__ == "__main__":
117 |     try:
118 |         start_websocket()
119 |     except Exception as e:
120 |         print(f"Unexpected error in main event loop: {e}")
121 | 


--------------------------------------------------------------------------------