feat: added a test sale program demoing wen-distribution-program features with tests

Author: sunguru98

Anchor.toml

@@ -5,7 +5,7 @@ resolution = true
 skip-lint = false
 
 [programs.localnet]
-test_sale = "7EhFwHKHPF4ffuFtsh1929XfsnbHKaA5QNbouX5PYpSj"
+test_sale = "saLeHtY1jcSpuy5NKGX4pryocQ51WGUYqSSCKJNsgrP"
 wen_new_standard = "wns1gDLt8fgLcGhWi5MqAqgXpwEP1JftKE9eZnXS1HM"
 wen_royalty_distribution = "diste3nXmK7ddDTs1zb6uday6j4etCa9RChD8fJ1xay"
 

programs/test_sale/src/constants.rs

@@ -0,0 +1,3 @@
+pub const TEST_SALE: &[u8] = b"test_sale";
+pub const SALE: &[u8] = b"sale";
+pub const LISTING: &[u8] = b"listing";

programs/test_sale/src/errors.rs

@@ -0,0 +1,13 @@
+use anchor_lang::prelude::*;
+
+#[error_code]
+pub enum TestSaleError {
+    #[msg("Buy amount mismatch with listing amount")]
+    ListingAmountMismatch,
+    #[msg("SPL Payment token account required")]
+    PaymentTokenAccountNotExistant,
+    #[msg("Invalid SPL Payment token account")]
+    InvalidPaymentTokenAccount,
+    #[msg("Arithmetic error")]
+    ArithmeticError,
+}

programs/test_sale/src/instructions/listing/fulfill.rs

