gobblerdev 0.2.1

Created with Anchor
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::curve::CurveCalculator;
use crate::curve::AMM;
use crate::curve::DEFAULT_TOKEN_RESERVES;
use crate::curve::DEFAULT_VIRTUAL_SOL_RESERVE;
use crate::curve::DEFUALT_INITIAL_VIRTUAL_TOKEN_RESERVE;
use crate::curve::DEFUALT_VIRTUAL_TOKEN_RESERVE;
use crate::error::ErrorCode;
use crate::states::*;
use crate::utils::*;
use anchor_lang::{
    accounts::interface_account::InterfaceAccount,
    prelude::*,
    solana_program::clock,
    system_program,
};
use anchor_spl::metadata::create_metadata_accounts_v3;
use anchor_spl::metadata::mpl_token_metadata::types::DataV2;
use anchor_spl::metadata::CreateMetadataAccountsV3;
use anchor_spl::metadata::Metadata;
use anchor_spl::{
    associated_token::AssociatedToken,
    token::Token,
    token_2022::spl_token_2022,
    token_interface::{Mint, TokenAccount, TokenInterface},
};
use solana_program::program::invoke_signed;
use spl_associated_token_account::create_associated_token_account;

use std::ops::Deref;

#[derive(Accounts)]
pub struct InitializeMetadata<'info> {
    #[account(
        mut,
        constraint = creator.key() == pool_state.load()?.pool_creator 
    )]
    pub creator: Signer<'info>,
    /// CHECK: This is not dangerous because we don't read or write from this account
    /// CHECK: pool vault and lp mint authority
    #[account(
    seeds = [
        crate::AUTH_SEED.as_bytes(),
    ],
    bump,
)]
    pub authority: UncheckedAccount<'info>,
    #[account(mut)]
    pub lp_mint: Box<InterfaceAccount<'info, Mint>>,
    pub token_metadata_program: Program<'info, Metadata>,
    #[account(
        mut,
        seeds = [
            b"metadata", 
            token_metadata_program.key.as_ref(), 
            lp_mint.to_account_info().key.as_ref()
        ],
        seeds::program = token_metadata_program.key(),
        bump,
    )]
    /// CHECK: metadata
    pub metadata: AccountInfo<'info>,
    pub system_program: Program<'info, System>,
    pub rent: Sysvar<'info, Rent>,
    /// AMM config account, used to verify the creator
    pub amm_config: Account<'info, AmmConfig>,

    /// an account to store oracle observations
    #[account(
        init,
        seeds = [
            OBSERVATION_SEED.as_bytes(),
            pool_state.key().as_ref(),
        ],
        bump,
        payer = creator,
        space = ObservationState::LEN
    )]
    pub observation_state: AccountLoader<'info, ObservationState>,
    /// The pool state account
    #[account(mut)]
    pub pool_state: AccountLoader<'info, PoolState>,
}

pub fn initialize_metadata(
    ctx: Context<InitializeMetadata>,
    name: String,
    symbol: String,
    uri: String,
) -> Result<()> {

    let name = name.to_string();
    let symbol = symbol.to_string();
    let uri = uri.to_string();

    let seeds = &[crate::AUTH_SEED.as_bytes(), &[ctx.bumps.authority]];
    let signer = [&seeds[..]];
 

    let token_data: DataV2 = DataV2 {
        name: name.clone(),
        symbol: symbol.clone(),
        uri: uri.clone(),
        seller_fee_basis_points: 0,
        creators: None,
        collection: None,
        uses: None,
    };

    let metadata_ctx = CpiContext::new_with_signer(
        ctx.accounts.token_metadata_program.to_account_info(),
        CreateMetadataAccountsV3 {
            payer: ctx.accounts.creator.to_account_info(),
            update_authority: ctx.accounts.authority.to_account_info(),
            mint: ctx.accounts.lp_mint.to_account_info(),
            metadata: ctx.accounts.metadata.to_account_info(),
            mint_authority: ctx.accounts.authority.to_account_info(),
            system_program: ctx.accounts.system_program.to_account_info(),
            rent: ctx.accounts.rent.to_account_info(),
        },
        &signer,
    );

    create_metadata_accounts_v3(metadata_ctx, token_data, false, true, None)?;
    Ok(())
}