solana token transfer to pool | 登链社区

5 solana token transfer to pool

回答问题即可获得 5 贡献值，回答被采纳后即可获得 9 学分。

我想要将solana的任何spl token能够通过inbox转移到当前程序账户下，然后任何token都能通过outbox从当前程序账户下转移到用户，我的代码好像是有误的，希望老师们能帮忙解决下，solana小白。

```
use anchor_lang::prelude::*;
use anchor_lang::solana_program::system_instruction;
use anchor_spl::token::{self, Token, TokenAccount, Transfer};

#[account]
pub struct MappingMakerToBool {
    pub mappings: Vec<PubkeyBoolPair>,
}
impl MappingMakerToBool {
    pub fn set(&mut self, key: Pubkey, value: bool) {
        if let Some(pair) = self.mappings.iter_mut().find(|pair| pair.key == key) {
            pair.value = value;
        } else {
            self.mappings.push(PubkeyBoolPair { key, value });
        }
    }

pub fn get(&self, key: Pubkey) -> Option<bool> {
        self.mappings
            .iter()
            .find(|pair| pair.key == key)
            .map(|pair| pair.value)
    }
}

#[program]
mod test {
 //初始化
    pub fn initialize(
        ctx: Context<Initialize>,
        owner: Pubkey,
        fee: u64,
        fee_receiver: Pubkey,
        paused: bool,
    ) -> Result<()> {
        let init_state = &mut ctx.accounts.state;
        // require!(
        //     ctx.accounts.user.key().to_string() == INIT_OPERATOR,
        //     ErrorCode::NoPermission
        // );
        // 确保只能调用一次
        require!(!init_state.initialized, ErrorCode::AlreadyInitialized);

let (pda, bump) = Pubkey::find_program_address(
            &[b"authority", init_state.key().as_ref()],
            ctx.program_id,
        );
        // PDA seeds and bump to "sign" for CPI
        // let seeds = b"authority";
        // let bump = ctx.bumps.reward_token_mint;
        // let signer: &[&[&[u8]]] = &[&[seeds, &[bump]]];

require!(fee <= 10000, ErrorCode::FeeOver10000);
        init_state.bump = bump;
        init_state.program_pda = pda;

init_state.owner = owner;
        init_state.fee = fee;
        init_state.fee_receiver = fee_receiver;

init_state.paused = paused;
        init_state.initialized = true; 
        Ok(())
    }

pub fn set_maker_list(
        ctx: Context<SetMakerList>,
        makers: Vec<Pubkey>,
        status: Vec<bool>,
    ) -> Result<()> {
        let state = &mut ctx.accounts.state;
        require!(
            state.owner == ctx.accounts.user.key(),
            ErrorCode::NoPermission
        );
        require!(makers.len() == status.len(), ErrorCode::InvalidLength);
        let maker_valid = &mut ctx.accounts.maker_valid;
        for (i, &maker) in makers.iter().enumerate() {
            maker_valid.set(maker, status[i]);
        }
        emit!(ChangeMakers {
            state_key: state.key(),
            new_makers: makers,
        });
        Ok(())
    }

pub fn inbox(ctx: Context<Inbox>, amount: u64, data: Vec<u8>) -> Result<()> {
        let state = &ctx.accounts.state;
        require!(!state.paused, ErrorCode::ContractPaused);
        let maker_valid = &mut ctx.accounts.maker_valid;
        let if_maker_valid = maker_valid.get(ctx.accounts.user.key()).unwrap_or(false);
        require!(if_maker_valid, ErrorCode::NotMaker);
        let required_fee = state.fee;
        let fee_amount = amount
            .checked_mul(required_fee)
            .and_then(|v| v.checked_div(10000))
            .ok_or(ErrorCode::InsufficientAmount)?;
        let real_in_amount = amount.checked_sub(fee_amount).ok_or(ErrorCode::Overflow)?;

require!(fee_amount <= real_in_amount, ErrorCode::InvalidFeeAmount);
        //Transfer fee to feeReceiver

if fee_amount > 0 {
            // Transfer fee to feeReceiver
            let cpi_accounts = Transfer {
                from: ctx.accounts.source.to_account_info(),
                to: ctx.accounts.fee_destination.to_account_info(),
                authority: ctx.accounts.user.to_account_info(),
            };
            let cpi_program = ctx.accounts.token_program.to_account_info();
            let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
            token::transfer(cpi_ctx, fee_amount)?;

emit!(InboxFeeEvent {
                token: ctx.accounts.contract_token_account.key(),
                sender: ctx.accounts.user.key(),
                fee_receiver: state.fee_receiver.key(),
                fee_amount: fee_amount,
            });
        }

// Transfer tokens inbox(state)
        let cpi_accounts = Transfer {
            from: ctx.accounts.contract_token_account.to_account_info(),
            to: ctx.accounts.destination.to_account_info(),
            authority: ctx.accounts.user.to_account_info(),
        };
        let cpi_program = ctx.accounts.token_program.to_account_info();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, real_in_amount)?;

emit!(InboxEvent {
            token: ctx.accounts.contract_token_account.key(),
            sender: ctx.accounts.user.key(),
            receiver: ctx.accounts.destination.key(),
            amount: real_in_amount,
            data: data,
        });
        Ok(())
    }

pub fn outbox(ctx: Context<Outbox>, amount: u64, data: Vec<u8>) -> Result<()> {
        let state = &ctx.accounts.state;
        require!(!state.paused, ErrorCode::ContractPaused);
        let maker_valid = &mut ctx.accounts.maker_valid;
        let if_maker_valid = maker_valid.get(ctx.accounts.user.key()).unwrap_or(false);
        require!(if_maker_valid, ErrorCode::NotMaker);

//Token Transfer
        // let seeds = &[&[state.bump]];
        // let signer_seeds = &[&seeds[..]];

// let seeds = b"authority";
        // let bump = state.bump;
        // let signer: &[&[&[u8]]] = &[&[seeds, &[bump]]];

let state_key = state.key();
        let seeds = &[b"authority", state_key.as_ref(), &[state.bump]];
        let signer_seeds = &[&seeds[..]];

let cpi_accounts = Transfer {
            from: ctx.accounts.source.to_account_info(),
            to: ctx.accounts.destination.to_account_info(),
            authority: ctx.accounts.contract_authority.to_account_info(),
        };
        let cpi_program = ctx.accounts.token_program.to_account_info();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer_seeds);
        token::transfer(cpi_ctx, amount)?;

emit!(OutboxEvent {
            token: ctx.accounts.contract_token_account.key(),
            sender: ctx.accounts.source.key(),
            receiver: ctx.accounts.destination.key(),
            amount: amount,
            data: data,
        });
        Ok(())
    }

}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init, payer = user, space = 8 + 256)]
    pub state: Account<'info, InitializeState>,
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct SetMakerList<'info> {
    pub state: Account<'info, InitializeState>,
    #[account(init, payer = user, space = 8 + 1024)]
    pub maker_valid: Account<'info, MappingMakerToBool>,
    #[account(mut)]
    pub user: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct Inbox<'info> {
    pub state: Account<'info, InitializeState>,
    #[account(mut)]
    pub user: Signer<'info>,
    #[account(mut)]
    pub source: Account<'info, TokenAccount>,
    #[account(mut)]
    pub destination: Account<'info, TokenAccount>,
    #[account(mut)]
    pub fee_destination: Account<'info, TokenAccount>,
    #[account(mut)]
    pub contract_token_account: Account<'info, TokenAccount>,
    pub token_program: Program<'info, Token>,
    pub system_program: Program<'info, System>,
    pub maker_valid: Account<'info, MappingMakerToBool>,
}

#[derive(Accounts)]
pub struct Outbox<'info> {
    pub state: Account<'info, InitializeState>,
    #[account(mut)]
    pub user: Signer<'info>,
    #[account(mut)]
    pub contract_token_account: Account<'info, TokenAccount>,
    #[account(mut)]
    pub source: Account<'info, TokenAccount>,
    #[account(mut)]
    pub destination: Account<'info, TokenAccount>,
    #[account(seeds = [b"authority", state.key().as_ref()],bump = state.bump)]
    pub contract_authority: AccountInfo<'info>,
    pub token_program: Program<'info, Token>,
    pub maker_valid: Account<'info, MappingMakerToBool>,
}

#[account]
pub struct InitializeState {
    pub bump: u8,
    pub program_pda: Pubkey,
    pub owner: Pubkey,
    pub paused: bool,
    pub fee: u64,
    pub fee_receiver: Pubkey,
    pub initialized: bool,
}

#[error_code]
pub enum ErrorCode {
    #[msg("No permission to perform this action.")]
    NoPermission,
    #[msg("Initialization has been performed.")]
    AlreadyInitialized,
    #[msg("Insufficient amount.")]
    InsufficientAmount,
    #[msg("Contract is paused.")]
    ContractPaused,
    #[msg("Invalid length.")]
    InvalidLength,
    #[msg("Invalid fee amount")]
    InvalidFeeAmount,
    #[msg("Overflow")]
    Overflow,
    #[msg("Not a maker.")]
    NotMaker,
    #[msg("Fee over 10000.")]
    FeeOver10000,
    #[msg("Not a manager")]
    NotManager,
}

#[event]
pub struct OwnerChangeEvent {
    pub old_owner: Pubkey,
    pub new_owner: Pubkey,
}

#[event]
pub struct ChangeMakers {
    pub state_key: Pubkey,
    pub new_makers: Vec<Pubkey>,
}

#[event]
pub struct InboxEvent {
    pub token: Pubkey,
    pub sender: Pubkey,
    pub receiver: Pubkey,
    pub amount: u64,
    pub data: Vec<u8>,
}

#[event]
pub struct InboxFeeEvent {
    pub token: Pubkey,
    pub sender: Pubkey,
    pub fee_receiver: Pubkey,
    pub fee_amount: u64,
}

#[event]
pub struct OutboxEvent {
    pub token: Pubkey,
    pub sender: Pubkey,
    pub receiver: Pubkey,
    pub amount: u64,
    pub data: Vec<u8>,
}

```