@@ -0,0 +1,297 @@
+use anchor_lang::{
+    prelude::*,
+    system_program::{transfer, Transfer},
+};
+use anchor_spl::{
+    associated_token::AssociatedToken,
+    token_2022::spl_token_2022::{extension::StateWithExtensions, state::Mint as StateMint},
+    token_2022::{transfer_checked, Token2022, TransferChecked},
+    token_interface::{Mint, TokenAccount},
+};
+use wen_new_standard::{
+    cpi::{
+        accounts::{ApproveTransfer, ThawDelegatedAccount},
+        approve_transfer, thaw_mint_account,
+    },
+    program::WenNewStandard,
+};
+use wen_royalty_distribution::{program::WenRoyaltyDistribution, DistributionAccount};
+
+use crate::{
+    constants::*,
+    utils::{
+        assert_right_associated_token_account, transfer_checked_with_hook, TransferCheckedWithHook,
+    },
+};
+use crate::{errors::*, utils::create_associated_token_account};
+use crate::{state::*, utils::calculate_royalties};
+
+#[derive(Accounts)]
+#[instruction(args: FulfillListingArgs)]
+pub struct FulfillListing<'info> {
+    #[account(mut)]
+    pub payer: Signer<'info>,
+
+    #[account(
+        mut,
+        seeds = [
+            TEST_SALE,
+            LISTING,
+            listing.seller.as_ref(),
+            listing.mint.as_ref(),
+        ],
+        bump = listing.bump,
+        has_one = sale,
+        has_one = mint,
+        has_one = seller,
+        has_one = seller_token_account,
+        constraint = args.buy_amount.eq(&args.buy_amount) @ TestSaleError::ListingAmountMismatch
+    )]
+    pub listing: Account<'info, Listing>,
+
+    #[account(
+        mut,
+        seeds = [
+            TEST_SALE,
+            SALE,
+            sale.group.key().as_ref(),
+            sale.distribution.key().as_ref()
+        ],
+        bump = sale.bump,
+        // has_one = distribution,
+    )]
+    pub sale: Account<'info, Sale>,
+
+    /// CHECK: Could be SOL or SPL, checked in distribution program
+    pub payment_mint: UncheckedAccount<'info>,
+
+    #[account(mut)]
+    pub buyer: Signer<'info>,
+
+    /// CHECK: Checked based on payment_mint
+    #[account(mut)]
+    pub buyer_payment_token_account: UncheckedAccount<'info>,
+
+    #[account(
+        mut,
+        has_one = payment_mint,
+        constraint = listing.payment_mint.eq(&distribution.payment_mint)
+    )]
+    pub distribution: Account<'info, DistributionAccount>,
+
+    /// CHECK: Created and checked based on payment_mint
+    #[account(mut)]
+    pub distribution_payment_token_account: UncheckedAccount<'info>,
+
+    #[account(mut)]
+    pub mint: InterfaceAccount<'info, Mint>,
+
+    #[account(
+        mut,
+        token::mint = mint,
+        token::authority = seller,
+    )]
+    pub seller_token_account: InterfaceAccount<'info, TokenAccount>,
+
+    #[account(
+        init_if_needed,
+        payer = payer,
+        associated_token::mint = mint,
+        associated_token::authority = buyer,
+    )]
+    pub buyer_token_account: InterfaceAccount<'info, TokenAccount>,
+
+    /// CHECK: Constraint checked with listing. Could be any account
+    #[account(mut)]
+    pub seller: SystemAccount<'info>,
+
+    /// CHECK: Checked based on payment_mint
+    #[account(mut)]
+    pub seller_payment_token_account: UncheckedAccount<'info>,
+
+    /// CHECK: Checked inside WNS program
+    pub manager: UncheckedAccount<'info>,
+    /// CHECK: Checked inside Token extensions program
+    pub extra_metas_account: UncheckedAccount<'info>,
+    /// CHECK: Checked inside WNS program
+    #[account(mut)]
+    pub approve_account: UncheckedAccount<'info>,
+
+    pub wns_program: Program<'info, WenNewStandard>,
+    pub distribution_program: Program<'info, WenRoyaltyDistribution>,
+    pub associated_token_program: Program<'info, AssociatedToken>,
+    pub token_program: Program<'info, Token2022>,
+    pub system_program: Program<'info, System>,
+}
+
+pub fn handler(ctx: Context<FulfillListing>, args: FulfillListingArgs) -> Result<()> {
+    let listing = &mut ctx.accounts.listing;
+    let sale = &ctx.accounts.sale;
+
+    let is_payment_mint_spl = ctx.accounts.payment_mint.key.ne(&Pubkey::default());
+
+    let signer_seeds: &[&[&[u8]]] = &[&[
+        TEST_SALE,
+        SALE,
+        sale.group.as_ref(),
+        sale.distribution.as_ref(),
+        &[sale.bump],
+    ]];
+
+    // Thaw NFT
+    thaw_mint_account(CpiContext::new_with_signer(
+        ctx.accounts.wns_program.to_account_info(),
+        ThawDelegatedAccount {
+            payer: ctx.accounts.payer.to_account_info(),
+            delegate_authority: ctx.accounts.sale.to_account_info(),
+            manager: ctx.accounts.manager.to_account_info(),
+            mint: ctx.accounts.mint.to_account_info(),
+            mint_token_account: ctx.accounts.seller_token_account.to_account_info(),
+            token_program: ctx.accounts.token_program.to_account_info(),
+            user: ctx.accounts.seller.to_account_info(),
+        },
+        signer_seeds,
+    ))?;
+
+    // Transfer (listing_amount - royalty) to seller
+    // Checking payment mint and creating seller token account if necessary
+    let royalty_funds = calculate_royalties(&ctx.accounts.mint.to_account_info(), args.buy_amount)?;
+
+    let funds_to_send = listing
+        .listing_amount
+        .checked_sub(royalty_funds)
+        .ok_or(TestSaleError::ArithmeticError)?;
+
+    if is_payment_mint_spl {
+        let payment_mint = &ctx.accounts.payment_mint.try_borrow_data()?;
+        let payment_mint_data = StateWithExtensions::<StateMint>::unpack(payment_mint)?;
+
+        require_neq!(
+            ctx.accounts.buyer_payment_token_account.key,
+            &Pubkey::default(),
+            TestSaleError::PaymentTokenAccountNotExistant
+        );
+
+        require_neq!(
+            ctx.accounts.buyer_payment_token_account.key,
+            &Pubkey::default(),
+            TestSaleError::PaymentTokenAccountNotExistant
+        );
+
+        assert_right_associated_token_account(
+            ctx.accounts.buyer.key,
+            ctx.accounts.payment_mint.key,
+            ctx.accounts.buyer_payment_token_account.key,
+        )?;
+
+        if ctx.accounts.seller_payment_token_account.data_is_empty() {
+            create_associated_token_account(
+                ctx.accounts.payer.to_account_info(),
+                ctx.accounts.seller.to_account_info(),
+                ctx.accounts.payment_mint.to_account_info(),
+                ctx.accounts.seller_payment_token_account.to_account_info(),
+                ctx.accounts.associated_token_program.to_account_info(),
+                ctx.accounts.token_program.to_account_info(),
+                ctx.accounts.system_program.to_account_info(),
+            )?;
+        }
+
+        transfer_checked(
+            CpiContext::new(
+                ctx.accounts.token_program.to_account_info(),
+                TransferChecked {
+                    authority: ctx.accounts.buyer.to_account_info(),
+                    from: ctx.accounts.buyer_payment_token_account.to_account_info(),
+                    to: ctx.accounts.seller_payment_token_account.to_account_info(),
+                    mint: ctx.accounts.payment_mint.to_account_info(),
+                },
+            ),
+            funds_to_send,
+            payment_mint_data.base.decimals,
+        )?;
+    } else {
+        transfer(
+            CpiContext::new(
+                ctx.accounts.system_program.to_account_info(),
+                Transfer {
+                    from: ctx.accounts.buyer.to_account_info(),
+                    to: ctx.accounts.seller.to_account_info(),
+                },
+            ),
+            funds_to_send,
+        )?;
+    }
+
+    // Approve Transfer
+    if is_payment_mint_spl
+        && ctx
+            .accounts
+            .distribution_payment_token_account
+            .data_is_empty()
+    {
+        create_associated_token_account(
+            ctx.accounts.payer.to_account_info(),
+            ctx.accounts.distribution.to_account_info(),
+            ctx.accounts.payment_mint.to_account_info(),
+            ctx.accounts
+                .distribution_payment_token_account
+                .to_account_info(),
+            ctx.accounts.associated_token_program.to_account_info(),
+            ctx.accounts.token_program.to_account_info(),
+            ctx.accounts.system_program.to_account_info(),
+        )?;
+    }
+
+    approve_transfer(
+        CpiContext::new(
+            ctx.accounts.wns_program.to_account_info(),
+            ApproveTransfer {
+                payer: ctx.accounts.payer.to_account_info(),
+                authority: ctx.accounts.buyer.to_account_info(),
+                payment_mint: ctx.accounts.payment_mint.to_account_info(),
+                mint: ctx.accounts.mint.to_account_info(),
+                distribution_account: ctx.accounts.distribution.to_account_info(),
+                authority_token_account: ctx.accounts.buyer_payment_token_account.to_account_info(),
+                distribution_token_account: ctx
+                    .accounts
+                    .distribution_payment_token_account
+                    .to_account_info(),
+                approve_account: ctx.accounts.approve_account.to_account_info(),
+                distribution_program: ctx.accounts.distribution_program.to_account_info(),
+                associated_token_program: ctx.accounts.associated_token_program.to_account_info(),
+                token_program: ctx.accounts.token_program.to_account_info(),
+                system_program: ctx.accounts.system_program.to_account_info(),
+            },
+        ),
+        args.buy_amount,
+    )?;
+
+    // // Transfer NFT to buyer
+    transfer_checked_with_hook(
+        CpiContext::new_with_signer(
+            ctx.accounts.token_program.to_account_info(),
+            TransferCheckedWithHook {
+                authority: ctx.accounts.sale.to_account_info(),
+                mint: ctx.accounts.mint.to_account_info(),
+                from: ctx.accounts.seller_token_account.to_account_info(),
+                to: ctx.accounts.buyer_token_account.to_account_info(),
+                extra_metas_account: ctx.accounts.extra_metas_account.to_account_info(),
+                approve_account: ctx.accounts.approve_account.to_account_info(),
+                wns_program: ctx.accounts.wns_program.to_account_info(),
+            },
+            signer_seeds,
+        ),
+        1,
+        0,
+    )?;
+
+    // Close listing
+    listing.close(ctx.accounts.payer.to_account_info())?;
+
+    Ok(())
+}
+
+#[derive(AnchorSerialize, AnchorDeserialize)]
+pub struct FulfillListingArgs {
+    pub buy_amount: u64,
+}