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

use anchor_lang::prelude::*;
use borsh::{BorshDeserialize, BorshSerialize};
pub mod consts;
pub mod error;
pub mod helper;
use consts::*;
use error::*;
use helper::validate_name;

type NAME = [u8; MAX_SIZE as usize];

declare_id!("BXhV8LAEAQQFVmiVpDW9MhkmpHyN2QzjFUZhwR6KHtbg");

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

    pub fn register_client(ctx: Context<RegisterClient>, _client_name: String) -> Result<()> {
        let client = &mut ctx.accounts.client.load_init()?;
        client.owner = ctx.accounts.owner.to_account_info().key();
        Ok(())
    }

    pub fn remove_client(_ctx: Context<DeleteClient>) -> Result<()> {
        Ok(())
    }

    pub fn send_request(ctx: Context<SendRequest>, request: Request) -> Result<()> {
        let s = request.name();

        let name = String::from_utf8(s.to_vec()).unwrap();
        if validate_name(&name.as_bytes()) == false {
            return err!(AgentError::InvalidName);
        }
        let req = &mut ctx.accounts.request.load_init()?;
        req.requester = ctx.accounts.owner.to_account_info().key();
        req.request = request;
        Ok(())
    }
}

#[derive(Accounts)]
pub struct RegisterClient<'info> {
    #[account(mut)]
    pub owner: Signer<'info>,

    #[account(init, payer= owner, space=56,seeds= ["client".as_ref(), owner.key().as_ref()], bump)]
    pub client: AccountLoader<'info, Client>,

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

#[derive(Accounts)]
pub struct DeleteClient<'info> {
    #[account(mut)]
    pub owner: Signer<'info>,

    #[account(mut,close=owner,seeds= ["client".as_ref(),owner.key().as_ref()],bump)]
    pub client: AccountLoader<'info, Client>,

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

#[derive(Accounts)]
pub struct SendRequest<'info> {
    #[account(mut)]
    pub owner: Signer<'info>,

    #[account(mut,seeds= ["client".as_ref(), owner.key().as_ref()],bump)]
    pub client: AccountLoader<'info, Client>,

    #[account(init,payer = owner,space = 200, seeds= ["request".as_ref(),owner.key().as_ref(),client.key().as_ref()],bump)]
    pub request: AccountLoader<'info, RequestData>,

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

// one client per one user
// struct to store client information, such as id, owner and number of requests from that client
#[account(zero_copy)]
pub struct Client {
    id: u64,
    owner: Pubkey,
    request_count: u64,
}

// Information about particular requests such as id,its client, requester,and request enum
// for details about the request
#[account(zero_copy)]
pub struct RequestData {
    id: u64,
    client_id: u64,
    requester: Pubkey,
    request: Request,
}

#[derive(AnchorSerialize, AnchorDeserialize, Copy, Clone)]
pub enum Request {
    CreateBucket { name: [u8; 128] },
    CreateFile { name: [u8; 128] },
    WriteFile { name: [u8; 128], file_id: u8 },
    CloseFile { name: [u8; 128], file_id: u8 },
    DeleteFile { name: [u8; 128], file_id: u8 },
    SetPosition { name: [u8; 128], file_id: u8 },
    OpenFile { name: [u8; 128], file_id: u8 },
    ReadFile { name: [u8; 128], file_id: u8 },
}

impl Request {
    fn name(&self) -> NAME {
        match self {
            Request::CreateBucket { name } => *name,
            Request::CreateFile { name } => *name,
            Request::WriteFile { name, .. } => *name,
            Request::DeleteFile { name, .. } => *name,
            Request::CloseFile { name, .. } => *name,
            Request::SetPosition { name, .. } => *name,
            Request::OpenFile { name, .. } => *name,
            Request::ReadFile { name, .. } => *name,
        }
    }
}