spl-token-metadata 0.0.1

Metaplex Metadata
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
127
128
129

mod utils;

use num_traits::FromPrimitive;
use solana_program::pubkey::Pubkey;
use solana_program_test::*;
use solana_sdk::{
    instruction::InstructionError,
    signature::{Keypair, Signer},
    transaction::{Transaction, TransactionError},
    transport::TransportError,
};
use spl_token_metadata::error::MetadataError;
use spl_token_metadata::state::Key;
use spl_token_metadata::{id, instruction};
use utils::*;

#[tokio::test]
async fn success() {
    let mut context = program_test().start_with_context().await;
    let test_metadata = Metadata::new();

    test_metadata
        .create(
            &mut context,
            "Test".to_string(),
            "TST".to_string(),
            "uri".to_string(),
            None,
            10,
            false,
        )
        .await
        .unwrap();

    let metadata = test_metadata.get_data(&mut context).await;

    assert_eq!(metadata.data.name, "Test");
    assert_eq!(metadata.data.symbol, "TST");
    assert_eq!(metadata.data.uri, "uri");
    assert_eq!(metadata.data.seller_fee_basis_points, 10);
    assert_eq!(metadata.data.creators, None);

    assert_eq!(metadata.primary_sale_happened, false);
    assert_eq!(metadata.is_mutable, false);
    assert_eq!(metadata.mint, test_metadata.mint.pubkey());
    assert_eq!(metadata.update_authority, context.payer.pubkey());
    assert_eq!(metadata.key, Key::MetadataV1);
}

#[tokio::test]
async fn fail_invalid_mint_authority() {
    let mut context = program_test().start_with_context().await;
    let test_metadata = Metadata::new();
    let fake_mint_authority = Keypair::new();
    let payer_pubkey = context.payer.pubkey();

    create_mint(&mut context, &test_metadata.mint, &payer_pubkey, None)
        .await
        .unwrap();
    create_token_account(
        &mut context,
        &test_metadata.token,
        &test_metadata.mint.pubkey(),
        &payer_pubkey,
    )
    .await
    .unwrap();
    mint_tokens(
        &mut context,
        &test_metadata.mint.pubkey(),
        &test_metadata.token.pubkey(),
        1,
        &payer_pubkey,
        None,
    )
    .await
    .unwrap();

    let tx = Transaction::new_signed_with_payer(
        &[instruction::create_metadata_accounts(
            id(),
            test_metadata.pubkey.clone(),
            test_metadata.mint.pubkey(),
            fake_mint_authority.pubkey(),
            context.payer.pubkey().clone(),
            context.payer.pubkey().clone(),
            "Test".to_string(),
            "TST".to_string(),
            "uri".to_string(),
            None,
            10,
            false,
            false,
        )],
        Some(&context.payer.pubkey()),
        &[&context.payer, &fake_mint_authority],
        context.last_blockhash,
    );

    let result = context
        .banks_client
        .process_transaction(tx)
        .await
        .unwrap_err();

    assert_custom_error!(result, MetadataError::InvalidMintAuthority);
}

#[tokio::test]
async fn fail_invalid_metadata_pda() {
    let mut context = program_test().start_with_context().await;
    let mut test_metadata = Metadata::new();
    test_metadata.pubkey = Pubkey::new_unique();

    let result = test_metadata
        .create(
            &mut context,
            "Test".to_string(),
            "TST".to_string(),
            "uri".to_string(),
            None,
            10,
            false,
        )
        .await
        .unwrap_err();

    assert_custom_error!(result, MetadataError::InvalidMetadataKey);
}