Launch SPL Tokens on Solana with Pump.fun

This Python script provides functionality to launch custom SPL tokens on the Solana blockchain through Pump.fun, a platform that enables the creation and management of tokens.

Key Components

  1. Metadata Upload

  2. Transaction Creation

  3. Token Launch Process

Detailed Breakdown

  1. Uploading Token Metadata

    The _upload_metadata function handles the uploading of token metadata to the IPFS through Pump.fun. The metadata includes the token's name, ticker, description, and image URL. If additional options (such as social media links) are provided, they are included in the metadata upload.

    Copy

    async def _upload_metadata(
    session: aiohttp.ClientSession,
    token_name: str,
    token_ticker: str,
    description: str,
    image_url: str,
    options: Optional[PumpfunTokenOptions] = None
) -> Dict[str, Any]:

    • Form Data: This method forms the required data for metadata upload, which includes the token’s basic information, image, and any optional social media URLs.

    • Image Download: The image for the token is downloaded from the provided URL.

    • IPFS Upload: The metadata and image are uploaded to Pump.fun's IPFS endpoint.

    • Response: On successful upload, it returns the metadata response, including the metadata URI.

  2. Creating the Token Transaction

    The _create_token_transaction function prepares a transaction for minting the token on the Solana blockchain through Pump.fun. The transaction includes the token's metadata and minting information.

    Copy

    async def _create_token_transaction(
    session: aiohttp.ClientSession,
    agent: SolanaAgentKit,
    mint_keypair: Keypair,
    metadata_response: Dict[str, Any],
    options: Optional[PumpfunTokenOptions] = None
) -> bytes:

    • Transaction Payload: The payload for the transaction is built using the agent’s wallet address, mint keypair, and metadata URI.

    • Transaction Request: A request is made to the Pump.fun API to create the transaction.

    • Serialized Transaction: The transaction is returned as serialized data that can be signed and sent to the network.

  3. Launching the Token

    The launch_pumpfun_token method orchestrates the process of launching a token. It includes uploading metadata, creating the transaction, and then signing and sending the transaction to the Solana network.

    Copy

    async def launch_pumpfun_token(
    agent: SolanaAgentKit,
    token_name: str,
    token_ticker: str,
    description: str,
    image_url: str,
    options: Optional[PumpfunTokenOptions] = None
) -> TokenLaunchResult:

    • Mint Keypair: A new mint keypair is generated for the token.

    • Metadata Upload: Calls _upload_metadata to upload the token's metadata to IPFS.

    • Transaction Creation: Calls _create_token_transaction to create the token transaction.

    • Transaction Signing: The transaction is signed using the mint keypair and sent to the Solana network via sign_and_send_transaction.

    Result: The method returns a TokenLaunchResult containing the transaction signature, mint address, and metadata URI.

Helper Functions

  1. fix_asyncio_for_windows() This function is used to ensure compatibility of asynchronous tasks when running on Windows. It fixes an issue with the default event loop on Windows machines that might otherwise result in an asyncio exception.

  2. sign_and_send_transaction() This function handles signing and sending the token transaction to the Solana blockchain. It is critical for the final step in the token launch process.

Example Usage

Below is an example of how to use the PumpfunTokenManager to launch a new token:

Copy

from solana.rpc.async_api import AsyncClient
from Kaze.agent import SolanaAgentKit

# Initialize the agent and other parameters
agent = SolanaAgentKit(client=AsyncClient("https://api.mainnet-beta.solana.com"))
token_name = "MyNewToken"
token_ticker = "MNTK"
description = "This is a test token."
image_url = "https://example.com/token_image.png"

# Optional: Provide additional configuration options
options = PumpfunTokenOptions(
    initial_liquidity_sol=1.0,  # Amount of SOL for initial liquidity
    slippage_bps=100,           # Slippage in basis points (1% = 100)
    priority_fee=50000          # Priority fee in lamports
)

# Launch the token
launch_result = await PumpfunTokenManager.launch_pumpfun_token(
    agent,
    token_name,
    token_ticker,
    description,
    image_url,
    options
)

# Print the launch result
print(f"Token launched successfully! Mint address: {launch_result.mint}")
print(f"Transaction signature: {launch_result.signature}")

Error Handling

The code handles various exceptions during the token launch process:

  • Metadata Upload: If the metadata upload fails (e.g., image download or IPFS upload), it raises an error.

  • Transaction Creation: If creating the transaction via the Pump.fun API fails, an exception is raised with the relevant error message.

  • Transaction Signing: If the transaction fails during signing or submission to the Solana network, the exception is caught, and an appropriate error message is logged.

Example of error handling:

Copy

except Exception as error:
    logger.error(f"Error in launch_pumpfun_token: {error}")
    raise

Key Features

  • IPFS Metadata Upload: Upload token metadata (name, symbol, description, image) to IPFS.

  • Transaction Creation: Create and serialize the minting transaction for a new token.

  • Customizable Options: Allow customization of initial liquidity, slippage, and priority fees for the token launch.

  • Solana Integration: Full integration with Solana blockchain for minting and token management.

  • Error Logging: Detailed logging and error handling throughout the process.

PreviousIntroduction

Last updated