use anchor_lang::prelude::*;
use anchor_lang::solana_program::system_instruction;
use anchor_spl::token::{self, Token, TokenAccount, Transfer};

#[account]
pub struct MappingMakerToBool {
    pub mappings: Vec&lt;PubkeyBoolPair>,
}
impl MappingMakerToBool {
    pub fn set(&mut self, key: Pubkey, value: bool) {
        if let Some(pair) = self.mappings.iter_mut().find(|pair| pair.key == key) {
            pair.value = value;
        } else {
            self.mappings.push(PubkeyBoolPair { key, value });
        }
    }

    pub fn get(&self, key: Pubkey) -> Option&lt;bool> {
        self.mappings
            .iter()
            .find(|pair| pair.key == key)
            .map(|pair| pair.value)
    }
}

#[program]
mod test {
 //初始化
    pub fn initialize(
        ctx: Context&lt;Initialize>,
        owner: Pubkey,
        fee: u64,
        fee_receiver: Pubkey,
        paused: bool,
    ) -> Result&lt;()> {
        let init_state = &mut ctx.accounts.state;
        // require!(
        //     ctx.accounts.user.key().to_string() == INIT_OPERATOR,
        //     ErrorCode::NoPermission
        // );
        // 确保只能调用一次
        require!(!init_state.initialized, ErrorCode::AlreadyInitialized);

        let (pda, bump) = Pubkey::find_program_address(
            &[b"authority", init_state.key().as_ref()],
            ctx.program_id,
        );
        // PDA seeds and bump to "sign" for CPI
        // let seeds = b"authority";
        // let bump = ctx.bumps.reward_token_mint;
        // let signer: &[&[&[u8]]] = &[&[seeds, &[bump]]];

        require!(fee &lt;= 10000, ErrorCode::FeeOver10000);
        init_state.bump = bump;
        init_state.program_pda = pda;

        init_state.owner = owner;
        init_state.fee = fee;
        init_state.fee_receiver = fee_receiver;

        init_state.paused = paused;
        init_state.initialized = true; 
        Ok(())
    }

