triggr-program 0.1.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

use anchor_lang::prelude::*;

pub mod errors;
pub mod instructions;
pub mod state;

use instructions::*;
declare_id!("41NuR2mieT98yDQpXmwDzBZ24sz9UMAieorCr8Mw9C8Q");

#[program]
pub mod triggr {

    use super::*;

    pub fn initialize_program(ctx: Context<InitializeProgram>) -> Result<()> {
        instructions::initialize_program::handler(ctx)
    }
    pub fn add_middleware(ctx: Context<AddMiddleware>, middleware: Middleware) -> Result<()> {
        instructions::add_middleware::handler(ctx, middleware)
    }

    pub fn update_middleware(
        ctx: Context<UpdateMiddleware>,
        index: u32,
        program_id: Pubkey,
        accounts_count: u8,
    ) -> Result<()> {
        instructions::update_middleware::handler(ctx, index, program_id, accounts_count)
    }

    pub fn close_program(ctx: Context<CloseProgram>) -> Result<()> {
        instructions::close_program::handler(ctx)
    }

    pub fn create_user(ctx: Context<CreateUser>, lamports: u64) -> Result<()> {
        instructions::create_user::handler(ctx, lamports)
    }

    pub fn close_account(ctx: Context<CloseAccount>) -> Result<()> {
        instructions::close_account::handler(ctx)
    }

    pub fn create_task(
        ctx: Context<CreateTask>,
        task_args: Task,
        trigger_index: u64,
    ) -> Result<()> {
        instructions::create_task::handler(ctx, task_args, trigger_index)
    }

    pub fn create_trigger(
        ctx: Context<CreateTrigger>,
        condition_tree: AdjacencyTree,
        lifetime: Lifetime,
        workflow_title: String,
    ) -> Result<()> {
        instructions::create_trigger::handler(ctx, condition_tree, lifetime, workflow_title)
    }

    pub fn update_task(
        ctx: Context<UpdateTask>,
        task_args: Task,
        trigger_index: u64,
        task_index: u8,
    ) -> Result<()> {
        instructions::update_task::handler(ctx, task_args, trigger_index, task_index)
    }

    pub fn exec_task(
        ctx: Context<ExecTask>,
        traverse: Vec<u8>,
        trigger_index: u64,
        task_index: u8,
    ) -> Result<()> {
        instructions::exec_task::handler(ctx, traverse, trigger_index, task_index)
    }

    pub fn update_trigger(
        ctx: Context<UpdateTrigger>,
        trigger_index: u64,
        conditions: AdjacencyTree,
    ) -> Result<()> {
        instructions::update_trigger::handler(ctx, trigger_index, conditions)
    }

    pub fn close_task(ctx: Context<CloseTask>, trigger_index: u64, task_index: u8) -> Result<()> {
        instructions::close_task::handler(ctx, trigger_index, task_index)
    }

    pub fn close_trigger(ctx: Context<CloseTrigger>, trigger_index: u64) -> Result<()> {
        instructions::close_trigger::handler(ctx, trigger_index)
    }

    pub fn close_user(ctx: Context<CloseUser>) -> Result<()> {
        instructions::close_user::handler(ctx)
    }

    pub fn withdraw_from_payer(ctx: Context<WithdrawFromPayer>, lamports: u64) -> Result<()> {
        instructions::withdraw_from_payer::handler(ctx, lamports)
    }
    pub fn withdraw_from_payer_spl(ctx: Context<WithdrawFromPayerSPL>, amount: u64) -> Result<()> {
        instructions::withdraw_from_payer_spl::handler(ctx, amount)
    }

    pub fn populate_instruction(ctx: Context<PopulateInstruction>, ix_index: u8) -> Result<()> {
        instructions::populate_instruction::handler(ctx, ix_index)
    }

    pub fn create_lut(ctx: Context<CreateLut>, slot: u64, bump: u8) -> Result<()> {
        instructions::create_lut::handler(ctx, slot, bump)
    }
}