refactor: split into protocol-zap and zap-sdk

Author: bangyro

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-members = ["programs/*", "libs/*", "zap-sdk"]
+members = ["programs/*", "libs/*", "zap-sdk", "protocol-zap"]
 resolver = "2"
 
 [profile.release]

Cargo.toml

@@ -8,13 +8,10 @@ use zap_sdk::constants::{
 
 #[constant]
 pub const WHITELISTED_AMM_PROGRAMS: [(Pubkey, [u8; 8]); 4] = [
-    (Pubkey::new_from_array(DAMM_V2), DAMM_V2_SWAP_DISC),
-    (Pubkey::new_from_array(DLMM), DLMM_SWAP2_DISC),
-    (Pubkey::new_from_array(JUP_V6), JUP_V6_ROUTE_DISC),
-    (
-        Pubkey::new_from_array(JUP_V6),
-        JUP_V6_SHARED_ACCOUNT_ROUTE_DISC,
-    ),
+    (DAMM_V2, DAMM_V2_SWAP_DISC),
+    (DLMM, DLMM_SWAP2_DISC),
+    (JUP_V6, JUP_V6_ROUTE_DISC),
+    (JUP_V6, JUP_V6_SHARED_ACCOUNT_ROUTE_DISC),
 ];
 
 #[constant]

programs/zap/src/constants.rs

@@ -0,0 +1,14 @@
+[package]
+name = "protocol-zap"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+borsh = "0.10"
+jupiter = { path = "../libs/jupiter" }
+ruint = { workspace = true }
+num_enum = "0.7"
+pinocchio = "0.9"
+pinocchio-pubkey = "0.3"
+thiserror = "2"
+zap-sdk = { path = "../zap-sdk" }

protocol-zap/Cargo.toml

@@ -0,0 +1,32 @@
+use pinocchio::pubkey::Pubkey;
+use pinocchio_pubkey::pubkey;
+
+pub const JUP_V6_SHARED_ACCOUNT_ROUTE_AMOUNT_IN_REVERSE_OFFSET: usize = 1 + 2 + 8 + 8; // Due to jupiter parameters have dynamic length type (vec), we have to do parameters_data.length - JUP_V6_SHARED_ACCOUNT_ROUTE_AMOUNT_IN_REVERSE_OFFSET
+pub const JUP_V6_SHARED_ACCOUNT_ROUTE_SOURCE_ACCOUNT_INDEX: usize = 3;
+pub const JUP_V6_SHARED_ACCOUNT_ROUTE_DESTINATION_ACCOUNT_INDEX: usize = 6;
+
+pub const JUP_V6_ROUTE_AMOUNT_IN_REVERSE_OFFSET: usize = 1 + 2 + 8 + 8;
+pub const JUP_V6_ROUTE_SOURCE_ACCOUNT_INDEX: usize = 2;
+pub const JUP_V6_ROUTE_DESTINATION_ACCOUNT_INDEX: usize = 4;
+
+pub const DLMM_SWAP2_AMOUNT_IN_OFFSET: u16 = 8;
+pub const DLMM_SWAP2_SOURCE_ACCOUNT_INDEX: usize = 4;
+pub const DLMM_SWAP2_DESTINATION_ACCOUNT_INDEX: usize = 5;
+
+pub const DAMM_V2_SWAP_AMOUNT_IN_OFFSET: u16 = 8;
+pub const DAMM_V2_SWAP_SOURCE_ACCOUNT_INDEX: usize = 2;
+pub const DAMM_V2_SWAP_DESTINATION_ACCOUNT_INDEX: usize = 3;
+
+pub const ZAP: Pubkey = pubkey!("zapvX9M3uf5pvy4wRPAbQgdQsM1xmuiFnkfHKPvwMiz");
+pub const ZAP_OUT_DISC: [u8; 8] = [155, 108, 185, 112, 104, 210, 161, 64];
+
+pub const USDC_ADDRESS: Pubkey = pubkey!("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+
+pub const SOL_ADDRESS: Pubkey = pubkey!("So11111111111111111111111111111111111111112");
+
+pub const MINTS_DISALLOWED_TO_ZAP_OUT: [Pubkey; 2] = [USDC_ADDRESS, SOL_ADDRESS];
+
+pub const SPL_TOKEN_PROGRAM_ID: Pubkey = pubkey!("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+
+pub const SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID: Pubkey =
+    pubkey!("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");

protocol-zap/src/constants.rs

@@ -3,21 +3,21 @@ use crate::{
         DAMM_V2_SWAP_AMOUNT_IN_OFFSET, DAMM_V2_SWAP_DESTINATION_ACCOUNT_INDEX,
         DAMM_V2_SWAP_SOURCE_ACCOUNT_INDEX,
     },
-    error::ZapSdkError,
+    error::ProtozolZapError,
     RawZapOutAmmInfo, ZapInfoProcessor, ZapOutParameters,
 };
 
 pub struct ZapDammV2InfoProcessor;
 
 impl ZapInfoProcessor for ZapDammV2InfoProcessor {
-    fn validate_payload(&self, _payload: &[u8]) -> Result<(), ZapSdkError> {
+    fn validate_payload(&self, _payload: &[u8]) -> Result<(), ProtozolZapError> {
         Ok(())
     }
 
     fn extract_raw_zap_out_amm_info(
         &self,
         _zap_params: &ZapOutParameters,
-    ) -> Result<RawZapOutAmmInfo, ZapSdkError> {
+    ) -> Result<RawZapOutAmmInfo, ProtozolZapError> {
         Ok(RawZapOutAmmInfo {
             source_index: DAMM_V2_SWAP_SOURCE_ACCOUNT_INDEX,
             destination_index: DAMM_V2_SWAP_DESTINATION_ACCOUNT_INDEX,

zap-sdk/src/damm_v2_zap.rs protocol-zap/src/damm_v2_zap.rszap-sdk/src/damm_v2_zap.rs renamed to protocol-zap/src/damm_v2_zap.rs

@@ -3,21 +3,21 @@ use crate::{
         DLMM_SWAP2_AMOUNT_IN_OFFSET, DLMM_SWAP2_DESTINATION_ACCOUNT_INDEX,
         DLMM_SWAP2_SOURCE_ACCOUNT_INDEX,
     },
-    error::ZapSdkError,
+    error::ProtozolZapError,
     RawZapOutAmmInfo, ZapInfoProcessor, ZapOutParameters,
 };
 
 pub struct ZapDlmmInfoProcessor;
 
 impl ZapInfoProcessor for ZapDlmmInfoProcessor {
-    fn validate_payload(&self, _payload: &[u8]) -> Result<(), ZapSdkError> {
+    fn validate_payload(&self, _payload: &[u8]) -> Result<(), ProtozolZapError> {
         Ok(())
     }
 
     fn extract_raw_zap_out_amm_info(
         &self,
         _zap_params: &ZapOutParameters,
-    ) -> Result<RawZapOutAmmInfo, ZapSdkError> {
+    ) -> Result<RawZapOutAmmInfo, ProtozolZapError> {
         Ok(RawZapOutAmmInfo {
             source_index: DLMM_SWAP2_SOURCE_ACCOUNT_INDEX,
             destination_index: DLMM_SWAP2_DESTINATION_ACCOUNT_INDEX,

zap-sdk/src/dlmm_zap.rs protocol-zap/src/dlmm_zap.rszap-sdk/src/dlmm_zap.rs renamed to protocol-zap/src/dlmm_zap.rs

@@ -4,7 +4,7 @@ use thiserror::Error;
 
 #[derive(Debug, Error, Clone, Copy, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[repr(u32)]
-pub enum ZapSdkError {
+pub enum ProtozolZapError {
     #[error("Math operation overflow")]
     MathOverflow = 0,
 
@@ -30,8 +30,8 @@ pub enum ZapSdkError {
     InvalidZapAccounts = 7,
 }
 
-impl From<ZapSdkError> for ProgramError {
-    fn from(e: ZapSdkError) -> Self {
+impl From<ProtozolZapError> for ProgramError {
+    fn from(e: ProtozolZapError) -> Self {
         ProgramError::Custom(e as u32)
     }
 }

zap-sdk/src/error.rs protocol-zap/src/error.rszap-sdk/src/error.rs renamed to protocol-zap/src/error.rs

@@ -5,7 +5,7 @@ use crate::{
         JUP_V6_SHARED_ACCOUNT_ROUTE_DESTINATION_ACCOUNT_INDEX,
         JUP_V6_SHARED_ACCOUNT_ROUTE_SOURCE_ACCOUNT_INDEX,
     },
-    error::ZapSdkError,
+    error::ProtozolZapError,
     safe_math::{SafeCast, SafeMath},
     RawZapOutAmmInfo, ZapInfoProcessor, ZapOutParameters,
 };
@@ -15,7 +15,7 @@ use jupiter::types::Swap;
 
 pub struct ZapJupV6RouteInfoProcessor;
 
-fn ensure_whitelisted_swap_leg(route_plan_steps: &[RoutePlanStep]) -> Result<(), ZapSdkError> {
+fn ensure_whitelisted_swap_leg(route_plan_steps: &[RoutePlanStep]) -> Result<(), ProtozolZapError> {
     for step in route_plan_steps {
         match step.swap {
             Swap::Meteora
@@ -33,7 +33,7 @@ fn ensure_whitelisted_swap_leg(route_plan_steps: &[RoutePlanStep]) -> Result<(),
             | Swap::RaydiumClmmV2 => {
                 // whitelisted swap leg
             }
-            _ => return Err(ZapSdkError::InvalidZapOutParameters),
+            _ => return Err(ProtozolZapError::InvalidZapOutParameters),
         }
     }
 
@@ -45,7 +45,7 @@ fn ensure_whitelisted_swap_leg(route_plan_steps: &[RoutePlanStep]) -> Result<(),
 /// - All swap paths must converge to exactly one terminal output
 pub(crate) fn ensure_route_plan_fully_converges(
     route_plan_steps: &[RoutePlanStep],
-) -> Result<(), ZapSdkError> {
+) -> Result<(), ProtozolZapError> {
     // Verify each unique input_index sums to exactly 100%
     for (i, step) in route_plan_steps.iter().enumerate() {
         // Only process first occurrence of each input_index
@@ -60,10 +60,10 @@ pub(crate) fn ensure_route_plan_fully_converges(
             .iter()
             .filter(|s| s.input_index == step.input_index)
             .try_fold(0u8, |acc, s| acc.checked_add(s.percent))
-            .ok_or(ZapSdkError::MathOverflow)?;
+            .ok_or(ProtozolZapError::MathOverflow)?;
 
         if percent_sum != 100 {
-            return Err(ZapSdkError::InvalidZapOutParameters);
+            return Err(ProtozolZapError::InvalidZapOutParameters);
         }
     }
 
@@ -83,22 +83,22 @@ pub(crate) fn ensure_route_plan_fully_converges(
         .count();
 
     if terminal_count != 1 {
-        return Err(ZapSdkError::InvalidZapOutParameters);
+        return Err(ProtozolZapError::InvalidZapOutParameters);
     }
 
     Ok(())
 }
 
 impl ZapInfoProcessor for ZapJupV6RouteInfoProcessor {
-    fn validate_payload(&self, payload: &[u8]) -> Result<(), ZapSdkError> {
+    fn validate_payload(&self, payload: &[u8]) -> Result<(), ProtozolZapError> {
         let route_params = jupiter::client::args::Route::try_from_slice(payload)
-            .map_err(|_| ZapSdkError::InvalidZapOutParameters)?;
+            .map_err(|_| ProtozolZapError::InvalidZapOutParameters)?;
         ensure_whitelisted_swap_leg(&route_params.route_plan)?;
         ensure_route_plan_fully_converges(&route_params.route_plan)?;
 
         // Ensure no platform_fee_bps is 0, so operator can't steal funds by providing their account as platform_fee_account
         if route_params.platform_fee_bps != 0 {
-            return Err(ZapSdkError::InvalidZapOutParameters);
+            return Err(ProtozolZapError::InvalidZapOutParameters);
         }
 
         Ok(())
@@ -107,7 +107,7 @@ impl ZapInfoProcessor for ZapJupV6RouteInfoProcessor {
     fn extract_raw_zap_out_amm_info(
         &self,
         zap_params: &ZapOutParameters,
-    ) -> Result<RawZapOutAmmInfo, ZapSdkError> {
+    ) -> Result<RawZapOutAmmInfo, ProtozolZapError> {
         let amount_in_offset = zap_params
             .payload_data
             .len()
@@ -125,15 +125,15 @@ impl ZapInfoProcessor for ZapJupV6RouteInfoProcessor {
 pub struct ZapJupV6SharedRouteInfoProcessor;
 
 impl ZapInfoProcessor for ZapJupV6SharedRouteInfoProcessor {
-    fn validate_payload(&self, payload: &[u8]) -> Result<(), ZapSdkError> {
+    fn validate_payload(&self, payload: &[u8]) -> Result<(), ProtozolZapError> {
         let route_params = jupiter::client::args::SharedAccountsRoute::try_from_slice(payload)
-            .map_err(|_| ZapSdkError::InvalidZapOutParameters)?;
+            .map_err(|_| ProtozolZapError::InvalidZapOutParameters)?;
         ensure_whitelisted_swap_leg(&route_params.route_plan)?;
         ensure_route_plan_fully_converges(&route_params.route_plan)?;
 
         // Ensure no platform_fee_bps is 0, so operator can't steal funds by providing their account as platform_fee_account
         if route_params.platform_fee_bps != 0 {
-            return Err(ZapSdkError::InvalidZapOutParameters);
+            return Err(ProtozolZapError::InvalidZapOutParameters);
         }
 
         Ok(())
@@ -142,7 +142,7 @@ impl ZapInfoProcessor for ZapJupV6SharedRouteInfoProcessor {
     fn extract_raw_zap_out_amm_info(
         &self,
         zap_params: &ZapOutParameters,
-    ) -> Result<RawZapOutAmmInfo, ZapSdkError> {
+    ) -> Result<RawZapOutAmmInfo, ProtozolZapError> {
         let amount_in_offset = zap_params
             .payload_data
             .len()

zap-sdk/src/jup_v6_zap.rs protocol-zap/src/jup_v6_zap.rszap-sdk/src/jup_v6_zap.rs renamed to protocol-zap/src/jup_v6_zap.rs

@@ -0,0 +1,68 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use pinocchio::pubkey::Pubkey;
+pub mod constants;
+pub mod damm_v2_zap;
+use damm_v2_zap::*;
+pub mod dlmm_zap;
+use dlmm_zap::ZapDlmmInfoProcessor;
+use zap_sdk::constants::{
+    DAMM_V2, DAMM_V2_SWAP_DISC, DLMM, DLMM_SWAP2_DISC, JUP_V6, JUP_V6_ROUTE_DISC,
+    JUP_V6_SHARED_ACCOUNT_ROUTE_DISC,
+};
+
+use crate::{
+    error::ProtozolZapError,
+    jup_v6_zap::{ZapJupV6RouteInfoProcessor, ZapJupV6SharedRouteInfoProcessor},
+};
+pub mod error;
+pub mod jup_v6_zap;
+pub mod safe_math;
+pub mod tests;
+pub mod utils;
+
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
+pub struct ZapOutParameters {
+    pub percentage: u8,
+    pub offset_amount_in: u16,
+    pub pre_user_token_balance: u64,
+    pub max_swap_amount: u64, // avoid the issue someone send token to user token account when user zap out
+    pub payload_data: Vec<u8>,
+}
+
+pub struct RawZapOutAmmInfo {
+    source_index: usize,
+    destination_index: usize,
+    amount_in_offset: u16,
+}
+
+pub trait ZapInfoProcessor {
+    fn validate_payload(&self, payload: &[u8]) -> Result<(), ProtozolZapError>;
+    fn extract_raw_zap_out_amm_info(
+        &self,
+        zap_params: &ZapOutParameters,
+    ) -> Result<RawZapOutAmmInfo, ProtozolZapError>;
+}
+
+const DAMM_V2_SWAP_DISC_REF: &[u8] = &DAMM_V2_SWAP_DISC;
+const DLMM_SWAP2_DISC_REF: &[u8] = &DLMM_SWAP2_DISC;
+const JUP_V6_ROUTE_DISC_REF: &[u8] = &JUP_V6_ROUTE_DISC;
+const JUP_V6_SHARED_ACCOUNT_ROUTE_DISC_REF: &[u8] = &JUP_V6_SHARED_ACCOUNT_ROUTE_DISC;
+
+const DLMM_ADDRESS: [u8; 32] = DLMM.to_bytes();
+const DAMM_V2_ADDRESS: [u8; 32] = DAMM_V2.to_bytes();
+const JUP_V6_ADDRESS: [u8; 32] = JUP_V6.to_bytes();
+
+pub fn get_zap_amm_processor(
+    amm_disc: &[u8],
+    amm_program_address: Pubkey,
+) -> Result<Box<dyn ZapInfoProcessor>, ProtozolZapError> {
+    match (amm_disc, amm_program_address) {
+        (DLMM_SWAP2_DISC_REF, DLMM_ADDRESS) => Ok(Box::new(ZapDlmmInfoProcessor)),
+        (DAMM_V2_SWAP_DISC_REF, DAMM_V2_ADDRESS) => Ok(Box::new(ZapDammV2InfoProcessor)),
+        (JUP_V6_ROUTE_DISC_REF, JUP_V6_ADDRESS) => Ok(Box::new(ZapJupV6RouteInfoProcessor)),
+        (JUP_V6_SHARED_ACCOUNT_ROUTE_DISC_REF, JUP_V6_ADDRESS) => {
+            Ok(Box::new(ZapJupV6SharedRouteInfoProcessor))
+        }
+        _ => Err(ProtozolZapError::InvalidZapOutParameters),
+    }
+}