 pub fn set_maker_list(
        ctx: Context&lt;SetMakerList>,
        makers: Vec&lt;Pubkey>,
        status: Vec&lt;bool>,
    ) -> Result&lt;()> {
        let state = &mut ctx.accounts.state;
        require!(
            state.owner == ctx.accounts.user.key(),
            ErrorCode::NoPermission
        );
        require!(makers.len() == status.len(), ErrorCode::InvalidLength);
        let maker_valid = &mut ctx.accounts.maker_valid;
        for (i, &maker) in makers.iter().enumerate() {
            maker_valid.set(maker, status[i]);
        }
        emit!(ChangeMakers {
            state_key: state.key(),
            new_makers: makers,
        });
        Ok(())
    }

pub fn inbox(ctx: Context&lt;Inbox>, amount: u64, data: Vec&lt;u8>) -> Result&lt;()> {
        let state = &ctx.accounts.state;
        require!(!state.paused, ErrorCode::ContractPaused);
        let maker_valid = &mut ctx.accounts.maker_valid;
        let if_maker_valid = maker_valid.get(ctx.accounts.user.key()).unwrap_or(false);
        require!(if_maker_valid, ErrorCode::NotMaker);
        let required_fee = state.fee;
        let fee_amount = amount
            .checked_mul(required_fee)
            .and_then(|v| v.checked_div(10000))
            .ok_or(ErrorCode::InsufficientAmount)?;
        let real_in_amount = amount.checked_sub(fee_amount).ok_or(ErrorCode::Overflow)?;

        require!(fee_amount &lt;= real_in_amount, ErrorCode::InvalidFeeAmount);
        //Transfer fee to feeReceiver

        if fee_amount > 0 {
            // Transfer fee to feeReceiver
            let cpi_accounts = Transfer {
                from: ctx.accounts.source.to_account_info(),
                to: ctx.accounts.fee_destination.to_account_info(),
                authority: ctx.accounts.user.to_account_info(),
            };
            let cpi_program = ctx.accounts.token_program.to_account_info();
            let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
            token::transfer(cpi_ctx, fee_amount)?;

            emit!(InboxFeeEvent {
                token: ctx.accounts.contract_token_account.key(),
                sender: ctx.accounts.user.key(),
                fee_receiver: state.fee_receiver.key(),
                fee_amount: fee_amount,
            });
        }

        // Transfer tokens inbox(state)
        let cpi_accounts = Transfer {
            from: ctx.accounts.contract_token_account.to_account_info(),
            to: ctx.accounts.destination.to_account_info(),
            authority: ctx.accounts.user.to_account_info(),
        };
        let cpi_program = ctx.accounts.token_program.to_account_info();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, real_in_amount)?;

