docs: remove token creation sections

src/ipfs/mod.rs

@@ -1,161 +0,0 @@
-use std::time::Duration;
-
-use serde_json::Value;
-use tokio::fs::File;
-use tokio::io::AsyncReadExt;
-use reqwest::Client;
-use reqwest::multipart::{Form, Part};
-use base64::{Engine as _, engine::general_purpose};
-use serde::{Deserialize, Serialize};
-
-/// Metadata structure for a token, matching the format expected by Pump.fun.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TokenMetadata {
-    /// Name of the token
-    pub name: String,
-    /// Token symbol (e.g. "BTC")
-    pub symbol: String,
-    /// Description of the token
-    pub description: String,
-    /// IPFS URL of the token's image
-    pub image: String,
-    /// Whether to display the token's name
-    pub show_name: bool,
-    /// Creation timestamp/source
-    pub created_on: String,
-    /// Twitter handle
-    pub twitter: Option<String>,
-    /// Telegram handle
-    pub telegram: Option<String>,
-    /// Website URL
-    pub website: Option<String>,
-}
-
-/// Response received after successfully uploading token metadata.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TokenMetadataIPFS {
-    /// The uploaded token metadata
-    pub metadata: TokenMetadata,
-    /// IPFS URI where the metadata is stored
-    pub metadata_uri: String,
-}
-
-/// Parameters for creating new token metadata.
-#[derive(Debug, Clone)]
-pub struct CreateTokenMetadata {
-    /// Name of the token
-    pub name: String,
-    /// Token symbol (e.g. "BTC")
-    pub symbol: String,
-    /// Description of the token
-    pub description: String,
-    /// Path to the token's image file
-    pub file: String,
-    /// Optional Twitter handle
-    pub twitter: Option<String>,
-    /// Optional Telegram group
-    pub telegram: Option<String>,
-    /// Optional website URL
-    pub website: Option<String>,
-
-    pub metadata_uri: Option<String>,
-}
-
-pub async fn create_token_metadata(metadata: CreateTokenMetadata, api_token: &str) -> Result<TokenMetadataIPFS, anyhow::Error> {
-    let ipfs_url = if metadata.file.starts_with("http") || metadata.metadata_uri.is_some() {
-        metadata.file
-    } else {
-        let base64_string = file_to_base64(&metadata.file).await?;
-        upload_base64_file(&base64_string, api_token).await?
-    };
-
-    let token_metadata = TokenMetadata {
-        name: metadata.name,
-        symbol: metadata.symbol,
-        description: metadata.description,
-        image: ipfs_url,
-        show_name: true,
-        created_on: "https://pump.fun".to_string(),
-        twitter: metadata.twitter,
-        telegram: metadata.telegram,
-        website: metadata.website,
-    };
-
-    if metadata.metadata_uri.is_some() {
-        let token_metadata_ipfs = TokenMetadataIPFS {
-            metadata: token_metadata,
-            metadata_uri: metadata.metadata_uri.unwrap(),
-        };  
-        Ok(token_metadata_ipfs)
-    } else {
-        let client = Client::new();
-        let response = client
-            .post("https://api.pinata.cloud/pinning/pinJSONToIPFS")
-            .header("Content-Type", "application/json")
-            .header("Authorization", format!("Bearer {}", api_token))
-            .json(&token_metadata)
-        .send()
-        .await?;
-
-        // 确保请求成功
-        if response.status().is_success() {
-            let res_data: serde_json::Value = response.json().await?;
-            let ipfs_hash = res_data["IpfsHash"].as_str().unwrap();
-            let ipfs_url = format!("https://ipfs.io/ipfs/{}", ipfs_hash);
-            let token_metadata_ipfs = TokenMetadataIPFS {
-                metadata: token_metadata,
-                metadata_uri: ipfs_url,
-            };  
-            Ok(token_metadata_ipfs)
-        } else {
-            eprintln!("Error: {:?}", response.text().await?);
-            Err(anyhow::anyhow!("Failed to create token metadata"))
-        }
-    }
-}
-
-pub async fn upload_base64_file(base64_string: &str, api_token: &str) -> Result<String, anyhow::Error> {
-    let decoded_bytes = general_purpose::STANDARD.decode(base64_string)?;
-
-    let client = Client::builder()
-        .timeout(Duration::from_secs(120))  // 增加超时时间到120秒
-        .pool_max_idle_per_host(0) // 禁用连接池
-        .pool_idle_timeout(None) // 禁用空闲超时
-        .build()?;
-
-    let part = Part::bytes(decoded_bytes)
-        .file_name("file.png") // 添加文件扩展名
-        .mime_str("image/png")?; // 指定正确的MIME类型
-
-    let form = Form::new().part("file", part);
-
-    let response = client
-        .post("https://api.pinata.cloud/pinning/pinFileToIPFS")
-        .header("Authorization", format!("Bearer {}", api_token))
-        .header("Accept", "application/json")
-        .multipart(form)
-        .send()
-        .await?;
-
-    if response.status().is_success() {
-        let response_json: Value = response.json().await.map_err(|e| anyhow::anyhow!("Failed to parse JSON: {}", e))?;  
-        println!("{:#?}", response_json);
-        let ipfs_hash = response_json["IpfsHash"].as_str().unwrap();
-        let ipfs_url = format!("https://ipfs.io/ipfs/{}", ipfs_hash);
-        Ok(ipfs_url)
-    } else {
-        let error_text = response.text().await?;
-        eprintln!("Error: {:?}", error_text);
-        Err(anyhow::anyhow!("Failed to upload file to IPFS: {}", error_text))
-    }
-}
-
-async fn file_to_base64(file_path: &str) -> Result<String, anyhow::Error> {
-    let mut file = File::open(file_path).await?;
-    let mut buffer = Vec::new();
-    file.read_to_end(&mut buffer).await?;
-    let base64_string = general_purpose::STANDARD.encode(&buffer);
-    Ok(base64_string)
-}

