Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

AUDIT: 37314 #191

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

AUDIT: 37314 #191

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
316 changes: 316 additions & 0 deletions integration_tests/tests/vault/burn_withdrawal_ticket.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -478,6 +478,167 @@ mod tests {
assert_eq!(vault.vrt_cooling_down_amount(), 0);
}

/// Tests that the program fee is non deducted when the staker is the program fee wallet
#[tokio::test]
async fn test_burn_withdrawal_ticket_with_staker_as_program_fee_wallet() {
const MINT_AMOUNT: u64 = 100_000;
const PROGRAM_FEE_BPS: u16 = 10; // 0.1%

let deposit_fee_bps = 0;
let withdraw_fee_bps = 0;
let reward_fee_bps = 0;
let num_operators = 1;
let slasher_amounts = vec![];

let mut fixture = TestBuilder::new().await;
let ConfiguredVault {
mut vault_program_client,
restaking_program_client: _,
vault_config_admin,
vault_root,
restaking_config_admin: _,
operator_roots,
} = fixture
.setup_vault_with_ncn_and_operators(
deposit_fee_bps,
withdraw_fee_bps,
reward_fee_bps,
num_operators,
&slasher_amounts,
)
.await
.unwrap();

// Set program fee
vault_program_client
.set_program_fee(&vault_config_admin, PROGRAM_FEE_BPS)
.await
.unwrap();

// Depositor is the program fee wallet
let depositor = vault_config_admin;
vault_program_client
.configure_depositor(&vault_root, &depositor.pubkey(), MINT_AMOUNT)
.await
.unwrap();
vault_program_client
.do_mint_to(&vault_root, &depositor, MINT_AMOUNT, MINT_AMOUNT)
.await
.unwrap();

let config = vault_program_client
.get_config(&Config::find_program_address(&jito_vault_program::id()).0)
.await
.unwrap();

// Delegate all funds to the operator
vault_program_client
.do_add_delegation(&vault_root, &operator_roots[0].operator_pubkey, MINT_AMOUNT)
.await
.unwrap();

let VaultStakerWithdrawalTicketRoot { base } = vault_program_client
.do_enqueue_withdrawal(&vault_root, &depositor, MINT_AMOUNT)
.await
.unwrap();

// If this breaks: MINT_AMOUNT * 9990 / 10000 - 1,
vault_program_client
.do_cooldown_delegation(&vault_root, &operator_roots[0].operator_pubkey, MINT_AMOUNT)
.await
.unwrap();

// Warp forward two epochs
fixture
.warp_slot_incremental(config.epoch_length())
.await
.unwrap();
vault_program_client
.do_full_vault_update(
&vault_root.vault_pubkey,
&[operator_roots[0].operator_pubkey],
)
.await
.unwrap();
fixture
.warp_slot_incremental(config.epoch_length())
.await
.unwrap();
vault_program_client
.do_full_vault_update(
&vault_root.vault_pubkey,
&[operator_roots[0].operator_pubkey],
)
.await
.unwrap();

let vault = vault_program_client
.get_vault(&vault_root.vault_pubkey)
.await
.unwrap();

let initial_depositor_balance = fixture
.get_token_account(&get_associated_token_address(
&depositor.pubkey(),
&vault.supported_mint,
))
.await
.unwrap()
.amount;

vault_program_client
.do_burn_withdrawal_ticket(&vault_root, &depositor, &base, &config.program_fee_wallet)
.await
.unwrap();

// Calculate expected fee
let expected_fee = 0;
let expected_withdrawal = MINT_AMOUNT - expected_fee;

// Check final balances
let final_depositor_balance = fixture
.get_token_account(&get_associated_token_address(
&depositor.pubkey(),
&vault.supported_mint,
))
.await
.unwrap()
.amount;
let program_fee_balance = fixture
.get_token_account(&get_associated_token_address(
&config.program_fee_wallet,
&vault.vrt_mint,
))
.await
.unwrap()
.amount;

// Assert correct amounts were transferred
assert_eq!(
final_depositor_balance - initial_depositor_balance,
expected_withdrawal
);
assert_eq!(program_fee_balance, expected_fee);

// Check that the vault state is correct
let vault = vault_program_client
.get_vault(&vault_root.vault_pubkey)
.await
.unwrap();
assert_eq!(
vault.tokens_deposited() - Vault::DEFAULT_INITIALIZATION_TOKEN_AMOUNT,
expected_fee
);
assert_eq!(
vault.vrt_supply() - Vault::DEFAULT_INITIALIZATION_TOKEN_AMOUNT,
expected_fee
);
assert_eq!(vault.delegation_state, DelegationState::default());
assert_eq!(vault.vrt_enqueued_for_cooldown_amount(), 0);
assert_eq!(vault.vrt_ready_to_claim_amount(), 0);
assert_eq!(vault.vrt_cooling_down_amount(), 0);
}

