libreplex_metadata 0.10.0

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

use anchor_lang::prelude::*;

use crate::{Metadata, DelegatePermissions, PermissionType, Group};

use crate::{errors::ErrorCode};


// Adds a metadata to a group
#[derive(Accounts)]
pub struct GroupAdd<'info> {
    pub metadata_authority: Signer<'info>,

    #[account(mut)]
    pub group_authority: Signer<'info>,

    #[account(mut)]
    pub payer: Signer<'info>,

    #[account(mut)]
    pub metadata: Box<Account<'info, Metadata>>,

    // Derived from the editor, the metadata's update auth and the the metadata itself
    #[account(seeds = ["permissions".as_ref(), 
                        metadata_authority.key().as_ref(), 
                        metadata.update_authority.as_ref(), 
                        metadata.key().as_ref()], 
                        bump)]
    pub delegated_metadata_specific_permissions: Option<Box<Account<'info, DelegatePermissions>>>,

    #[account(seeds = ["permissions".as_ref(),
                        group_authority.key().as_ref(), 
                        group.key().as_ref()], bump)]
    pub delegated_group_wide_permissions: Option<Box<Account<'info, DelegatePermissions>>>,

    #[account(mut)]
    pub group: Box<Account<'info, Group>>,

    pub system_program: Program<'info, System>,
}

pub fn handler(ctx: Context<GroupAdd>
) -> Result<()> {
    let metadata = &mut ctx.accounts.metadata;

    if metadata.group.is_some() {
        return Err(ErrorCode::MetadataBelongsToGroup.into())
    }

    let group = &ctx.accounts.group;

    let metadata_authority = &ctx.accounts.metadata_authority;
    let group_authority = &ctx.accounts.group_authority;

    let mut can_edit_metadata = &metadata.update_authority == metadata_authority.key;
    
    if let Some(delegated_metadata_specific_permissions_account) 
        = &ctx.accounts.delegated_metadata_specific_permissions {
            can_edit_metadata = can_edit_metadata || delegated_metadata_specific_permissions_account.permissions.contains(&PermissionType::AddToGroup)
    }

    let mut can_edit_group = &group.update_authority == group_authority.key;

    if let Some(delegated_group_wide_permissions) = &ctx.accounts.delegated_group_wide_permissions {
        can_edit_group = can_edit_group || delegated_group_wide_permissions.permissions.contains(&PermissionType::AddToGroup)
    }

    if !can_edit_group || !can_edit_metadata {
        return Err(ErrorCode::InvalidPermissions.into());
    }

    msg!("Setting group to {}", group.key());
    

    metadata.group = Some(group.key());
    metadata.update_authority = group.key();
    
    Ok(())
}