        emit!(InboxEvent {
            token: ctx.accounts.contract_token_account.key(),
            sender: ctx.accounts.user.key(),
            receiver: ctx.accounts.destination.key(),
            amount: real_in_amount,
            data: data,
        });
        Ok(())
    }

    pub fn outbox(ctx: Context&lt;Outbox>, amount: u64, data: Vec&lt;u8>) -> Result&lt;()> {
        let state = &ctx.accounts.state;
        require!(!state.paused, ErrorCode::ContractPaused);
        let maker_valid = &mut ctx.accounts.maker_valid;
        let if_maker_valid = maker_valid.get(ctx.accounts.user.key()).unwrap_or(false);
        require!(if_maker_valid, ErrorCode::NotMaker);

        //Token Transfer
        // let seeds = &[&[state.bump]];
        // let signer_seeds = &[&seeds[..]];

        // let seeds = b"authority";
        // let bump = state.bump;
        // let signer: &[&[&[u8]]] = &[&[seeds, &[bump]]];

        let state_key = state.key();
        let seeds = &[b"authority", state_key.as_ref(), &[state.bump]];
        let signer_seeds = &[&seeds[..]];

        let cpi_accounts = Transfer {
            from: ctx.accounts.source.to_account_info(),
            to: ctx.accounts.destination.to_account_info(),
            authority: ctx.accounts.contract_authority.to_account_info(),
        };
        let cpi_program = ctx.accounts.token_program.to_account_info();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer_seeds);
        token::transfer(cpi_ctx, amount)?;

        emit!(OutboxEvent {
            token: ctx.accounts.contract_token_account.key(),
            sender: ctx.accounts.source.key(),
            receiver: ctx.accounts.destination.key(),
            amount: amount,
            data: data,
        });
        Ok(())
    }

}

#[derive(Accounts)]
pub struct Initialize&lt;'info> {
    #[account(init, payer = user, space = 8 + 256)]
    pub state: Account&lt;'info, InitializeState>,
    #[account(mut)]
    pub user: Signer&lt;'info>,
    pub system_program: Program&lt;'info, System>,
}