/// Tests that the program fee is correctly deducted and transferred during burn_withdrawal_ticket
#[tokio::test]
async fn test_burn_withdrawal_ticket_withdrawal_fee() {
Expand Down Expand Up @@ -633,6 +794,161 @@ mod tests {
assert_eq!(vault.vrt_cooling_down_amount(), 0);
}

/// Tests that the program fee is non deducted when the staker is the vault fee wallet
#[tokio::test]
async fn test_burn_withdrawal_ticket_with_staker_as_vault_fee_wallet() {
const MINT_AMOUNT: u64 = 100_000;
const WITHDRAWAL_FEE_BPS: u16 = 1000; // 10%

let deposit_fee_bps = 0;
let withdraw_fee_bps = WITHDRAWAL_FEE_BPS;
let reward_fee_bps = 0;
let num_operators = 1;
let slasher_amounts = vec![];

let mut fixture = TestBuilder::new().await;
let ConfiguredVault {
mut vault_program_client,
restaking_program_client: _,
vault_config_admin: _,
vault_root,
restaking_config_admin: _,
operator_roots,
} = fixture
.setup_vault_with_ncn_and_operators(
deposit_fee_bps,
withdraw_fee_bps,
reward_fee_bps,
num_operators,
&slasher_amounts,
)
.await
.unwrap();

// Initial deposit + mint
let depositor = vault_root.vault_admin.insecure_clone();
vault_program_client
.configure_depositor(&vault_root, &depositor.pubkey(), MINT_AMOUNT)
.await
.unwrap();
vault_program_client
.do_mint_to(&vault_root, &depositor, MINT_AMOUNT, MINT_AMOUNT)
.await
.unwrap();

let config = vault_program_client
.get_config(&Config::find_program_address(&jito_vault_program::id()).0)
.await
.unwrap();

// Delegate all funds to the operator
vault_program_client
.do_add_delegation(&vault_root, &operator_roots[0].operator_pubkey, MINT_AMOUNT)
.await
.unwrap();

let VaultStakerWithdrawalTicketRoot { base } = vault_program_client
.do_enqueue_withdrawal(&vault_root, &depositor, MINT_AMOUNT)
.await
.unwrap();

// If this breaks: MINT_AMOUNT * 9990 / 10000 - 1,
vault_program_client
.do_cooldown_delegation(&vault_root, &operator_roots[0].operator_pubkey, MINT_AMOUNT)
.await
.unwrap();

// Warp forward two epochs
fixture
.warp_slot_incremental(config.epoch_length())
.await
.unwrap();
vault_program_client
.do_full_vault_update(
&vault_root.vault_pubkey,
&[operator_roots[0].operator_pubkey],
)
.await
.unwrap();
fixture
.warp_slot_incremental(config.epoch_length())
.await
.unwrap();
vault_program_client
.do_full_vault_update(
&vault_root.vault_pubkey,
&[operator_roots[0].operator_pubkey],
)
.await
.unwrap();

let vault = vault_program_client
.get_vault(&vault_root.vault_pubkey)
.await
.unwrap();

let initial_depositor_balance = fixture
.get_token_account(&get_associated_token_address(
&depositor.pubkey(),
&vault.supported_mint,
))
.await
.unwrap()
.amount;

vault_program_client
.do_burn_withdrawal_ticket(&vault_root, &depositor, &base, &config.program_fee_wallet)
.await
.unwrap();

// Calculate expected fee
let expected_fee = 0;
let expected_withdrawal = MINT_AMOUNT - expected_fee;

// Check final balances
let final_depositor_balance = fixture
.get_token_account(&get_associated_token_address(
&depositor.pubkey(),
&vault.supported_mint,
))
.await
.unwrap()
.amount;
let program_fee_balance = fixture
.get_token_account(&get_associated_token_address(
&vault.fee_wallet,
&vault.vrt_mint,
))
.await
.unwrap()
.amount;

// Assert correct amounts were transferred
assert_eq!(
final_depositor_balance - initial_depositor_balance,
expected_withdrawal
);
assert_eq!(program_fee_balance, expected_fee);

// Check that the vault state is correct
let vault = vault_program_client
.get_vault(&vault_root.vault_pubkey)
.await
.unwrap();
assert_eq!(
vault.tokens_deposited() - Vault::DEFAULT_INITIALIZATION_TOKEN_AMOUNT,
expected_fee
);
assert_eq!(
vault.vrt_supply() - Vault::DEFAULT_INITIALIZATION_TOKEN_AMOUNT,
expected_fee
);
assert_eq!(vault.delegation_state, DelegationState::default());
assert_eq!(vault.vrt_enqueued_for_cooldown_amount(), 0);
assert_eq!(vault.vrt_ready_to_claim_amount(), 0);
assert_eq!(vault.vrt_cooling_down_amount(), 0);
}

#[tokio::test]
async fn test_burn_withdrawal_ticket_with_extra_vrt_sent_to_ticket() {
const MINT_AMOUNT: u64 = 100_000;
Expand Down
Loading
Loading