Merge pull request #430 from kalloc/feat/pump-swap-update

feat: update pumpswap to 09.2025 update

Author: KellianDev

decoders/pump-swap-decoder/src/accounts/fee_config.rs

@@ -0,0 +1,17 @@
+use super::super::types::*;
+
+use carbon_core::{
+    borsh::{self, maybestd::vec::Vec},
+    CarbonDeserialize,
+};
+
+#[derive(
+    CarbonDeserialize, Debug, serde::Deserialize, serde::Serialize, PartialEq, Eq, Clone, Hash,
+)]
+#[carbon(discriminator = "0x8f3492bbdb7b4c9b")]
+pub struct FeeConfig {
+    pub bump: u8,
+    pub admin: solana_pubkey::Pubkey,
+    pub flat_fees: Fees,
+    pub fee_tiers: Vec<FeeTier>,
+}

decoders/pump-swap-decoder/src/accounts/mod.rs

@@ -5,13 +5,15 @@ use crate::PROGRAM_ID;
 
 use super::PumpSwapDecoder;
 pub mod bonding_curve;
+pub mod fee_config;
 pub mod global_config;
 pub mod global_volume_accumulator;
 pub mod pool;
 pub mod user_volume_accumulator;
 
 pub enum PumpSwapAccount {
     BondingCurve(bonding_curve::BondingCurve),
+    FeeConfig(fee_config::FeeConfig),
     GlobalConfig(global_config::GlobalConfig),
     GlobalVolumeAccumulator(global_volume_accumulator::GlobalVolumeAccumulator),
     Pool(pool::Pool),
@@ -40,6 +42,16 @@ impl AccountDecoder<'_> for PumpSwapDecoder {
             });
         }
 
+        if let Some(decoded_account) = fee_config::FeeConfig::deserialize(account.data.as_slice()) {
+            return Some(carbon_core::account::DecodedAccount {
+                lamports: account.lamports,
+                data: PumpSwapAccount::FeeConfig(decoded_account),
+                owner: account.owner,
+                executable: account.executable,
+                rent_epoch: account.rent_epoch,
+            });
+        }
+
         if let Some(decoded_account) =
             global_config::GlobalConfig::deserialize(account.data.as_slice())
         {

decoders/pump-swap-decoder/src/instructions/admin_update_token_incentives_event.rs

@@ -9,4 +9,7 @@ pub struct AdminUpdateTokenIncentivesEvent {
     pub end_time: i64,
     pub day_number: u64,
     pub token_supply_per_day: u64,
+    pub mint: solana_pubkey::Pubkey,
+    pub seconds_in_a_day: i64,
+    pub timestamp: i64,
 }

decoders/pump-swap-decoder/src/instructions/buy.rs

@@ -7,6 +7,7 @@ use carbon_core::{account_utils::next_account, borsh, CarbonDeserialize};
 pub struct Buy {
     pub base_amount_out: u64,
     pub max_quote_amount_in: u64,
+    pub track_volume: Option<bool>,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Hash, serde::Serialize, serde::Deserialize)]
@@ -32,6 +33,8 @@ pub struct BuyInstructionAccounts {
     pub coin_creator_vault_authority: solana_pubkey::Pubkey,
     pub global_volume_accumulator: solana_pubkey::Pubkey,
     pub user_volume_accumulator: solana_pubkey::Pubkey,
+    pub fee_config: solana_pubkey::Pubkey,
+    pub fee_program: solana_pubkey::Pubkey,
 }
 
 impl carbon_core::deserialize::ArrangeAccounts for Buy {
@@ -62,6 +65,8 @@ impl carbon_core::deserialize::ArrangeAccounts for Buy {
         let coin_creator_vault_authority = next_account(&mut iter)?;
         let global_volume_accumulator = next_account(&mut iter)?;
         let user_volume_accumulator = next_account(&mut iter)?;
+        let fee_config = next_account(&mut iter)?;
+        let fee_program = next_account(&mut iter)?;
 
         Some(BuyInstructionAccounts {
             pool,
@@ -85,6 +90,8 @@ impl carbon_core::deserialize::ArrangeAccounts for Buy {
             coin_creator_vault_authority,
             global_volume_accumulator,
             user_volume_accumulator,
+            fee_config,
+            fee_program,
         })
     }
 }

decoders/pump-swap-decoder/src/instructions/buy_event.rs

@@ -28,4 +28,9 @@ pub struct BuyEvent {
     pub coin_creator: solana_pubkey::Pubkey,
     pub coin_creator_fee_basis_points: u64,
     pub coin_creator_fee: u64,
+    pub track_volume: bool,
+    pub total_unclaimed_tokens: u64,
+    pub total_claimed_tokens: u64,
+    pub current_sol_volume: u64,
+    pub last_update_timestamp: i64,
 }

decoders/pump-swap-decoder/src/instructions/claim_token_incentives_event.rs

@@ -8,4 +8,7 @@ pub struct ClaimTokenIncentivesEvent {
     pub user: solana_pubkey::Pubkey,
     pub mint: solana_pubkey::Pubkey,
     pub amount: u64,
+    pub timestamp: i64,
+    pub total_claimed_tokens: u64,
+    pub current_sol_volume: u64,
 }

decoders/pump-swap-decoder/src/instructions/close_user_volume_accumulator.rs

@@ -0,0 +1,36 @@
+use carbon_core::{account_utils::next_account, borsh, CarbonDeserialize};
+
+#[derive(
+    CarbonDeserialize, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Clone, Hash,
+)]
+#[carbon(discriminator = "0xf945a4da9667548a")]
+pub struct CloseUserVolumeAccumulator {}
+
+#[derive(Debug, PartialEq, Eq, Clone, Hash, serde::Serialize, serde::Deserialize)]
+pub struct CloseUserVolumeAccumulatorInstructionAccounts {
+    pub user: solana_pubkey::Pubkey,
+    pub user_volume_accumulator: solana_pubkey::Pubkey,
+    pub event_authority: solana_pubkey::Pubkey,
+    pub program: solana_pubkey::Pubkey,
+}
+
+impl carbon_core::deserialize::ArrangeAccounts for CloseUserVolumeAccumulator {
+    type ArrangedAccounts = CloseUserVolumeAccumulatorInstructionAccounts;
+
+    fn arrange_accounts(
+        accounts: &[solana_instruction::AccountMeta],
+    ) -> Option<Self::ArrangedAccounts> {
+        let mut iter = accounts.iter();
+        let user = next_account(&mut iter)?;
+        let user_volume_accumulator = next_account(&mut iter)?;
+        let event_authority = next_account(&mut iter)?;
+        let program = next_account(&mut iter)?;
+
+        Some(CloseUserVolumeAccumulatorInstructionAccounts {
+            user,
+            user_volume_accumulator,
+            event_authority,
+            program,
+        })
+    }
+}