#[derive(Accounts)]
pub struct SetMakerList&lt;'info> {
    pub state: Account&lt;'info, InitializeState>,
    #[account(init, payer = user, space = 8 + 1024)]
    pub maker_valid: Account&lt;'info, MappingMakerToBool>,
    #[account(mut)]
    pub user: Signer&lt;'info>,
    pub system_program: Program&lt;'info, System>,
}

#[derive(Accounts)]
pub struct Inbox&lt;'info> {
    pub state: Account&lt;'info, InitializeState>,
    #[account(mut)]
    pub user: Signer&lt;'info>,
    #[account(mut)]
    pub source: Account&lt;'info, TokenAccount>,
    #[account(mut)]
    pub destination: Account&lt;'info, TokenAccount>,
    #[account(mut)]
    pub fee_destination: Account&lt;'info, TokenAccount>,
    #[account(mut)]
    pub contract_token_account: Account&lt;'info, TokenAccount>,
    pub token_program: Program&lt;'info, Token>,
    pub system_program: Program&lt;'info, System>,
    pub maker_valid: Account&lt;'info, MappingMakerToBool>,
}

#[derive(Accounts)]
pub struct Outbox&lt;'info> {
    pub state: Account&lt;'info, InitializeState>,
    #[account(mut)]
    pub user: Signer&lt;'info>,
    #[account(mut)]
    pub contract_token_account: Account&lt;'info, TokenAccount>,
    #[account(mut)]
    pub source: Account&lt;'info, TokenAccount>,
    #[account(mut)]
    pub destination: Account&lt;'info, TokenAccount>,
    #[account(seeds = [b"authority", state.key().as_ref()],bump = state.bump)]
    pub contract_authority: AccountInfo&lt;'info>,
    pub token_program: Program&lt;'info, Token>,
    pub maker_valid: Account&lt;'info, MappingMakerToBool>,
}

#[account]
pub struct InitializeState {
    pub bump: u8,
    pub program_pda: Pubkey,
    pub owner: Pubkey,
    pub paused: bool,
    pub fee: u64,
    pub fee_receiver: Pubkey,
    pub initialized: bool,
}

#[error_code]
pub enum ErrorCode {
    #[msg("No permission to perform this action.")]
    NoPermission,
    #[msg("Initialization has been performed.")]
    AlreadyInitialized,
    #[msg("Insufficient amount.")]
    InsufficientAmount,
    #[msg("Contract is paused.")]
    ContractPaused,
    #[msg("Invalid length.")]
    InvalidLength,
    #[msg("Invalid fee amount")]
    InvalidFeeAmount,
    #[msg("Overflow")]
    Overflow,
    #[msg("Not a maker.")]
    NotMaker,
    #[msg("Fee over 10000.")]
    FeeOver10000,
    #[msg("Not a manager")]
    NotManager,
}

#[event]
pub struct OwnerChangeEvent {
    pub old_owner: Pubkey,
    pub new_owner: Pubkey,
}

#[event]
pub struct ChangeMakers {
    pub state_key: Pubkey,
    pub new_makers: Vec&lt;Pubkey>,
}

#[event]
pub struct InboxEvent {
    pub token: Pubkey,
    pub sender: Pubkey,
    pub receiver: Pubkey,
    pub amount: u64,
    pub data: Vec&lt;u8>,
}

#[event]
pub struct InboxFeeEvent {
    pub token: Pubkey,
    pub sender: Pubkey,
    pub fee_receiver: Pubkey,
    pub fee_amount: u64,
}

#[event]
pub struct OutboxEvent {
    pub token: Pubkey,
    pub sender: Pubkey,
    pub receiver: Pubkey,
    pub amount: u64,
    pub data: Vec&lt;u8>,
}

0 条评论
分类：Solana

默认排序时间排序

1 个回答

NPC.李括 11小时前

要实现将任何 SPL Token 通过 inbox 转移到当前程序账户，并通过 outbox 从当前程序账户转移到用户，你的代码总体思路是正确的，但可能存在一些细节上的问题。以下是一些建议和改进点，帮助你更好地实现这个功能。

主要改进点

1. 检查账户的初始化状态：

确保所有涉及的账户（如 source、destination、contract_token_account 和 fee_destination）都已正确初始化，并且具有正确的 SPL Token 余额。

2. 确保正确的 Token Account：

在 inbox 和 outbox 函数中，确保 source 和 destination 是正确的 TokenAccount。这意味着你需要确保它们与所处理的 SPL Token 兼容。

