NTF Store - Phantasia Sports

Rust compiler requires the program developer to set the TREASURY_ATA_PUBKEY environment variable to build the program. The BuyNft and BuyEdition instruction handlers use the value of this variable to get the fee vault address. Since this address is hardcoded at compile time, it cannot be modified without redeploying the program if the account compromised.

Code Location

processor/buy_nft.rs

let transaction_fee_fant_ata_id = Pubkey::from_str(env!(
    "TREASURY_ATA_PUBKEY",
    "Must specify a treasury ATA account public key!"
))
.map_err(|_| PhantasiaError::StringToPubkeyConversionFailed)?;
if *transaction_fee_fant_ata.key != transaction_fee_fant_ata_id {
    msg!(
        "PhantasiaError::TransactionFeeFantAtaMismatched EXPECTED: {:?} ACTUAL: {:?}",
        transaction_fee_fant_ata_id,
        transaction_fee_fant_ata.key
    );
    return Err(PhantasiaError::TransactionFeeFantAtaMismatched.into());
}

processor/buy_edition.rs

let transaction_fee_fant_ata_id = Pubkey::from_str(env!(
    "TREASURY_ATA_PUBKEY",
    "Must specify a treasury ATA account public key!"
))
.map_err(|_| PhantasiaError::StringToPubkeyConversionFailed)?;
if *transaction_fee_fant_ata.key != transaction_fee_fant_ata_id {
    msg!(
        "PhantasiaError::TransactionFeeFantAtaMismatched EXPECTED: {:?} ACTUAL: {:?}",
        transaction_fee_fant_ata_id,
        transaction_fee_fant_ata.key
    );
    return Err(PhantasiaError::TransactionFeeFantAtaMismatched.into());
}

ACKNOWLEDGED: The Phantasia Sports team accepts the risk of this finding.

The program creates two types of NFT sell orders: SellOrder and LimitedEditionSale. NFTs may be either single- or multiple edition. Edition ID is stored in NFT metadata as edition_nonce. Editions are identified with u8 integer, but for single edition NFTs this property is set to None.

Neither the ListNftForSale nor the ListEditionForSale instruction handler checks the value of the edition_nonce property, which means the NFT owner may place a SellOrder order for a multiple edition NFT and a LimitedEditionSale order for a single edition NFT.

Code Location

processor/list_nft.rs

if !rent.is_exempt(
    selling_nft_token_account.lamports(),
    selling_nft_token_account.data_len(),
) {
    msg!("PhantasiaError::NotRentExempt");
    return Err(PhantasiaError::NotRentExempt.into());
}

validate_nft(
    selling_nft_mint_account,
    selling_nft_token_account,
    selling_nft_metadata_account,
    seller_wallet_account.key,
)?;

processor/list_nft.rs