src/lib.rs

@@ -4,7 +4,6 @@ pub mod error;
 pub mod instruction;
 pub mod grpc;
 pub mod common;
-pub mod ipfs;
 pub mod swqos;
 pub mod pumpfun;
 pub mod pumpswap;
@@ -24,7 +23,6 @@ use solana_sdk::{
 
 use common::{pumpfun::logs_data::TradeInfo, pumpfun::logs_events::PumpfunEvent, pumpfun::logs_subscribe, Cluster, PriorityFee, SolanaRpcClient};
 use common::pumpfun::logs_subscribe::SubscriptionHandle;
-use ipfs::TokenMetadataIPFS;
 
 use constants::trade_type::{COPY_BUY, SNIPER_BUY};
 use constants::trade_platform::{PUMPFUN, PUMPFUN_SWAP, RAYDIUM};
@@ -145,63 +143,6 @@ impl SolanaTrade {
         let instance = INSTANCE.lock().unwrap();
         instance.as_ref().expect("PumpFun instance not initialized. Please call new() first.").clone()
     }
-
-    /// Create a new token
-    pub async fn create(
-        &self,
-        mint: Keypair,
-        ipfs: TokenMetadataIPFS,
-    ) -> Result<(), anyhow::Error> {
-        pumpfun::create::create(
-            self.rpc.clone(),
-            self.payer.clone(),
-            mint,
-            ipfs,
-            self.priority_fee.clone(),
-        ).await 
-    }
-
-    pub async fn create_and_buy(
-        &self,
-        mint: Keypair,
-        ipfs: TokenMetadataIPFS,
-        amount_sol: u64,
-        slippage_basis_points: Option<u64>,
-        recent_blockhash: Hash,
-    ) -> Result<(), anyhow::Error> {
-        pumpfun::create::create_and_buy(
-            self.rpc.clone(),
-            self.payer.clone(),
-            mint,
-            ipfs,
-            amount_sol,
-            slippage_basis_points,
-            self.priority_fee.clone(),
-            recent_blockhash,
-        ).await
-    }
-
-    pub async fn create_and_buy_with_tip(
-        &self,
-        payer: Arc<Keypair>, 
-        mint: Keypair,
-        ipfs: TokenMetadataIPFS,
-        buy_sol_cost: u64,
-        slippage_basis_points: Option<u64>,
-        recent_blockhash: Hash,
-    ) -> Result<(), anyhow::Error> { 
-        pumpfun::create::create_and_buy_with_tip(
-            self.rpc.clone(),
-            self.fee_clients.clone(),
-            payer,
-            mint,
-            ipfs,
-            buy_sol_cost,
-            slippage_basis_points,
-            self.priority_fee.clone(),
-            recent_blockhash,
-        ).await
-    }
     
     /// Buy tokens
     pub async fn sniper_buy(

src/pumpfun/create.rs

@@ -1,238 +0,0 @@
-use std::{str::FromStr, time::Instant, sync::Arc};
-
-use anyhow::anyhow;
-use solana_hash::Hash;
-use solana_sdk::{
-    compute_budget::ComputeBudgetInstruction, 
-    instruction::Instruction, message::{v0, VersionedMessage}, 
-    pubkey::Pubkey, 
-    native_token::sol_to_lamports, 
-    signature::Keypair, 
-    signer::Signer, 
-    system_instruction, 
-    transaction::{Transaction, VersionedTransaction}
-};
-use spl_associated_token_account::instruction::create_associated_token_account;
-
-use crate::{
-    common::{PriorityFee, SolanaRpcClient}, constants, instruction, 
-    ipfs::TokenMetadataIPFS,  swqos::{FeeClient, TradeType},
-};
-
-use crate::pumpfun::common::{
-    create_priority_fee_instructions, 
-    get_buy_amount_with_slippage, get_global_account
-};
-
-use crate::common::tip_cache::TipCache;
-
-use super::common::{get_bonding_curve_account, get_buy_token_amount, get_creator_vault_pda};
-
-/// Create a new token
-pub async fn create(
-    rpc: Arc<SolanaRpcClient>,
-    payer: Arc<Keypair>,
-    mint: Keypair,
-    ipfs: TokenMetadataIPFS,
-    priority_fee: PriorityFee,
-) -> Result<(), anyhow::Error> {
-    let mut instructions = create_priority_fee_instructions(priority_fee);
-
-    instructions.push(instruction::create(
-        payer.as_ref(),
-        &mint,
-        instruction::Create {
-            _name: ipfs.metadata.name,
-            _symbol: ipfs.metadata.symbol,
-            _uri: ipfs.metadata_uri,
-            _creator: payer.pubkey(),
-        },
-    ));
-
-    let recent_blockhash = rpc.get_latest_blockhash().await?;
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &[payer.as_ref(), &mint],
-        recent_blockhash,
-    );
-
-    rpc.send_and_confirm_transaction(&transaction).await?;
-
-    Ok(())
-}
-
-/// Create and buy tokens in one transaction
-pub async fn create_and_buy(
-    rpc: Arc<SolanaRpcClient>,
-    payer: Arc<Keypair>,
-    mint: Keypair,
-    ipfs: TokenMetadataIPFS,
-    buy_sol_cost: u64,
-    slippage_basis_points: Option<u64>,
-    priority_fee: PriorityFee,
-    recent_blockhash: Hash,
-) -> Result<(), anyhow::Error> {
-    if buy_sol_cost == 0 {
-        return Err(anyhow!("Amount cannot be zero"));
-    }
-
-    let mint = Arc::new(mint);
-    let transaction = build_create_and_buy_transaction(rpc.clone(), payer.clone(), mint.clone(), ipfs, buy_sol_cost, slippage_basis_points, priority_fee.clone(), recent_blockhash).await?;
-    rpc.send_and_confirm_transaction(&transaction).await?;
-
-    Ok(())
-}
-
-pub async fn create_and_buy_with_tip(
-    rpc: Arc<SolanaRpcClient>,
-    fee_clients: Vec<Arc<FeeClient>>,
-    payer: Arc<Keypair>,
-    mint: Keypair,
-    ipfs: TokenMetadataIPFS,
-    buy_sol_cost: u64,
-    slippage_basis_points: Option<u64>,
-    priority_fee: PriorityFee,
-    recent_blockhash: Hash,
-) -> Result<(), anyhow::Error> {
-    let start_time = Instant::now();
-    let mint = Arc::new(mint);
-    let build_instructions = build_create_and_buy_instructions(rpc.clone(), payer.clone(), mint.clone(), ipfs.clone(), buy_sol_cost, slippage_basis_points).await?;
-    let mut handles = vec![];
-    for fee_client in fee_clients {
-        let tip_account = fee_client.get_tip_account()?;
-        let tip_account = Arc::new(Pubkey::from_str(&tip_account).map_err(|e| anyhow!(e))?);
-        let transaction = build_create_and_buy_transaction_with_tip(/*rpc.clone(),*/ tip_account, payer.clone(), priority_fee.clone(), build_instructions.clone(), recent_blockhash).await?;
-        let handle = tokio::spawn(async move {    
-            fee_client.send_transaction(TradeType::CreateAndBuy, &transaction).await.map_err(|e| anyhow!(e.to_string()))?;
-            println!("Total Jito create and buy operation time: {:?}ms", start_time.elapsed().as_millis());
-            Ok::<(), anyhow::Error>(())
-        });
-
-        handles.push(handle);
-    }
-
-    for handle in handles {
-        match handle.await {
-            Ok(Ok(_)) => (),
-            Ok(Err(e)) => println!("Error in task: {}", e),
-            Err(e) => println!("Task join error: {}", e),
-        }
-    }
-
-    Ok(())
-}
-
-pub async fn build_create_and_buy_transaction(
-    rpc: Arc<SolanaRpcClient>,
-    payer: Arc<Keypair>,
-    mint: Arc<Keypair>,
-    ipfs: TokenMetadataIPFS,
-    buy_sol_cost: u64,
-    slippage_basis_points: Option<u64>,
-    priority_fee: PriorityFee,
-    recent_blockhash: Hash,
-) -> Result<Transaction, anyhow::Error> {
-    let mut instructions = vec![
-        ComputeBudgetInstruction::set_compute_unit_price(priority_fee.unit_price),
-        ComputeBudgetInstruction::set_compute_unit_limit(priority_fee.unit_limit),
-    ];
-
-    let build_instructions = build_create_and_buy_instructions(rpc.clone(), payer.clone(), mint.clone(), ipfs, buy_sol_cost, slippage_basis_points).await?;
-    instructions.extend(build_instructions);
-
-    // let recent_blockhash = rpc.get_latest_blockhash().await?;
-    // let recent_blockhash = Hash::default();
-    let transaction = Transaction::new_signed_with_payer(
-        &instructions,
-        Some(&payer.pubkey()),
-        &[payer.as_ref(), mint.as_ref()],
-        recent_blockhash,
-    );
-
-    Ok(transaction)
-}
-
-pub async fn build_create_and_buy_transaction_with_tip(
-    // rpc: Arc<SolanaRpcClient>,
-    tip_account: Arc<Pubkey>,
-    payer: Arc<Keypair>,
-    priority_fee: PriorityFee,  
-    build_instructions: Vec<Instruction>,
-    recent_blockhash: Hash,
-) -> Result<VersionedTransaction, anyhow::Error> {
-    let tip_cache = TipCache::get_instance();
-    let tip_amount = tip_cache.get_tip();
-
-    let mut instructions = vec![
-        ComputeBudgetInstruction::set_compute_unit_price(priority_fee.unit_price),
-        ComputeBudgetInstruction::set_compute_unit_limit(priority_fee.unit_limit),
-        system_instruction::transfer(
-            &payer.pubkey(),
-            &tip_account,
-            sol_to_lamports(tip_amount),
-        ),
-    ];
-    instructions.extend(build_instructions);
-
-    // let recent_blockhash = rpc.get_latest_blockhash().await?;
-    // let recent_blockhash = Hash::default();
-    let v0_message: v0::Message =
-        v0::Message::try_compile(&payer.pubkey(), &instructions, &[], recent_blockhash)?;
-    
-    let versioned_message: VersionedMessage = VersionedMessage::V0(v0_message);
-    let transaction = VersionedTransaction::try_new(versioned_message, &[&payer])?;
-
-    Ok(transaction)
-}
-
-pub async fn build_create_and_buy_instructions(
-    rpc: Arc<SolanaRpcClient>,
-    payer: Arc<Keypair>,
-    mint: Arc<Keypair>,
-    ipfs: TokenMetadataIPFS,
-    buy_sol_cost: u64,
-    slippage_basis_points: Option<u64>,
-) -> Result<Vec<Instruction>, anyhow::Error> {
-    if buy_sol_cost == 0 {
-        return Err(anyhow!("Amount cannot be zero"));
-    }
-
-    let (bonding_curve_account, bonding_curve_pda) = get_bonding_curve_account(&rpc, &mint.pubkey()).await?;
-    let creator_vault_pda = get_creator_vault_pda(&bonding_curve_account.creator).unwrap();
-    let (buy_token_amount, max_sol_cost) = get_buy_token_amount(&bonding_curve_account, buy_sol_cost, slippage_basis_points)?;
-
-    let mut instructions = vec![];
-
-    instructions.push(instruction::create(
-        payer.as_ref(),
-        mint.as_ref(),
-        instruction::Create {
-            _name: ipfs.metadata.name.clone(),
-            _symbol: ipfs.metadata.symbol.clone(),
-            _uri: ipfs.metadata_uri.clone(),
-            _creator: payer.pubkey(),
-        },
-    ));
-
-    instructions.push(create_associated_token_account(
-        &payer.pubkey(),
-        &payer.pubkey(),
-        &mint.pubkey(),
-        &constants::pumpfun::accounts::TOKEN_PROGRAM,
-    ));
-
-    instructions.push(instruction::buy(
-        payer.as_ref(),
-        &mint.pubkey(),
-        &bonding_curve_pda,
-        &creator_vault_pda,
-        &constants::pumpfun::global_constants::FEE_RECIPIENT,
-        instruction::Buy {
-            _amount: buy_token_amount,
-            _max_sol_cost: max_sol_cost,
-        },
-    ));
-
-    Ok(instructions)
-}

src/pumpfun/mod.rs

@@ -1,4 +1,3 @@
 pub mod buy;
-pub mod create;
 pub mod sell;
 pub mod common;