3. 费用和金额的处理：

在 inbox 函数中，你需要确保在转账时正确计算费用，并且在执行转账之前检查合约的状态是否允许执行此操作。

4. 合约权限：

确保合约调用者具有必要的权限。你已经通过 maker_valid 检查了调用者是否是允许的制作者，这很好。
<br>
修正代码示例

以下是对你的 inbox 和 outbox 函数的改进代码示例：

`rust`

```
pub fn inbox(ctx: Context<Inbox>, amount: u64, data: Vec<u8>) -> Result<()> {
    let state = &ctx.accounts.state;
    require!(!state.paused, ErrorCode::ContractPaused);
    
    let maker_valid = &ctx.accounts.maker_valid;
    let if_maker_valid = maker_valid.get(ctx.accounts.user.key()).unwrap_or(false);
    require!(if_maker_valid, ErrorCode::NotMaker);

let required_fee = state.fee;
    let fee_amount = amount
        .checked_mul(required_fee)
        .and_then(|v| v.checked_div(10000))
        .ok_or(ErrorCode::InsufficientAmount)?;
    let real_in_amount = amount.checked_sub(fee_amount).ok_or(ErrorCode::Overflow)?;

// 确保费用和实际转入金额有效
    require!(fee_amount <= amount, ErrorCode::InvalidFeeAmount);
    
    // Transfer fee to feeReceiver
    if fee_amount > 0 {
        let cpi_accounts = Transfer {
            from: ctx.accounts.source.to_account_info(),
            to: ctx.accounts.fee_destination.to_account_info(),
            authority: ctx.accounts.user.to_account_info(),
        };
        let cpi_program = ctx.accounts.token_program.to_account_info();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, fee_amount)?;

emit!(InboxFeeEvent {
            token: ctx.accounts.contract_token_account.key(),
            sender: ctx.accounts.user.key(),
            fee_receiver: state.fee_receiver.key(),
            fee_amount,
        });
    }

// Transfer tokens to the contract's destination
    let cpi_accounts = Transfer {
        from: ctx.accounts.source.to_account_info(),
        to: ctx.accounts.contract_token_account.to_account_info(),
        authority: ctx.accounts.user.to_account_info(),
    };
    let cpi_ctx = CpiContext::new(ctx.accounts.token_program.to_account_info(), cpi_accounts);
    token::transfer(cpi_ctx, real_in_amount)?;

emit!(InboxEvent {
        token: ctx.accounts.contract_token_account.key(),
        sender: ctx.accounts.user.key(),
        receiver: ctx.accounts.contract_token_account.key(),
        amount: real_in_amount,
        data,
    });

Ok(())
}

pub fn outbox(ctx: Context<Outbox>, amount: u64, data: Vec<u8>) -> Result<()> {
    let state = &ctx.accounts.state;
    require!(!state.paused, ErrorCode::ContractPaused);
    
    let maker_valid = &ctx.accounts.maker_valid;
    let if_maker_valid = maker_valid.get(ctx.accounts.user.key()).unwrap_or(false);
    require!(if_maker_valid, ErrorCode::NotMaker);

let cpi_accounts = Transfer {
        from: ctx.accounts.contract_token_account.to_account_info(),
        to: ctx.accounts.destination.to_account_info(),
        authority: ctx.accounts.contract_authority.to_account_info(),
    };
    let cpi_program = ctx.accounts.token_program.to_account_info();
    
    let seeds = &[b"authority", state.key().as_ref(), &[state.bump]];
    let signer_seeds = &[&seeds[..]];
    
    let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer_seeds);
    token::transfer(cpi_ctx, amount)?;

emit!(OutboxEvent {
        token: ctx.accounts.contract_token_account.key(),
        sender: ctx.accounts.contract_token_account.key(),
        receiver: ctx.accounts.destination.key(),
        amount,
        data,
    });

Ok(())
}
```

其他建议

a. 详细的错误处理：确保对所有可能的错误情况进行处理，以便在出错时能够给出清晰的反馈。

b. 测试合约：在真实的 Solana 网络上部署之前，确保在本地或测试网络上充分测试合约，以确保其按预期工作。

c. 文档和注释：在代码中添加注释，以便其他开发者（或未来的你）能够理解每个部分的作用。