Function process

program/src/processor/sweep_fees.rs:85–184

(program_id: &Pubkey, accounts: &[AccountInfo])

}

pub(crate) fn process(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
    let accounts = Accounts::parse(program_id, accounts)?;

    let mut market_state = DexState::get(accounts.market)?;
    check_accounts(program_id, &market_state, &accounts)?;
    check_metadata_account(accounts.token_metadata, &market_state.base_mint)?;

    let mut no_op = true;

    if accounts.token_metadata.data_len() != 0 && market_state.accumulated_royalties != 0 {
        no_op = false;
        let metadata: Metadata = Metadata::from_account_info(accounts.token_metadata)?;
        let mut share_sum = 0;
        let mut royalties_sum = 0u64;
        if let Some(creators) = metadata.data.creators {
            for (idx, creator) in creators.into_iter().enumerate() {
                share_sum += creator.share;
                let token_destination = accounts.creators_token_accounts.get(idx).unwrap();
                let amount = market_state
                    .accumulated_royalties
                    .checked_mul(creator.share as u64)
                    .ok_or(DexError::NumericalOverflow)?
                    / 100;

                royalties_sum = royalties_sum
                    .checked_add(amount)
                    .ok_or(DexError::NumericalOverflow)?;

                check_token_account_owner(token_destination, &creator.address)?;

                let transfer_instruction = spl_token::instruction::transfer(
                    &spl_token::ID,
                    accounts.quote_vault.key,
                    token_destination.key,
                    accounts.market_signer.key,
                    &[],
                    amount,
                )?;
                invoke_signed(
                    &transfer_instruction,
                    &[
                        accounts.spl_token_program.clone(),
                        accounts.quote_vault.clone(),
                        token_destination.clone(),
                        accounts.market_signer.clone(),
                    ],
                    &[&[
                        &accounts.market.key.to_bytes(),
                        &[market_state.signer_nonce as u8],
                    ]],
                )?;
            }

            if share_sum != 100 {
                msg!("Invalid metadata shares - received {}", share_sum);
                return Err(ProgramError::InvalidAccountData);
            }