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
130
131
132
133
134
135
136
137

use anchor_lang::prelude::*;

pub mod errors;
pub mod helpers;
pub mod instructions;
pub mod structs;

use instructions::*;

// declare_id!("EruNB3QKUApfEETbY1nedwkdhDo7bNhjjPo2hP2WcZJ3");
declare_id!("6eqr7wETF1YRsMNQkTqTVrDNFWc4JgBMwWkNAKQprgHZ");

#[program]
pub mod missions {
    use super::*;

    pub fn initialize_project(
        ctx: Context<InitializeProject>,
        params: InitializeProjectParams,
    ) -> Result<()> {
        instructions::initialize_project(ctx, params)
    }

    pub fn update_merkle(ctx: Context<UpdateMerkle>, params: UpdateMerkleParams) -> Result<()> {
        instructions::update_merkle(ctx, params)
    }

    pub fn initialize_admin(
        ctx: Context<InitializeAdmin>,
        params: InitializeAdminParams,
    ) -> Result<()> {
        instructions::initialize_admin(ctx, params)
    }

    pub fn create_resource(
        ctx: Context<CreateResource>,
        params: CreateResourceParams,
    ) -> Result<()> {
        instructions::create_resource(ctx, params)
    }

    pub fn create_nftpart(ctx: Context<CreateNftPart>, params: CreateNftPartParams) -> Result<()> {
        instructions::create_nftpart(ctx, params)
    }

    pub fn create_mission(ctx: Context<CreateMission>, params: CreateMissionParams) -> Result<()> {
        instructions::create_mission(ctx, params)
    }

    pub fn create_mission_v2(
        ctx: Context<CreateMissionV2>,
        params: CreateMissionV2Params,
    ) -> Result<()> {
        instructions::create_mission_v2(ctx, params)
    }

    pub fn delete_mission(ctx: Context<DeleteMission>, params: DeleteMissionParams) -> Result<()> {
        instructions::delete_mission(ctx, params)
    }

    pub fn update_mission(ctx: Context<UpdateMission>, params: UpdateMissionParams) -> Result<()> {
        instructions::update_mission(ctx, params)
    }

    pub fn update_mission_v2(
        ctx: Context<UpdateMissionV2>,
        params: UpdateMissionV2Params,
    ) -> Result<()> {
        instructions::update_mission_v2(ctx, params)
    }

    pub fn initialize_user_account(
        ctx: Context<InitializeUserAccount>,
        params: InitializeUserAccountParams,
    ) -> Result<()> {
        instructions::initialize_user_account(ctx, params)
    }

    pub fn initialize_user_resource(
        ctx: Context<InitializeUserResource>,
        params: InitializeUserResourceParams,
    ) -> Result<()> {
        instructions::initialize_user_resource(ctx, params)
    }

    pub fn send_on_mission<'info>(
        ctx: Context<'_, '_, '_, 'info, SendOnMission<'info>>,
        params: SendOnMissionParams,
    ) -> Result<()> {
        instructions::send_on_mission(ctx, params)
    }

    pub fn send_on_mission_v2<'info>(
        ctx: Context<'_, '_, '_, 'info, SendOnMissionV2<'info>>,
        params: SendOnMissionV2Params,
    ) -> Result<()> {
        instructions::send_on_mission_v2(ctx, params)
    }

    pub fn calculate_rewards(ctx: Context<CalculateRewards>) -> Result<()> {
        instructions::calculate_rewards(ctx)
    }
    pub fn calculate_rewards_v2(ctx: Context<CalculateRewardsV2>) -> Result<()> {
        instructions::calculate_rewards_v2(ctx)
    }

    pub fn burn_resource(ctx: Context<BurnResource>, params: BurnResourceParams) -> Result<()> {
        instructions::burn_resource(ctx, params)
    }

    pub fn claim_rewards(ctx: Context<ClaimRewards>) -> Result<()> {
        instructions::claim_rewards(ctx)
    }

    pub fn claim_rewards_v2(ctx: Context<ClaimRewardsV2>) -> Result<()> {
        instructions::claim_rewards_v2(ctx)
    }

    pub fn recall_from_mission<'info>(
        ctx: Context<'_, '_, '_, 'info, RecallFromMission<'info>>,
        params: RecallFromMissionParams,
    ) -> Result<()> {
        instructions::recall_from_mission(ctx, params)
    }

    pub fn close_participation(ctx: Context<CloseParticipation>) -> Result<()> {
        instructions::close_participation(ctx)
    }

    pub fn award_resource(ctx: Context<AwardResource>, params: AwardResourceParams) -> Result<()> {
        instructions::award_resource(ctx, params)
    }

    // pub fn migrate_mission(ctx: Context<MigrateMission>) -> Result<()> {
    //     instructions::migrate_mission(ctx)
    // }
}