blockworks-foundation
/
autobahn
mirror of https://github.com/blockworks-foundation/autobahn.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

make executor fully compatible with token2022

This commit is contained in:
Maximilian Schneider 2024-11-06 21:41:04 +01:00
parent 805218e86d
commit 0b51674a85
8 changed files with 278 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
programs/autobahn-executor/src/instructions/execute_charge_fees_v2.rs Normal file
View File

@ -0,0 +1,80 @@
use crate::logs::{emit_stack, PlatformFeeLog, ReferrerFeeLog};
use crate::token;
use crate::utils::{read_u64, read_u8};
use solana_program::account_info::AccountInfo;
use solana_program::entrypoint::ProgramResult;
use solana_program::program_error::ProgramError;
use std::cmp::min;
/// transfers autobahn-executor fee to platform_fee_account and optionally referrer_fee_account
///
/// Instruction data layout
/// Data:
/// - total_fee_amount_native: u64
/// - platform_fee_percent: u8
///
/// If there is a referrer
/// - Platform will get `platform_fee_percent/100 * total_fee_amount_native`
/// - Referrer will get `(1 - platform_fee_percent/100) * total_fee_amount_native`
///
/// If there is no referrer,
/// - Platform will get `total_fee_amount_native`
pub fn execute_charge_fees_v2(accounts: &[AccountInfo], instruction_data: &[u8]) -> ProgramResult {
let (fee_amount, instruction_data) = read_u64(instruction_data);
let (platform_fee_percent, _) = read_u8(instruction_data);
let platform_fee_percent = min(100, platform_fee_percent);
if accounts.len() < 5 {
return Err(ProgramError::NotEnoughAccountKeys);
}
let token_program = &accounts[0];
let mint_account = &accounts[1];
let token_account = &accounts[2];
let platform_fee_account = &accounts[3];
let signer_account = &accounts[4];
let has_referrer = accounts.len() == 6;
let platform_fee_amount = if has_referrer {
(fee_amount * platform_fee_percent as u64) / 100
} else {
fee_amount
};
token::transfer(
token_program,
mint_account,
token_account,
platform_fee_account,
signer_account,
&[],
platform_fee_amount,
)?;
emit_stack(PlatformFeeLog {
user: *signer_account.key,
platform_token_account: *platform_fee_account.key,
platform_fee: platform_fee_amount,
})?;
if has_referrer {
let referrer_fee_account = &accounts[4];
let referrer_fee_amount = fee_amount.saturating_sub(platform_fee_amount);
token::transfer(
token_program,
mint_account,
token_account,
referrer_fee_account,
signer_account,
&[],
referrer_fee_amount,
)?;
emit_stack(ReferrerFeeLog {
referee: *signer_account.key,
referer_token_account: *referrer_fee_account.key,
referrer_fee: referrer_fee_amount,
})?;
}
Ok(())
}

28
programs/autobahn-executor/src/instructions/execute_create_referral.rs
View File