decoders/pump-swap-decoder/src/instructions/close_user_volume_accumulator_event.rs

@@ -0,0 +1,14 @@
+use carbon_core::{borsh, CarbonDeserialize};
+
+#[derive(
+    CarbonDeserialize, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Clone, Hash,
+)]
+#[carbon(discriminator = "0xe445a52e51cb9a1d929fbdac925838f4")]
+pub struct CloseUserVolumeAccumulatorEvent {
+    pub user: solana_pubkey::Pubkey,
+    pub timestamp: i64,
+    pub total_unclaimed_tokens: u64,
+    pub total_claimed_tokens: u64,
+    pub current_sol_volume: u64,
+    pub last_update_timestamp: i64,
+}

decoders/pump-swap-decoder/src/instructions/init_user_volume_accumulator.rs

@@ -0,0 +1,42 @@
+use carbon_core::{account_utils::next_account, borsh, CarbonDeserialize};
+
+#[derive(
+    CarbonDeserialize, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Clone, Hash,
+)]
+#[carbon(discriminator = "0x5e06ca73ff60e8b7")]
+pub struct InitUserVolumeAccumulator {}
+
+#[derive(Debug, PartialEq, Eq, Clone, Hash, serde::Serialize, serde::Deserialize)]
+pub struct InitUserVolumeAccumulatorInstructionAccounts {
+    pub payer: solana_pubkey::Pubkey,
+    pub user: solana_pubkey::Pubkey,
+    pub user_volume_accumulator: solana_pubkey::Pubkey,
+    pub system_program: solana_pubkey::Pubkey,
+    pub event_authority: solana_pubkey::Pubkey,
+    pub program: solana_pubkey::Pubkey,
+}
+
+impl carbon_core::deserialize::ArrangeAccounts for InitUserVolumeAccumulator {
+    type ArrangedAccounts = InitUserVolumeAccumulatorInstructionAccounts;
+
+    fn arrange_accounts(
+        accounts: &[solana_instruction::AccountMeta],
+    ) -> Option<Self::ArrangedAccounts> {
+        let mut iter = accounts.iter();
+        let payer = next_account(&mut iter)?;
+        let user = next_account(&mut iter)?;
+        let user_volume_accumulator = next_account(&mut iter)?;
+        let system_program = next_account(&mut iter)?;
+        let event_authority = next_account(&mut iter)?;
+        let program = next_account(&mut iter)?;
+
+        Some(InitUserVolumeAccumulatorInstructionAccounts {
+            payer,
+            user,
+            user_volume_accumulator,
+            system_program,
+            event_authority,
+            program,
+        })
+    }
+}

decoders/pump-swap-decoder/src/instructions/init_user_volume_accumulator_event.rs

@@ -0,0 +1,11 @@
+use carbon_core::{borsh, CarbonDeserialize};
+
+#[derive(
+    CarbonDeserialize, Debug, serde::Serialize, serde::Deserialize, PartialEq, Eq, Clone, Hash,
+)]
+#[carbon(discriminator = "0xe445a52e51cb9a1d86240d48e86582d8")]
+pub struct InitUserVolumeAccumulatorEvent {
+    pub payer: solana_pubkey::Pubkey,
+    pub user: solana_pubkey::Pubkey,
+    pub timestamp: i64,
+}