1use solana_program::{
25 hash::hashv,
26 instruction::{AccountMeta, Instruction},
27 pubkey,
28 pubkey::Pubkey,
29 system_program,
30};
31
32pub const ID: Pubkey = pubkey!("5y7iWJ1VAMJjnnWbbdo2a2PsWJEwTExSNpzrvQSEnS8k");
35pub const ID_STR: &str = "5y7iWJ1VAMJjnnWbbdo2a2PsWJEwTExSNpzrvQSEnS8k";
36pub const FEE_OWNER: Pubkey = pubkey!("4G3cznCnwCUPBCZwzKiLupjdgB5pSoCcGWNGuFv4TYFo");
38pub const TOKEN: Pubkey = pubkey!("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
39pub const TOKEN_2022: Pubkey = pubkey!("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
40pub const ATA_PROGRAM: Pubkey = pubkey!("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
41pub const USDC_DEVNET: Pubkey = pubkey!("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU");
43pub const USDC_MAINNET: Pubkey = pubkey!("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
44
45pub const FEE_BPS: u64 = 30; pub const ORDER_FEE_MIN: u64 = 50_000; pub const ORDER_MIN_AMOUNT: u64 = 5_000_000;
51pub const MAX_AMOUNT: u64 = 100_000_000_000; pub const MIN_WORK: i64 = 60;
53pub const MAX_WORK: i64 = 90 * 86_400;
54pub const MAX_TERMS: usize = 600;
55
56pub const MERGE: u8 = 0; pub const TESTS: u8 = 1; pub const OPEN: u8 = 1; pub const HELD: u8 = 3;
60pub const WARRANTY: u8 = 4;
61pub const F_FAUCET: u8 = 1; pub const F_PRIVATE: u8 = 2;
63pub const F_NEUTRAL: u8 = 4;
64pub const F_STANDING: u8 = 8;
65pub const F_TOKEN2022: u8 = 16;
66pub const ORDER_LEN: usize = 512;
67pub const OPTS_LEN: usize = 48;
68
69pub fn units(micro: u64, decimals: u8) -> u64 {
71 if micro == 0 { return 0; }
72 let v = match 10u128.checked_pow(decimals as u32) { Some(p) => (micro as u128).saturating_mul(p) / 1_000_000, None => u128::MAX };
73 v.min(u64::MAX as u128) as u64
74}
75pub fn bps_of(amount: u64, bps: u64) -> u64 { amount / 10_000 * bps + amount % 10_000 * bps / 10_000 }
77pub fn order_fee(amount: u64, bps: u64, decimals: u8) -> u64 { bps_of(amount, bps).max(units(ORDER_FEE_MIN, decimals)) }
81
82pub fn terms_hash(json: &[u8]) -> [u8; 32] { hashv(&[json]).to_bytes() }
84pub fn wf_repo_hash(repository: &str) -> [u8; 32] { hashv(&[repository.as_bytes()]).to_bytes() }
86pub fn scope(repo_id: u64, issue: u64) -> [u8; 32] { hashv(&[b"knos3:scope", &repo_id.to_le_bytes(), &issue.to_le_bytes()]).to_bytes() }
88pub fn private_scope(salt: &[u8; 32], repo_id: u64, issue: u64) -> [u8; 32] { hashv(&[salt, &repo_id.to_le_bytes(), &issue.to_le_bytes()]).to_bytes() }
90
91pub fn auth(program: &Pubkey) -> Pubkey { Pubkey::find_program_address(&[b"auth"], program).0 }
93pub fn pause(program: &Pubkey) -> Pubkey { Pubkey::find_program_address(&[b"pause"], program).0 }
95pub fn order(program: &Pubkey, scope: &[u8; 32], source: &Pubkey, seq: u32) -> Pubkey {
98 Pubkey::find_program_address(&[b"ord", scope, source.as_ref(), &seq.to_le_bytes()], program).0
99}
100pub fn ov(program: &Pubkey, order: &Pubkey) -> Pubkey { Pubkey::find_program_address(&[b"ov", order.as_ref()], program).0 }
102pub fn ata(owner: &Pubkey, mint: &Pubkey, token_program: &Pubkey) -> Pubkey {
104 Pubkey::find_program_address(&[owner.as_ref(), token_program.as_ref(), mint.as_ref()], &ATA_PROGRAM).0
105}
106
107#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
110pub struct Opts {
111 pub flags: u8, pub holdback_bps: u16, pub warranty_days: u16, pub kill_bps: u16, pub reserve_days: u8, pub rate: u64, pub arbiter_id: u64,
112 pub judge_repo_id: u64, pub salted: bool,
113}
114impl Opts {
115 pub fn to_bytes(&self) -> [u8; OPTS_LEN] {
116 let mut o = [0u8; OPTS_LEN];
117 o[0] = self.flags;
118 o[1..3].copy_from_slice(&self.holdback_bps.to_le_bytes());
119 o[3..5].copy_from_slice(&self.warranty_days.to_le_bytes());
120 o[5..7].copy_from_slice(&self.kill_bps.to_le_bytes());
121 o[7] = self.reserve_days;
122 o[8..16].copy_from_slice(&self.rate.to_le_bytes());
123 o[16..24].copy_from_slice(&self.arbiter_id.to_le_bytes());
124 o[24..32].copy_from_slice(&self.judge_repo_id.to_le_bytes());
125 o[32] = self.salted as u8;
126 o
127 }
128}
129
130#[derive(Clone, Copy, Debug, PartialEq, Eq)]
135pub struct FundOrder {
136 pub repo_id: u64, pub issue: u64, pub amount: u64, pub mode: u8, pub work_s: i64, pub seq: u32, pub opts: Opts, pub wf_repo: [u8; 32],
137 pub wf_sha: [u8; 40], pub private_scope: Option<[u8; 32]>,
138}
139impl Default for FundOrder {
140 fn default() -> Self {
141 FundOrder { repo_id: 0, issue: 0, amount: 0, mode: MERGE, work_s: 14 * 86_400, seq: 0, opts: Opts::default(), wf_repo: [0; 32], wf_sha: [b'0'; 40],
142 private_scope: None }
143 }
144}
145impl FundOrder {
146 pub fn scope(&self) -> [u8; 32] { self.private_scope.unwrap_or_else(|| scope(self.repo_id, self.issue)) }
147 pub fn address(&self, program: &Pubkey, funder: &Pubkey) -> Pubkey { order(program, &self.scope(), funder, self.seq) }
149}
150
151pub fn fund_order_wallet(program: &Pubkey, funder: &Pubkey, funder_token: &Pubkey, mint: &Pubkey, token_program: &Pubkey, f: &FundOrder,
155 terms: &[u8]) -> Instruction {
156 let order = f.address(program, funder);
157 let mut data = Vec::with_capacity(190 + terms.len());
158 data.push(15);
159 data.extend_from_slice(&f.issue.to_le_bytes());
160 data.extend_from_slice(&f.repo_id.to_le_bytes());
161 data.extend_from_slice(&f.amount.to_le_bytes());
162 data.push(f.mode);
163 data.extend_from_slice(&f.work_s.to_le_bytes());
164 data.extend_from_slice(&f.seq.to_le_bytes());
165 data.extend_from_slice(&f.opts.to_bytes());
166 data.extend_from_slice(&f.wf_repo);
167 data.extend_from_slice(&f.wf_sha);
168 if let Some(s) = &f.private_scope { data.extend_from_slice(s); }
169 data.extend_from_slice(terms);
170 Instruction { program_id: *program, data, accounts: vec![
171 AccountMeta::new(*funder, true), AccountMeta::new(order, false), AccountMeta::new(ov(program, &order), false),
172 AccountMeta::new(*funder_token, false), AccountMeta::new_readonly(*mint, false), AccountMeta::new_readonly(auth(program), false),
173 AccountMeta::new_readonly(*token_program, false), AccountMeta::new_readonly(system_program::ID, false),
174 AccountMeta::new_readonly(pause(program), false),
175 ] }
176}
177
178pub fn top_up(program: &Pubkey, signer: &Pubkey, order: &Pubkey, o: &Order, add: u64, from_token: Option<&Pubkey>) -> Instruction {
182 let tp = o.token_program();
183 let from = match from_token { Some(k) => *k, None if o.from_balance => o.refund_to, None => ata(&o.source, &o.mint, &tp) };
184 let mut data = vec![23];
185 data.extend_from_slice(&add.to_le_bytes());
186 Instruction { program_id: *program, data, accounts: vec![
187 AccountMeta::new(*signer, true), AccountMeta::new(*order, false), AccountMeta::new(ov(program, order), false), AccountMeta::new(from, false),
188 AccountMeta::new_readonly(o.source, false), AccountMeta::new_readonly(o.mint, false), AccountMeta::new_readonly(auth(program), false),
189 AccountMeta::new_readonly(tp, false), AccountMeta::new_readonly(pause(program), false),
190 ] }
191}
192
193pub fn refund_order(program: &Pubkey, relayer: &Pubkey, order: &Pubkey, o: &Order, refund_token: Option<&Pubkey>) -> Instruction {
197 let tp = o.token_program();
198 let dest = match refund_token { Some(k) => *k, None if o.from_balance => o.refund_to, None => ata(&o.refund_to, &o.mint, &tp) };
199 Instruction { program_id: *program, data: vec![22], accounts: vec![
200 AccountMeta::new(*relayer, true), AccountMeta::new(*order, false), AccountMeta::new(ov(program, order), false), AccountMeta::new(dest, false),
201 AccountMeta::new_readonly(auth(program), false), AccountMeta::new(o.rent_to, false), AccountMeta::new_readonly(o.mint, false),
202 AccountMeta::new_readonly(tp, false),
203 ] }
204}
205
206#[derive(Clone, Debug, PartialEq, Eq)]
208pub struct Order {
209 pub state: u8, pub mode: u8, pub from_balance: bool, pub flags: u8, pub bump: u8, pub decimals: u8, pub reserve_days: u8, pub repo_id: u64,
210 pub issue: u64, pub scope: [u8; 32], pub seq: u32, pub holdback_bps: u16, pub kill_bps: u16, pub amount: u64, pub fee: u64, pub rate: u64,
211 pub paid: u64, pub deadline: i64, pub not_before: i64, pub hold_until: i64, pub warranty_s: i64, pub reserved_by: u64, pub reserved_until: i64,
212 pub cancel_at: i64, pub payee_id: u64, pub funder_id: u64, pub owner_id: u64, pub arbiter_id: u64, pub judge_repo_id: u64, pub source: Pubkey,
213 pub refund_to: Pubkey, pub rent_to: Pubkey, pub mint: Pubkey, pub terms: [u8; 32], pub wf_repo: [u8; 32], pub wf_sha: [u8; 40], pub fee_bps: u16,
214 pub inc: u64,
216 pub grace: bool,
218}
219impl Order {
220 pub fn parse(d: &[u8]) -> Option<Order> {
222 if d.len() != ORDER_LEN || d[0] != 2 { return None; }
223 let u16_at = |o: usize| u16::from_le_bytes([d[o], d[o + 1]]);
224 let u64_at = |o: usize| u64::from_le_bytes(d[o..o + 8].try_into().unwrap());
225 let i64_at = |o: usize| i64::from_le_bytes(d[o..o + 8].try_into().unwrap());
226 let key = |o: usize| Pubkey::new_from_array(d[o..o + 32].try_into().unwrap());
227 Some(Order {
228 state: d[1], mode: d[2], from_balance: d[3] == 1, flags: d[4], bump: d[5], decimals: d[6], reserve_days: d[7], repo_id: u64_at(8),
229 issue: u64_at(16), scope: d[24..56].try_into().unwrap(), seq: u32::from_le_bytes(d[56..60].try_into().unwrap()), holdback_bps: u16_at(60),
230 kill_bps: u16_at(62), amount: u64_at(64), fee: u64_at(72), rate: u64_at(80), paid: u64_at(88), deadline: i64_at(96), not_before: i64_at(104),
231 hold_until: i64_at(112), warranty_s: i64_at(120), reserved_by: u64_at(128), reserved_until: i64_at(136), cancel_at: i64_at(144),
232 payee_id: u64_at(152), funder_id: u64_at(160), owner_id: u64_at(168), arbiter_id: u64_at(176), judge_repo_id: u64_at(184), source: key(192),
233 refund_to: key(224), rent_to: key(256), mint: key(288), terms: d[320..352].try_into().unwrap(), wf_repo: d[352..384].try_into().unwrap(),
234 wf_sha: d[384..424].try_into().unwrap(), fee_bps: u16_at(424), inc: u64_at(432), grace: d[440] == 1,
235 })
236 }
237 pub fn read(address: &Pubkey, owner: &Pubkey, data: &[u8], program: &Pubkey) -> Option<Order> {
240 if owner != program { return None; }
241 let o = Order::parse(data)?;
242 let at = Pubkey::create_program_address(&[b"ord", &o.scope, o.source.as_ref(), &o.seq.to_le_bytes(), &[o.bump]], program).ok()?;
243 if at == *address { Some(o) } else { None }
244 }
245 pub fn is(&self, flag: u8) -> bool { self.flags & flag != 0 }
246 pub fn token_program(&self) -> Pubkey { if self.is(F_TOKEN2022) { TOKEN_2022 } else { TOKEN } }
247 pub fn address(&self, program: &Pubkey) -> Pubkey { order(program, &self.scope, &self.source, self.seq) }
248 pub fn refundable(&self, now: i64) -> bool { (self.state == OPEN && now > self.deadline) || (self.state == HELD && now > self.hold_until) }
251}