103 lines
3.0 KiB
Rust
103 lines
3.0 KiB
Rust
use lox::bridge_table::{from_scalar, BridgeLine, BridgeTable, ENC_BUCKET_BYTES};
|
|
use lox::cred::{BucketReachability, Invitation, Lox};
|
|
use lox::proto;
|
|
use lox::{IssuerPubKey, OPENINV_LENGTH};
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_with::serde_as;
|
|
use std::array::TryFromSliceError;
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct OpenReqState {
|
|
pub request: proto::open_invite::Request,
|
|
pub state: proto::open_invite::State,
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct TrustReqState {
|
|
pub request: proto::trust_promotion::Request,
|
|
pub state: proto::trust_promotion::State,
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct MigReqState {
|
|
pub request: proto::migration::Request,
|
|
pub state: proto::migration::State,
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct LevelupReqState {
|
|
pub request: proto::level_up::Request,
|
|
pub state: proto::level_up::State,
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct IssueInviteReqState {
|
|
pub request: proto::issue_invite::Request,
|
|
pub state: proto::issue_invite::State,
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct RedeemReqState {
|
|
pub request: proto::redeem_invite::Request,
|
|
pub state: proto::redeem_invite::State,
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct CheckBlockageReqState {
|
|
pub request: proto::check_blockage::Request,
|
|
pub state: proto::check_blockage::State,
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
pub struct BlockageMigReqState {
|
|
pub request: proto::blockage_migration::Request,
|
|
pub state: proto::blockage_migration::State,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, Serialize)]
|
|
pub struct PubKeys {
|
|
pub lox_pub: IssuerPubKey,
|
|
pub migration_pub: IssuerPubKey,
|
|
pub migrationkey_pub: IssuerPubKey,
|
|
pub reachability_pub: IssuerPubKey,
|
|
pub invitation_pub: IssuerPubKey,
|
|
}
|
|
|
|
#[serde_as]
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct EncBridgeTable {
|
|
#[serde_as(as = "Vec<[_; ENC_BUCKET_BYTES]>")]
|
|
pub etable: Vec<[u8; ENC_BUCKET_BYTES]>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, Serialize)]
|
|
pub struct LoxCredential {
|
|
pub lox_credential: Lox,
|
|
pub bridgeline: Option<BridgeLine>,
|
|
pub invitation: Option<Invitation>,
|
|
}
|
|
|
|
// This should also check the pubkey
|
|
pub fn validate(invite: &[u8]) -> Result<[u8; OPENINV_LENGTH], TryFromSliceError> {
|
|
invite.try_into()
|
|
}
|
|
|
|
pub fn generate_reachability_cred(lox_cred: &Lox, encrypted_table: String) -> BucketReachability {
|
|
let (id, key) = from_scalar(lox_cred.bucket).unwrap();
|
|
let enc_buckets: EncBridgeTable = serde_json::from_str(&encrypted_table).unwrap();
|
|
let bucket = BridgeTable::decrypt_bucket(id, &key, &enc_buckets.etable[id as usize]).unwrap();
|
|
bucket.1.unwrap()
|
|
}
|
|
|
|
//pub const MAX_LEVEL: usize = 4;
|
|
//pub const LEVEL_INTERVAL: [u32; MAX_LEVEL + 1] = [0, 14, 28, 56, 84];
|
|
pub fn calc_test_days(trust_level: i64) -> i64 {
|
|
let mut total = 31;
|
|
// for level in 0..trust_level {
|
|
// let level_interval: u32 = LEVEL_INTERVAL[trust_level as usize];
|
|
// total += level_interval;
|
|
total += trust_level * 85;
|
|
// }
|
|
total
|
|
}
|