yqq's blog

#[allow(clippy::too_many_arguments)]
fn create_account(
    from_account_index: IndexOfAccount,
    to_account_index: IndexOfAccount,
    to_address: &Address,
    lamports: u64,
    space: u64,
    owner: &Pubkey, // 根据上面分析可知，owner即是 TOKEN_PROGRAM_ID
    signers: &HashSet<Pubkey>,
    invoke_context: &InvokeContext,
    transaction_context: &TransactionContext,
    instruction_context: &InstructionContext,
) -> Result<(), InstructionError> {
    // if it looks like the `to` account is already in use, bail
    {
        let mut to = instruction_context
            .try_borrow_instruction_account(transaction_context, to_account_index)?;

        // 如果账户已经存在，则不能创建
        if to.get_lamports() > 0 {
            ic_msg!(
                invoke_context,
                "Create Account: account {:?} already in use",
                to_address
            );
            return Err(SystemError::AccountAlreadyInUse.into());
        }
        // 注意， 到此处为止， token mint的owner 是 SYSTEM_PROGRAM_ID

        // 分配空间， 并指派owner权限
        allocate_and_assign(&mut to, to_address, space, owner, signers, invoke_context)?;
    }

    // 注意， 到这里为止， token mint的owner 已经是 owner, 即 TOKEN_PROGRAM_ID

    // 交租金
    transfer(
        from_account_index,
        to_account_index,
        lamports,
        invoke_context,
        transaction_context,
        instruction_context,
    )
}

// 源码 https://github.com/solana-labs/solana/blob/27eff8408b7223bb3c4ab70523f8a8dca3ca6645/programs/system/src/system_processor.rs#L132
fn allocate_and_assign(
    to: &mut BorrowedAccount,
    to_address: &Address,
    space: u64,
    owner: &Pubkey,
    signers: &HashSet<Pubkey>,
    invoke_context: &InvokeContext,
) -> Result<(), InstructionError> {
    // 为新账户分配空间
    allocate(to, to_address, space, signers, invoke_context)?;

    // 为新账户指派owner
    assign(to, to_address, owner, signers, invoke_context)


}

//  源码  https://github.com/solana-labs/solana/blob/27eff8408b7223bb3c4ab70523f8a8dca3ca6645/programs/system/src/system_processor.rs#L70
fn allocate(
    account: &mut BorrowedAccount,
    address: &Address,
    space: u64,
    signers: &HashSet<Pubkey>,
    invoke_context: &InvokeContext,
) -> Result<(), InstructionError> {

    // 需要 Token Mint账户的签名
    if !address.is_signer(signers) {
        ic_msg!(
            invoke_context,
            "Allocate: 'to' account {:?} must sign",
            address
        );
        return Err(InstructionError::MissingRequiredSignature);
    }

    // if it looks like the `to` account is already in use, bail
    //   (note that the id check is also enforced by message_processor)
    if !account.get_data().is_empty() || !system_program::check_id(account.get_owner()) {
        ic_msg!(
            invoke_context,
            "Allocate: account {:?} already in use",
            address
        );
        return Err(SystemError::AccountAlreadyInUse.into());
    }

    if space > MAX_PERMITTED_DATA_LENGTH {
        ic_msg!(
            invoke_context,
            "Allocate: requested {}, max allowed {}",
            space,
            MAX_PERMITTED_DATA_LENGTH
        );
        return Err(SystemError::InvalidAccountDataLength.into());
    }

    // 设置账户空间
    account.set_data_length(space as usize)?;

    Ok(())
}


//  源码  https://github.com/solana-labs/solana/blob/27eff8408b7223bb3c4ab70523f8a8dca3ca6645/programs/system/src/system_processor.rs#L112
fn assign(
    account: &mut BorrowedAccount,
    address: &Address,
    owner: &Pubkey,
    signers: &HashSet<Pubkey>,
    invoke_context: &InvokeContext,
) -> Result<(), InstructionError> {
    // no work to do, just return
    if account.get_owner() == owner {
        return Ok(());
    }

    // 需要 Token Mint账户的签名
    if !address.is_signer(signers) {
        ic_msg!(invoke_context, "Assign: account {:?} must sign", address);
        return Err(InstructionError::MissingRequiredSignature);
    }

    // 设置owner
    account.set_owner(&owner.to_bytes())
}

/// Processes an [InitializeMint2](enum.TokenInstruction.html) instruction.
pub fn process_initialize_mint2(
    accounts: &[AccountInfo],
    decimals: u8,
    mint_authority: Pubkey,
    freeze_authority: COption<Pubkey>,
) -> ProgramResult {
    Self::_process_initialize_mint(accounts, decimals, mint_authority, freeze_authority, false)
}

fn _process_initialize_mint(
    accounts: &[AccountInfo],
    decimals: u8,
    mint_authority: Pubkey,
    freeze_authority: COption<Pubkey>,
    rent_sysvar_account: bool,
) -> ProgramResult {
    let account_info_iter = &mut accounts.iter();

    //
    let mint_info = next_account_info(account_info_iter)?;
    let mint_data_len = mint_info.data_len();
    let rent = if rent_sysvar_account {
        Rent::from_account_info(next_account_info(account_info_iter)?)?
    } else {
        Rent::get()?
    };

    let mut mint = Mint::unpack_unchecked(&mint_info.data.borrow())?;
    if mint.is_initialized {
        return Err(TokenError::AlreadyInUse.into());
    }

    if !rent.is_exempt(mint_info.lamports(), mint_data_len) {
        return Err(TokenError::NotRentExempt.into());
    }

    mint.mint_authority = COption::Some(mint_authority);
    mint.decimals = decimals;
    mint.is_initialized = true;
    mint.freeze_authority = freeze_authority;


    // 将mint结构体，序列化到 mint_info.data， 这里需要提供mint_info的写入权限
    Mint::pack(mint, &mut mint_info.data.borrow_mut())?;

    Ok(())
}