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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
use anchor_lang::prelude::*;
pub mod consts;
pub mod error;
pub mod helper;
use consts::*;
use error::*;
use helper::*;
type NAME = [u8; MAX_SIZE as usize];
declare_id!("EiPBR9hbRnECQ6gTutUsW8brBtaZKqK5UZth8MBjMfDf");
#[program]
pub mod bitoku_sdk_agent {
use super::*;
pub fn init_bitoku(_ctx: Context<InitBitoku>) -> Result<()> {
Ok(())
}
pub fn register_client(ctx: Context<RegisterClient>, client_id: u8) -> Result<u8> {
let mut bookkeeper = ctx.accounts.bookkeeper.load_mut()?;
let mut request = ctx.accounts.request.load_init()?;
let my_id = bookkeeper.next_id;
addel(&mut bookkeeper.status, my_id);
request.client_id = my_id;
if bookkeeper.next_id == 255 {
return err!(BitokuAgentError::NoAvailableClients);
}
bookkeeper.next_id += 1;
Ok(my_id)
}
pub fn remove_client(ctx: Context<DeleteClient>, client_id: u8) -> Result<()> {
let mut bookkeeper = ctx.accounts.bookkeeper.load_mut()?;
let bool = isel(bookkeeper.status, client_id);
if !bool {
return err!(BitokuAgentError::UnregisteredClient);
}
delel(&mut bookkeeper.status, client_id);
Ok(())
}
pub fn send_request(ctx: Context<SendRequest>, request: Request, i: u8) -> Result<()> {
let s = request.name();
let name = String::from_utf8(s.to_vec()).unwrap();
if validate_name(&name.as_bytes()) == false {
return err!(BitokuAgentError::InvalidName);
}
let req = &mut ctx.accounts.request.load_mut()?;
req.requester = ctx.accounts.fee_payer.to_account_info().key();
req.request = request;
Ok(())
}
}
#[derive(Accounts)]
pub struct InitBitoku<'info> {
#[account(mut)]
pub fee_payer: Signer<'info>,
#[account(init, payer= fee_payer, space=41,seeds= ["book_keeper".as_ref()], bump)]
pub bookkeeper: AccountLoader<'info, BookKeeper>,
pub system_program: Program<'info, System>,
}
#[derive(Accounts)]
#[instruction(client_id: u8)]
pub struct RegisterClient<'info> {
#[account(mut)]
pub fee_payer: Signer<'info>,
#[account(mut,seeds= ["book_keeper".as_ref()], bump)]
pub bookkeeper: AccountLoader<'info, BookKeeper>,
#[account(
init,
payer = fee_payer,
space = 8+1+32+(1+128+1),
seeds= ["request".as_ref(),fee_payer.key().as_ref()],
bump
)]
pub request: AccountLoader<'info, RequestData>,
pub system_program: Program<'info, System>,
}
#[derive(Accounts)]
#[instruction(client_id: u8)]
pub struct DeleteClient<'info> {
#[account(mut)]
pub fee_payer: Signer<'info>,
#[account(mut,seeds= ["book_keeper".as_ref()], bump)]
pub bookkeeper: AccountLoader<'info, BookKeeper>,
#[account(
mut,
seeds= ["request".as_ref(),fee_payer.key().as_ref()],
bump
)]
pub request: AccountLoader<'info, RequestData>,
pub system_program: Program<'info, System>,
}
#[derive(Accounts)]
#[instruction(request: Request,client_id: u8)]
pub struct SendRequest<'info> {
#[account(mut)]
pub fee_payer: Signer<'info>,
#[account(mut,seeds= ["book_keeper".as_ref()], bump)]
pub bookkeeper: AccountLoader<'info, BookKeeper>,
#[account(
mut,
seeds= ["request".as_ref(),fee_payer.key().as_ref()],
bump
)]
pub request: AccountLoader<'info, RequestData>,
pub system_program: Program<'info, System>,
}
#[account(zero_copy)]
pub struct BookKeeper {
status: [u8; 32],
next_id: u8,
}
#[account(zero_copy)]
pub struct RequestData {
client_id: u8,
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,
}
}
}