Rust Program to Transfer Pnft

Question

Im trying to update my program to be able to transfer pnfts from the payer wallet to another wallet but facing errors:

"11111111111111111111111111111111's signer privilege escalated",
'Program f37PsdsiyhLuDLUc2HpSEFJCdav1n5ibzKe92HDFmiP consumed 37923 of 200000 compute units',
'Program f37PsdsiyhLuDLUc2HpSEFJCdav1n5ibzKe92HDFmiP failed: Cross-program invocation with unauthorized signer or writable account'

My Function looks like this:

                    transferPNFT(
                        ctx.accounts.nft_account.to_account_info(),
                        ctx.accounts.nft_metadata.to_account_info(),
                        ctx.accounts.nft_mint.to_account_info(),
                        ctx.accounts.destination.to_account_info(),
                        ctx.accounts.destination_ata.to_account_info(),
                        ctx.accounts.spl_ata_program.to_account_info(),
                        ctx.accounts.authority.to_account_info(),
                        ctx.accounts.admin.to_account_info(),
                        ctx.accounts.system_program.to_account_info(),
                        ctx.accounts.sysvar_instructions.to_account_info(),
                        ctx.accounts.spl_token_program.to_account_info(),
                        ctx.accounts.nft_master_edition.to_account_info(),
                        ctx.accounts.owner_token_record.to_account_info(),
                        ctx.accounts.destination_token_record.to_account_info(),
                        ctx.accounts.auth_rules_program.to_account_info(),
                        ctx.accounts.auth_rules.to_account_info(),
                        false,
                        None,
                        None,
                    );

pub fn transferPNFT<'info>( nft_account: AccountInfo<'info>, nft_metadata: AccountInfo<'info>, nft_mint: AccountInfo<'info>, destination: AccountInfo<'info>, destination_ata: AccountInfo<'info>, spl_ata_program: AccountInfo<'info>, authority: AccountInfo<'info>, payer: AccountInfo<'info>, system_program: AccountInfo<'info>, sysvar_instructions: AccountInfo<'info>, spl_token_program: AccountInfo<'info>, nft_master_edition: AccountInfo<'info>, owner_token_record: AccountInfo<'info>, destination_token_record: AccountInfo<'info>, auth_rules_program: AccountInfo<'info>, auth_rules: AccountInfo<'info>, escrow: bool, entrants: Option, bump: Option, ) -> Result<()> { let mut transfer_builder = TransferBuilder::new();

transfer_builder
    .token(nft_account.key())
    .token_owner(authority.key())
    .destination(destination_ata.key())
    .destination_owner(destination.key())
    .mint(nft_mint.key())
    .metadata(nft_metadata.key())
    .authority(authority.key())
    .payer(payer.key());

let mut transfer_infos = vec![
    nft_account.to_account_info(),
    authority.to_account_info(),
    authority.to_account_info(),
    destination_ata.to_account_info(),
    destination.to_account_info(),
    nft_mint.to_account_info(),
    nft_metadata.to_account_info(),
    system_program.to_account_info(),
    sysvar_instructions.to_account_info(),
    spl_token_program.to_account_info(),
    spl_ata_program.to_account_info(),
];

let metadata: Metadata = Metadata::from_account_info(&nft_metadata)?;

if matches!(
    metadata.token_standard,
    Some(TokenStandard::ProgrammableNonFungible)
) {
    transfer_builder
        .edition(nft_master_edition.key())
        .owner_token_record(owner_token_record.key())
        .destination_token_record(destination_token_record.key());

    transfer_infos.push(nft_master_edition.to_account_info());
    transfer_infos.push(owner_token_record.to_account_info());
    transfer_infos.push(destination_token_record.to_account_info());

    // if let Some(ProgrammableConfig::V1 { rule_set: Some(_) }) =
    //     metadata.programmable_config
    // {

    transfer_builder
        .authorization_rules_program(auth_rules_program.key())
        .authorization_rules(auth_rules.key());
    transfer_infos.push(auth_rules_program.to_account_info());

    transfer_infos.push(auth_rules.to_account_info());
    // }
}
let transfer_ix = transfer_builder
    .build(TransferArgs::V1 {
        amount: 1,
        authorization_data: None,
    }).map_err(|_| DegenDropError::InstructionBuilderFailed)?
    .instruction();
if !escrow {
    invoke(&transfer_ix, &transfer_infos)?;
} else {
    let entrants = match entrants {
        Some(entrants) => entrants,
        None => return Err(DegenDropError::AccountNotfound.into()),
    };

    let bump = match bump {
        Some(bump) => bump,
        None => return Err(DegenDropError::AccountNotfound.into()),
    };

    invoke_signed(
        &transfer_ix,
        &transfer_infos,
        &[&[b"raffle".as_ref(), entrants.as_ref(), &[bump]]],
    )?;
}

Ok(())

}

and my context looks like this:

#[derive(Accounts)] pub struct AdminCallbackPNFT<'info> { #[account(mut, address = global_account.authority @ DegenDropError::AccessDenied)] pub admin: Signer<'info>,

#[account(
    mut,
    seeds = [GLOBAL_VAULT.as_bytes()],
    bump = global_account.bump,
)]
pub global_account:  Box<Account<'info, GlobalState>>,

/// CHECK:Initialize Treasury
#[account(mut, address = admin.key() @ DegenDropError::InvalidFeePool, signer)]
pub treasury_account: AccountInfo<'info>,
#[account(
    mut,
    seeds = [PLAYER_ACCOUNT.as_bytes(), player.key().as_ref()],
    bump = player_account.bump,
)]
pub player_account:  Box<Account<'info, BoxPlay>>,
/// CHECK: callback player's account
#[account(mut, address=player_account.wallet_address)]
pub player: AccountInfo<'info>,

#[account(
    mut,
    token::authority = admin.key(),
    token::mint = spl_mint.key()
)]
pub spl_treasury_account: Box<Account<'info, TokenAccount>>,

#[account(mut)]
/// CHECK:Initialize Treasury
pub spl_mint: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub nft_account: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub nft_metadata: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub nft_mint: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub authority: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub destination: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub destination_ata: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub spl_ata_program: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub spl_token_program: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub sysvar_instructions: AccountInfo<'info>,
/// CHECK:Initialize Treasury
pub nft_master_edition: UncheckedAccount<'info>,
/// CHECK:Initialize Treasury
pub owner_token_record: UncheckedAccount<'info>,
/// CHECK:Initialize Treasury
pub destination_token_record: UncheckedAccount<'info>,
/// CHECK:Initialize Treasury
pub auth_rules_program: UncheckedAccount<'info>,
/// CHECK:Initialize Treasury
pub auth_rules: UncheckedAccount<'info>,
/// CHECK:Initialize Treasury
pub token_program: Program<'info, Token>,

#[account(
    mut,
    constraint = player_mint_ata.owner == player.key() && player_mint_ata.mint == spl_mint.key()
)]
pub player_mint_ata:  Box<Account<'info, TokenAccount>>,
pub system_program: Program<'info, System>,

}