pub fn validate_nft(
    nft_mint: &AccountInfo,
    nft_token_account: &AccountInfo,
    metadata_info: &AccountInfo,
    seller_wallet_pubkey: &Pubkey,
) -> ProgramResult {
    let verified_creators: [Pubkey; NUM_VERIFIED_CREATORS] = [
        vc1_id::id(), // This is our main wallet
        vc2_id::id(),
        vc3_id::id(),
        vc4_id::id(),
        vc5_id::id(),
        vc6_id::id(), // Phanbot creator
    ];
    validate_metadata_account(metadata_info, nft_mint.key)?;

    if *nft_token_account.owner != spl_token::id() {
        msg!("PhantasiaError::AccountOwnerShouldBeTokenProgram");
        return Err(PhantasiaError::AccountOwnerShouldBeTokenProgram.into());
    }

processor/list_nft.rs

pub fn validate_nft(
    nft_mint: &AccountInfo,
    nft_token_account: &AccountInfo,
    metadata_info: &AccountInfo,
    seller_wallet_pubkey: &Pubkey,
) -> ProgramResult {
    let verified_creators: [Pubkey; NUM_VERIFIED_CREATORS] = [
        vc1_id::id(), // This is our main wallet
        vc2_id::id(),
        vc3_id::id(),
        vc4_id::id(),
        vc5_id::id(),
        vc6_id::id(), // Phanbot creator
    ];
    validate_metadata_account(metadata_info, nft_mint.key)?;

    if *nft_token_account.owner != spl_token::id() {
        msg!("PhantasiaError::AccountOwnerShouldBeTokenProgram");
        return Err(PhantasiaError::AccountOwnerShouldBeTokenProgram.into());
    }

processor/list_nft.rs

pub fn validate_metadata_account(metadata_info: &AccountInfo, nft_mint: &Pubkey) -> ProgramResult {
    verify_metadata_account_owner(metadata_info.owner)?;
    let metadata_program_id = metadata_program_id::id();
    let metadata_seeds = &[
        metaplex_state::PREFIX.as_bytes(),
        metadata_program_id.as_ref(),
        nft_mint.as_ref(),
    ];
    let (metadata_address, _) =
        Pubkey::find_program_address(metadata_seeds, &metadata_program_id::id());

    if metadata_address != *metadata_info.key {
        msg!("PhantasiaError::MetadataAccountMismatched");
        return Err(PhantasiaError::MetadataAccountMismatched.into());
    }
    Ok(())
}

SOLVED: The Phantasia Sports team fixed this issue in commit 6b36c56025ae1ed8bfc869dc7015413a25e1b8b3: the value of edition_nonce is checked in the validate_nft function, used by ListNftForSale and ListEditionForSale, to verify that it is expected sales order type.

The program calculates the FANT amount the seller receives with the get_fants_to_receive_from_basis_points function. This function takes a u64 selling_price and u16 basis_points and performs some arithmetic operations on them. The result is cast to u64 to match the type of the amount field of SPL Token's Account struct.

Before casting however the result is not verified to not exceed the maximum value allowed by the u64 type which can lead to integer overflow.

Code Location

processor/buy_nft.rs

pub fn get_fants_to_receive_from_basis_points(
    selling_price: u64,
    basis_points: u16,
) -> Result<u64, ProgramError> {
    let amount_to_receive = (selling_price as u128)
        .checked_mul(basis_points as u128)
        .ok_or(PhantasiaError::MathOverflow)?
        .checked_div(10000u128)
        .ok_or(PhantasiaError::MathOverflow)? as u64;
    return Ok(amount_to_receive);
}

SOLVED: The Phantasia Sports team fixed this issue in commit 6b36c56025ae1ed8bfc869dc7015413a25e1b8b3: the amount_to_receive is verified to not exceed the maximum value allowed by the u64 type to avoid an integer overflow.

The ListEditionForSale instruction handler requires the NFT owner to provide some parameters, including number_to_sell and num_sold. The former denotes the total number of NTFs available, and the latter stores the number of NFTs sold to date.

The handler does not verify if num_sold is lower than number_to_sell which means it is possible to place a sell order on an NFT edition where the number of sold tokens exceeds the number of tokens available for sale.

Code Location

processor/list_edition.rs

pub fn process_list_edition_nft(
    accounts: &[AccountInfo],
    program_id: &Pubkey,
    sale_price: u64,
    number_to_sell: u16,
    num_sold: u16
) -> ProgramResult {
    let account_info_iter = &mut accounts.iter();
    let seller_wallet_account = next_account_info(account_info_iter)?;

processor/list_edition.rs

let sell_order_data: LimitedEditionSale = LimitedEditionSale {
    acc_type: AccTypesWithVersion::LimitedEditionSaleDataV1 as u8,
    seller_wallet: *seller_wallet_account.key,
    nft_token: *selling_nft_token_account.key,
    selling_price: sale_price,
    number_purchased: num_sold,
    number_to_sell: number_to_sell,
    nonce: bump_seed,
};

SOLVED: The Phantasia Sports team fixed this issue in commit 32ff199c83cdedf061aaeef706c75c9a4c7ed510: the num_sold is verified not to exceed the number of available tokens, number_to_sell.

The intention and use of helper methods in Rust, like unwrap, is very useful for testing environments because a value is forcibly demanded to get an error (aka panic!) if the Option the methods is called on doesn't have Some value or Result. Nevertheless, leaving unwrap functions in production environments is a bad practice because not only will this cause the program to crash out, or panic!. In addition, no helpful messages are shown to help the user solve, or understand the reason of the error.

Code Location

processor/list_nft.rs

let metadata = Metadata::from_account_info(metadata_info)?;
let nft_creators = metadata.data.creators.unwrap();
let mut is_fake_nft = true;
for creator in nft_creators {
    if creator.verified && is_verified_creator(&creator.address, &verified_creators)? {
        is_fake_nft = false;
        break;
    }
}

SOLVED: The Phantasia Sports team fixed this issue in commit 68463a47fdd1a9be18b14ead9891806cb96be9d9: any use of the unwrap function has been removed and replaced by more secure methods such as error propagation.

Both BuyNft and BuyEdition instruction handlers expect the transaction sender to provide the buyer_nft_fant_ata FANT token account to charge and buyer_wallet_account to authorize the transfer. If it is successful, the NFT's authority is transferred to buyer_wallet_account.

In the SPL Token program, an account delegate is defined as an account authorized to transfer an owner-approved share of tokens out of the account.

Neither the BuyNft nor BuyEdition instruction handler verifies if buyer_wallet_account is the owner of the buyer_nft_fant_ata account rather than just a delegate which means if the transaction is signed by a delegate, the NFT's authority will be transferred to the delegate instead of the buyer_nft_fant_ata account owner.

Code Location

processor/buy_nft.rs

pub fn process_buy_nft(accounts: &[AccountInfo], program_id: &Pubkey) -> ProgramResult {
    let account_info_iter = &mut accounts.iter();
    let buyer_wallet_account = next_account_info(account_info_iter)?;
    let buyer_nft_fant_ata = next_account_info(account_info_iter)?;

processor/buy_nft.rs

if !buyer_wallet_account.is_signer {
        msg!("ProgramError::MissingRequiredSignature");
        return Err(ProgramError::MissingRequiredSignature);
    }

the only check on buyer_wallet_account

processor/buy_nft.rs

if !buyer_wallet_account.is_signer {
        msg!("ProgramError::MissingRequiredSignature");
        return Err(ProgramError::MissingRequiredSignature);
    }

processor/buy_edition.rs

let mint_authority_info = next_account_info(account_info_iter)?;
let buyer_wallet_account = next_account_info(account_info_iter)?;
let nft_store_signer_pda_account = next_account_info(account_info_iter)?;
let master_edition_token_account_info = next_account_info(account_info_iter)?;
let update_authority_info = next_account_info(account_info_iter)?;
let master_metadata_account_info = next_account_info(account_info_iter)?;
let token_program_account_info = next_account_info(account_info_iter)?;
let system_account_info = next_account_info(account_info_iter)?;
let rent_info = next_account_info(account_info_iter)?;
let metadata_program_id_account = next_account_info(account_info_iter)?;
let metadata_mint_info = next_account_info(account_info_iter)?;

let buyer_nft_fant_ata = next_account_info(account_info_iter)?;

the only check on buyer_wallet_account

processor/buy_edition.rs

if !buyer_wallet_account.is_signer {
        msg!("ProgramError::MissingRequiredSignature");
        return Err(ProgramError::MissingRequiredSignature);
    }

ACKNOWLEDGED: The Phantasia Sports team do not believe that any of the platform users are going to ever use delegation to purchase NFTs from the store.

NFT owners can post sell orders on NFTs or NFT editions. When a user buys a single-edition NFT, a fixed percentage is deducted from the ask price and transferred to the fee vault. When a user buys an NFT edition, however, 100% of the ask price is transferred to the fee vault and the NFT owner receives nothing.

Code Location

processor/buy_edition.rs

let seller_to_receive_fants = sell_order_data.selling_price;

msg!("Calling the token program to transfer FANT to Treasury...");
invoke(
    &spl_token::instruction::transfer(
        token_program_account_info.key,
        buyer_nft_fant_ata.key,
        transaction_fee_fant_ata.key,
        buyer_wallet_account.key,
        &[],
        seller_to_receive_fants,
    )?,
    &[
        buyer_nft_fant_ata.clone(),
        transaction_fee_fant_ata.clone(),
        buyer_wallet_account.clone(),
        token_program_account_info.clone(),
    ],
)?;

ACKNOWLEDGED: The Phantasia Sports team states that the idea is that edition sales will be only performed by the team and would like all proceeds to be sent directly to the treasury.