@ -1,23 +1,16 @@
use solana_program::account_info::AccountInfo;
use solana_program::entrypoint::ProgramResult;
use solana_program::program::invoke;
use solana_program::program_error::ProgramError;
use solana_program::program_pack::Pack;
use solana_program::pubkey::Pubkey;
use solana_program::rent::Rent;
use solana_program::system_program;
use solana_program::sysvar::Sysvar;
use crate::create_pda::create_pda_account;
use crate::logs::{emit_stack, CreateReferralLog};
use crate::token;
pub fn execute_create_referral(accounts: &[AccountInfo], instruction_data: &[u8]) -> ProgramResult {
if let [payer, referrer, vault, mint, system_program, token_program] = accounts {
// verify token program is passed
if !spl_token::ID.eq(token_program.key) {
return Err(ProgramError::IncorrectProgramId);
}
token::verify_program_id(token_program.key)?;
// verify system program is passed
if !system_program::ID.eq(system_program.key) {
@ -38,26 +31,15 @@ pub fn execute_create_referral(accounts: &[AccountInfo], instruction_data: &[u8]
return Err(ProgramError::InvalidSeeds);
}
create_pda_account(
token::intialize(
payer,
&Rent::get()?,
spl_token::state::Account::LEN,
&spl_token::ID,
system_program,
token_program,
mint,
vault,
&vault_seeds,
)?;
let initialize_ix = spl_token::instruction::initialize_account3(
&spl_token::ID,
vault.key,
mint.key,
vault.key,
)?;
let initialize_account_infos = [vault.clone(), mint.clone(), token_program.clone()];
invoke(&initialize_ix, &initialize_account_infos)?;
emit_stack(CreateReferralLog {
referee: *payer.key,
referer: *referrer.key,

5
programs/autobahn-executor/src/instructions/execute_swap_v2.rs
View File

@ -1,3 +1,4 @@
use crate::token;
use crate::utils::{read_bytes, read_u64, read_u8, read_ux16};
use solana_program::account_info::AccountInfo;
use solana_program::entrypoint::ProgramResult;
@ -69,9 +70,9 @@ pub fn execute_swap_v2(
};
let ix_token_account = &ix_accounts[0];
let balance_before = crate::get_balance(ix_token_account)?;
let balance_before = token::get_balance(ix_token_account)?;
invoke(&instruction, &ix_accounts)?;
let balance_after = crate::get_balance(ix_token_account)?;
let balance_after = token::get_balance(ix_token_account)?;
in_amount = balance_after - balance_before;
ext_instruction_data = instruction_data;
ix_account_index += ix_accounts.len();

13
programs/autobahn-executor/src/instructions/execute_swap_v3.rs
View File

@ -1,4 +1,5 @@
use crate::logs::{emit_stack, SwapEvent};
use crate::token;
use crate::utils::{read_bytes, read_u64, read_u8, read_ux16};
use solana_program::account_info::AccountInfo;
use solana_program::entrypoint::ProgramResult;
@ -35,13 +36,13 @@ pub fn execute_swap_v3(
);
let mut in_amount = 0u64;
let mut in_mint = crate::get_mint(&accounts[0])?;
let mut in_mint = token::get_mint(&accounts[0])?;
let mut ix_account_index = 1usize;
let mut ext_instruction_data = instruction_data;
let mut input_amount = 0u64;
let mut input_mint = Pubkey::default();
let input_token_account_balance = crate::get_balance(&accounts[0])?;
let input_token_account_balance = token::get_balance(&accounts[0])?;
let mut output_amount = 0u64;
let mut output_mint = Pubkey::default();
@ -79,14 +80,14 @@ pub fn execute_swap_v3(
};
let ix_token_account = &ix_accounts[0];
let balance_before = crate::get_balance(ix_token_account)?;
let balance_before = token::get_balance(ix_token_account)?;
invoke(&instruction, &ix_accounts)?;
let balance_after = crate::get_balance(ix_token_account)?;
let balance_after = token::get_balance(ix_token_account)?;
let out_amount = balance_after - balance_before;
let out_mint = crate::get_mint(ix_token_account)?;
let out_mint = token::get_mint(ix_token_account)?;
if ix_index == 0 {
input_amount = input_token_account_balance - crate::get_balance(&accounts[0])?;
input_amount = input_token_account_balance - token::get_balance(&accounts[0])?;
input_mint = in_mint;
}

46
programs/autobahn-executor/src/instructions/execute_withdraw_referral_fees.rs
View File

@ -1,23 +1,20 @@
use solana_program::account_info::AccountInfo;
use solana_program::entrypoint::ProgramResult;
use solana_program::program::invoke_signed;
use solana_program::program_error::ProgramError;
use solana_program::program_pack::Pack;
use solana_program::pubkey::Pubkey;
use solana_program::system_program;
use spl_token::state::Account as TokenAccount;
use crate::logs::{emit_stack, ReferrerWithdrawLog};
use crate::{
logs::{emit_stack, ReferrerWithdrawLog},
token,
};
pub fn execute_withdraw_referral_fees(
accounts: &[AccountInfo],
instruction_data: &[u8],
) -> ProgramResult {
if let [referrer, vault, mint, referrer_ata, system_program, token_program] = accounts {
// verify token program is passed
if !spl_token::ID.eq(token_program.key) {
return Err(ProgramError::IncorrectProgramId);
}
token::verify_program_id(token_program.key)?;
// verify system program is passed
if !system_program::ID.eq(system_program.key) {
@ -30,8 +27,7 @@ pub fn execute_withdraw_referral_fees(
}
// Verify the ownership of the referrer_ata
let referrer_ata_data = TokenAccount::unpack(&referrer_ata.try_borrow_data()?)?;
if referrer_ata_data.owner != *referrer.key {
if token::get_owner(referrer_ata)? != *referrer.key {
return Err(ProgramError::IllegalOwner);
}
@ -48,30 +44,18 @@ pub fn execute_withdraw_referral_fees(
return Err(ProgramError::InvalidSeeds);
}
// Assume accounts are correctly provided and the `vault` account is an SPL Token account
let vault_info = vault;
// Deserialize the token account to get the balance
let vault_token_account: TokenAccount =
TokenAccount::unpack(&vault_info.try_borrow_data()?)?;
// Always go with full amount
let full_amount = vault_token_account.amount;
// Create transfer instruction from vault to referrer ATA
let transfer_ix = spl_token::instruction::transfer(
token_program.key,
vault.key,
referrer_ata.key,
vault.key,
&[],
// Always withdraw full amount
let full_amount = token::get_balance(vault)?;
token::transfer(
token_program,
mint,
vault,
referrer_ata,
vault,
&vault_seeds,
full_amount,
)?;
let transfer_account_infos = [vault.clone(), referrer_ata.clone(), token_program.clone()];
invoke_signed(&transfer_ix, &transfer_account_infos, &[&vault_seeds])?;
emit_stack(ReferrerWithdrawLog {
referer: *referrer.key,
referer_token_account: *referrer_ata.key,

2
programs/autobahn-executor/src/instructions/mod.rs
View File

@ -1,4 +1,5 @@
mod execute_charge_fees;
mod execute_charge_fees_v2;
mod execute_create_referral;
mod execute_openbook_v2_swap;
mod execute_swap_v2;
@ -6,6 +7,7 @@ mod execute_swap_v3;
mod execute_withdraw_referral_fees;
pub use execute_charge_fees::execute_charge_fees;
pub use execute_charge_fees_v2::execute_charge_fees_v2;
pub use execute_create_referral::execute_create_referral;
pub use execute_openbook_v2_swap::execute_openbook_v2_swap;
pub use execute_swap_v2::execute_swap_v2;

37
programs/autobahn-executor/src/lib.rs
View File

@ -2,16 +2,15 @@ pub mod create_pda;
mod instructions;
pub mod logs;
pub mod swap_ix;
pub mod token;
pub mod utils;
use instructions::{
execute_charge_fees, execute_create_referral, execute_openbook_v2_swap, execute_swap_v2,
execute_swap_v3, execute_withdraw_referral_fees,
execute_charge_fees, execute_charge_fees_v2, execute_create_referral, execute_openbook_v2_swap, execute_swap_v2, execute_swap_v3, execute_withdraw_referral_fees
};
use solana_program::declare_id;
use solana_program::entrypoint::ProgramResult;
use solana_program::program_error::ProgramError;
use solana_program::program_pack::Pack;
use solana_program::{account_info::AccountInfo, pubkey::Pubkey};
#[cfg(not(feature = "no-entrypoint"))]
@ -41,6 +40,7 @@ pub enum Instructions {
ChargeFees = 4,
CreateReferral = 5,
WithdrawReferral = 6,
ChargeFeesV2 = 7,
}
pub fn process_instruction(
@ -70,34 +70,9 @@ pub fn process_instruction(
x if x == Instructions::WithdrawReferral as u8 => {
execute_withdraw_referral_fees(accounts, &instruction_data[1..])
}
x if x == Instructions::ChargeFeesV2 as u8 => {
execute_charge_fees_v2(accounts, &instruction_data[1..])
}
_ => Err(ProgramError::InvalidInstructionData),
}
}
fn get_balance(account: &AccountInfo) -> Result<u64, ProgramError> {
match account.owner {
&spl_token::ID => {
let token = spl_token::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.amount)
}
&spl_token_2022::ID => {
let token = spl_token_2022::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.amount)
}
_ => Err(ProgramError::IllegalOwner),
}
}
fn get_mint(account: &AccountInfo) -> Result<Pubkey, ProgramError> {
match account.owner {
&spl_token::ID => {
let token = spl_token::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.mint)
}
&spl_token_2022::ID => {
let token: spl_token_2022::state::Account = spl_token_2022::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.mint)
}
_ => Err(ProgramError::IllegalOwner),
}
}

160
programs/autobahn-executor/src/token.rs Normal file
View File

@ -0,0 +1,160 @@
use solana_program::account_info::AccountInfo;
use solana_program::program::{invoke, invoke_signed};
use solana_program::program_error::ProgramError;
use solana_program::program_pack::Pack;
use solana_program::pubkey::Pubkey;
use solana_program::rent::Rent;
use solana_program::sysvar::Sysvar;
use spl_token_2022::extension::{BaseStateWithExtensions, ExtensionType, StateWithExtensions};
use crate::create_pda::create_pda_account;
pub fn get_balance(account: &AccountInfo) -> Result<u64, ProgramError> {
match account.owner {
&spl_token::ID => {
let token = spl_token::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.amount)
}
&spl_token_2022::ID => {
let token = spl_token_2022::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.amount)
}
_ => Err(ProgramError::IllegalOwner),
}
}
pub fn get_mint(account: &AccountInfo) -> Result<Pubkey, ProgramError> {
match account.owner {
&spl_token::ID => {
let token = spl_token::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.mint)
}
&spl_token_2022::ID => {
let token: spl_token_2022::state::Account =
spl_token_2022::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.mint)
}
_ => Err(ProgramError::IllegalOwner),
}
}
pub fn get_owner(account: &AccountInfo) -> Result<Pubkey, ProgramError> {
match account.owner {
&spl_token::ID => {
let token = spl_token::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.owner)
}
&spl_token_2022::ID => {
let token: spl_token_2022::state::Account =
spl_token_2022::state::Account::unpack(&account.try_borrow_data()?)?;
Ok(token.owner)
}
_ => Err(ProgramError::IllegalOwner),
}
}
pub fn intialize<'a>(
payer: &AccountInfo<'a>,
system_program: &AccountInfo<'a>,
token_program: &AccountInfo<'a>,
mint: &AccountInfo<'a>,
account: &AccountInfo<'a>,
seeds: &[&[u8]],
) -> Result<(), ProgramError> {
let space = match account.owner {
&spl_token::ID => Ok(spl_token::state::Account::LEN),
&spl_token_2022::ID => {
let mint_data = mint.data.borrow();
let mint_with_extension =
StateWithExtensions::<spl_token_2022::state::Mint>::unpack(&mint_data).unwrap();
let mint_extensions = mint_with_extension.get_extension_types()?;
let required_extensions =
ExtensionType::get_required_init_account_extensions(&mint_extensions);
let space = ExtensionType::try_calculate_account_len::<spl_token_2022::state::Account>(
&required_extensions,
)?;
Ok(space)
}
_ => Err(ProgramError::IllegalOwner),
}?;
create_pda_account(
payer,
&Rent::get()?,
space,
account.owner,
system_program,
account,
seeds,
)?;
let initialize_ix = spl_token::instruction::initialize_account3(
token_program.key,
account.key,
mint.key,
account.key,
)?;
let initialize_account_infos = [account.clone(), mint.clone(), token_program.clone()];
invoke(&initialize_ix, &initialize_account_infos)
}
pub fn transfer<'a>(
program: &AccountInfo<'a>,
mint: &AccountInfo<'a>,
source: &AccountInfo<'a>,
destination: &AccountInfo<'a>,
authority: &AccountInfo<'a>,
signer_seeds: &[&[u8]],
amount: u64,
) -> Result<(), ProgramError> {
match *program.key {
spl_token::ID => {
let transfer_ix = spl_token::instruction::transfer(
program.key,
source.key,
destination.key,
authority.key,
&[],
amount,
)?;
let transfer_account_infos = [source.clone(), destination.clone(), program.clone()];
if signer_seeds.is_empty() {
invoke(&transfer_ix, &transfer_account_infos)
} else {
invoke_signed(&transfer_ix, &transfer_account_infos, &[signer_seeds])
}
}
spl_token_2022::ID => {
let mint_data = mint.try_borrow_data()?;
let mint_parsed = StateWithExtensions::<
spl_token_2022::state::Mint,
>::unpack(&mint_data)?;
let transfer_ix = spl_token_2022::instruction::transfer_checked(
program.key,
source.key,
mint.key,
destination.key,
authority.key,
&[],
amount,
mint_parsed.base.decimals,
)?;
let transfer_account_infos = [source.clone(), destination.clone(), program.clone()];
if signer_seeds.is_empty() {
invoke(&transfer_ix, &transfer_account_infos)
} else {
invoke_signed(&transfer_ix, &transfer_account_infos, &[signer_seeds])
}
}
_ => Err(ProgramError::IncorrectProgramId),
}
}
pub fn verify_program_id(address: &Pubkey) -> Result<(), ProgramError> {
if spl_token::ID.eq(address) || spl_token_2022::ID.eq(address) {
return Ok(());
} else {
return Err(ProgramError::IncorrectProgramId);
}
}