IntenseWebs/veilid
3
0
Fork 0
mirror of https://gitlab.com/veilid/veilid.git synced 2024-11-25 18:20:41 -06:00
Code Issues Packages Projects Releases Wiki Activity

Replace .unwrap() with ? operator

Browse Source
This commit is contained in:
Brandon Vandegrift 2023-09-12 08:06:49 -04:00
parent c2c607efac
commit ac8bbe9a83
4 changed files with 88 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
veilid-wasm/src/lib.rs
View File

@ -66,10 +66,15 @@ fn take_veilid_api() -> Result<veilid_core::VeilidAPI, veilid_core::VeilidAPIErr
}
// Marshalling helpers
pub fn unmarshall(b64: String) -> Vec<u8> {
pub fn unmarshall(b64: String) -> APIResult<Vec<u8>> {
data_encoding::BASE64URL_NOPAD
.decode(b64.as_bytes())
.unwrap()
.map_err(|e| {
VeilidAPIError::generic(format!(
"error decoding base64url string '{}' into bytes: {}",
b64, e
))
})
}
pub fn marshall(data: &Vec<u8>) -> String {

122
veilid-wasm/src/veilid_crypto_js.rs
View File

@ -93,12 +93,8 @@ impl VeilidCrypto {
pub fn hashPassword(kind: String, password: String, salt: String) -> APIResult<String> {
let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?;
let password: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(password.as_bytes())
.unwrap();
let salt: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(salt.as_bytes())
.unwrap();
let password = unmarshall(password)?;
let salt = unmarshall(salt)?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;
@ -119,9 +115,7 @@ impl VeilidCrypto {
password_hash: String,
) -> APIResult<bool> {
let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?;
let password: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(password.as_bytes())
.unwrap();
let password = unmarshall(password)?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;
@ -138,12 +132,8 @@ impl VeilidCrypto {
pub fn deriveSharedSecret(kind: String, password: String, salt: String) -> APIResult<String> {
let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?;
let password: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(password.as_bytes())
.unwrap();
let salt: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(salt.as_bytes())
.unwrap();
let password = unmarshall(password)?;
let salt = unmarshall(salt)?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;
@ -196,20 +186,34 @@ impl VeilidCrypto {
signatures: StringArray,
) -> VeilidAPIResult<StringArray> {
let node_ids = into_unchecked_string_vec(node_ids);
let node_ids: Vec<veilid_core::TypedKey> = node_ids
let node_ids: Vec<TypedKey> = node_ids
.iter()
.map(|k| veilid_core::TypedKey::from_str(k).unwrap())
.collect();
.map(|k| {
veilid_core::TypedKey::from_str(k).map_err(|e| {
VeilidAPIError::invalid_argument(
"verifySignatures()",
format!("error decoding nodeid in node_ids[]: {}", e),
k,
)
})
})
.collect::<APIResult<Vec<TypedKey>>>()?;
let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(data.as_bytes())
.unwrap();
let data: Vec<u8> = unmarshall(data)?;
let typed_signatures = into_unchecked_string_vec(signatures);
let typed_signatures: Vec<veilid_core::TypedSignature> = typed_signatures
let typed_signatures: Vec<TypedSignature> = typed_signatures
.iter()
.map(|k| veilid_core::TypedSignature::from_str(k).unwrap())
.collect();
.map(|k| {
TypedSignature::from_str(k).map_err(|e| {
VeilidAPIError::invalid_argument(
"verifySignatures()",
format!("error decoding keypair in key_pairs[]: {}", e),
k,
)
})
})
.collect::<APIResult<Vec<TypedSignature>>>()?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;
@ -223,15 +227,21 @@ impl VeilidCrypto {
}
pub fn generateSignatures(data: String, key_pairs: StringArray) -> APIResult<StringArray> {
let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(data.as_bytes())
.unwrap();
let data = unmarshall(data)?;
let key_pairs = into_unchecked_string_vec(key_pairs);
let key_pairs: Vec<veilid_core::TypedKeyPair> = key_pairs
let key_pairs: Vec<TypedKeyPair> = key_pairs
.iter()
.map(|k| veilid_core::TypedKeyPair::from_str(k).unwrap())
.collect();
.map(|k| {
veilid_core::TypedKeyPair::from_str(k).map_err(|e| {
VeilidAPIError::invalid_argument(
"generateSignatures()",
format!("error decoding keypair in key_pairs[]: {}", e),
k,
)
})
})
.collect::<APIResult<Vec<veilid_core::TypedKeyPair>>>()?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;
@ -262,9 +272,7 @@ impl VeilidCrypto {
pub fn generateHash(kind: String, data: String) -> APIResult<String> {
let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?;
let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(data.as_bytes())
.unwrap();
let data = unmarshall(data)?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;
@ -301,9 +309,7 @@ impl VeilidCrypto {
pub fn validateHash(kind: String, data: String, hash: String) -> APIResult<bool> {
let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?;
let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(data.as_bytes())
.unwrap();
let data = unmarshall(data)?;
let hash: veilid_core::HashDigest = veilid_core::HashDigest::from_str(&hash)?;
@ -345,9 +351,7 @@ impl VeilidCrypto {
let key: veilid_core::PublicKey = veilid_core::PublicKey::from_str(&key)?;
let secret: veilid_core::SecretKey = veilid_core::SecretKey::from_str(&secret)?;
let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(data.as_bytes())
.unwrap();
let data = unmarshall(data)?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;
@ -362,9 +366,7 @@ impl VeilidCrypto {
let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?;
let key: veilid_core::PublicKey = veilid_core::PublicKey::from_str(&key)?;
let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(data.as_bytes())
.unwrap();
let data = unmarshall(data)?;
let signature: veilid_core::Signature = veilid_core::Signature::from_str(&signature)?;
let veilid_api = get_veilid_api()?;
@ -401,20 +403,16 @@ impl VeilidCrypto {
) -> APIResult<String> {
let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?;
let body: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(body.as_bytes())
.unwrap();
let body = unmarshall(body)?;
let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce)?;
let shared_secret: veilid_core::SharedSecret =
veilid_core::SharedSecret::from_str(&shared_secret)?;
let associated_data: Option<Vec<u8>> = associated_data.map(|ad| {
data_encoding::BASE64URL_NOPAD
.decode(ad.as_bytes())
.unwrap()
});
let associated_data = associated_data
.map(|ad| unmarshall(ad))
.map_or(APIResult::Ok(None), |r| r.map(Some))?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;
@ -447,20 +445,16 @@ impl VeilidCrypto {
) -> APIResult<String> {
let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?;
let body: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(body.as_bytes())
.unwrap();
let body = unmarshall(body)?;
let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce).unwrap();
let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce)?;
let shared_secret: veilid_core::SharedSecret =
veilid_core::SharedSecret::from_str(&shared_secret).unwrap();
veilid_core::SharedSecret::from_str(&shared_secret)?;
let associated_data: Option<Vec<u8>> = associated_data.map(|ad| {
data_encoding::BASE64URL_NOPAD
.decode(ad.as_bytes())
.unwrap()
});
let associated_data: Option<Vec<u8>> = associated_data
.map(|ad| unmarshall(ad))
.map_or(APIResult::Ok(None), |r| r.map(Some))?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;
@ -492,14 +486,12 @@ impl VeilidCrypto {
) -> APIResult<String> {
let kind: veilid_core::CryptoKind = veilid_core::FourCC::from_str(&kind)?;
let mut body: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(body.as_bytes())
.unwrap();
let mut body = unmarshall(body)?;
let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce).unwrap();
let nonce: veilid_core::Nonce = veilid_core::Nonce::from_str(&nonce)?;
let shared_secret: veilid_core::SharedSecret =
veilid_core::SharedSecret::from_str(&shared_secret).unwrap();
veilid_core::SharedSecret::from_str(&shared_secret)?;
let veilid_api = get_veilid_api()?;
let crypto = veilid_api.crypto()?;

31
veilid-wasm/src/veilid_routing_context_js.rs
View File

@ -44,9 +44,7 @@ impl VeilidRoutingContext {
///
/// Returns a route id that can be used to send private messages to the node creating this route.
pub fn importRemotePrivateRoute(&self, blob: String) -> APIResult<RouteId> {
let blob: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(blob.as_bytes())
.unwrap();
let blob = unmarshall(blob)?;
let veilid_api = get_veilid_api()?;
let route_id = veilid_api.import_remote_private_route(blob)?;
APIResult::Ok(route_id)
@ -86,7 +84,7 @@ impl VeilidRoutingContext {
/// * `call_id` - specifies which call to reply to, and it comes from a VeilidUpdate::AppCall, specifically the VeilidAppCall::id() value.
/// * `message` - is an answer blob to be returned by the remote node's RoutingContext::app_call() function, and may be up to 32768 bytes
pub async fn appCallReply(call_id: String, message: String) -> APIResult<()> {
let message = unmarshall(message);
let message = unmarshall(message)?;
let call_id = match call_id.parse() {
Ok(v) => v,
Err(e) => {
@ -152,7 +150,7 @@ impl VeilidRoutingContext {
#[wasm_bindgen(skip_jsdoc)]
pub async fn appMessage(&self, target_string: String, message: String) -> APIResult<()> {
let routing_context = self.getRoutingContext()?;
let message = unmarshall(message);
let message = unmarshall(message)?;
let veilid_api = get_veilid_api()?;
let target = veilid_api.parse_as_target(target_string).await?;
@ -169,7 +167,7 @@ impl VeilidRoutingContext {
/// @returns an answer blob of up to `32768` bytes, base64Url encoded.
#[wasm_bindgen(skip_jsdoc)]
pub async fn appCall(&self, target_string: String, request: String) -> APIResult<String> {
let request: Vec<u8> = unmarshall(request);
let request: Vec<u8> = unmarshall(request)?;
let routing_context = self.getRoutingContext()?;
let veilid_api = get_veilid_api()?;
@ -215,11 +213,10 @@ impl VeilidRoutingContext {
key: String,
writer: Option<String>,
) -> APIResult<DHTRecordDescriptor> {
let key = TypedKey::from_str(&key).unwrap();
let writer = match writer {
Some(writer) => Some(KeyPair::from_str(&writer).unwrap()),
_ => None,
};
let key = TypedKey::from_str(&key)?;
let writer = writer
.map(|writer| KeyPair::from_str(&writer))
.map_or(APIResult::Ok(None), |r| r.map(Some))?;
let routing_context = self.getRoutingContext()?;
let dht_record_descriptor = routing_context.open_dht_record(key, writer).await?;
@ -230,7 +227,7 @@ impl VeilidRoutingContext {
///
/// Closing a record allows you to re-open it with a different routing context
pub async fn closeDhtRecord(&self, key: String) -> APIResult<()> {
let key = TypedKey::from_str(&key).unwrap();
let key = TypedKey::from_str(&key)?;
let routing_context = self.getRoutingContext()?;
routing_context.close_dht_record(key).await?;
APIRESULT_UNDEFINED
@ -242,7 +239,7 @@ impl VeilidRoutingContext {
/// Deleting a record does not delete it from the network, but will remove the storage of the record locally,
/// and will prevent its value from being refreshed on the network by this node.
pub async fn deleteDhtRecord(&self, key: String) -> APIResult<()> {
let key = TypedKey::from_str(&key).unwrap();
let key = TypedKey::from_str(&key)?;
let routing_context = self.getRoutingContext()?;
routing_context.delete_dht_record(key).await?;
APIRESULT_UNDEFINED
@ -260,7 +257,7 @@ impl VeilidRoutingContext {
subKey: u32,
forceRefresh: bool,
) -> APIResult<Option<ValueData>> {
let key = TypedKey::from_str(&key).unwrap();
let key = TypedKey::from_str(&key)?;
let routing_context = self.getRoutingContext()?;
let res = routing_context
.get_dht_value(key, subKey, forceRefresh)
@ -278,10 +275,8 @@ impl VeilidRoutingContext {
subKey: u32,
data: String,
) -> APIResult<Option<ValueData>> {
let key = TypedKey::from_str(&key).unwrap();
let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
.decode(&data.as_bytes())
.unwrap();
let key = TypedKey::from_str(&key)?;
let data = unmarshall(data)?;
let routing_context = self.getRoutingContext()?;
let res = routing_context.set_dht_value(key, subKey, data).await?;

22
veilid-wasm/src/veilid_table_db_js.rs
View File

@ -63,11 +63,11 @@ impl VeilidTableDB {
/// Read a key from a column in the TableDB immediately.
pub async fn load(&mut self, columnId: u32, key: String) -> APIResult<Option<String>> {
self.ensureOpen().await;
let key = unmarshall(key);
let key = unmarshall(key)?;
let table_db = self.getTableDB()?;
let out = table_db.load(columnId, &key).await?.unwrap();
let out = Some(marshall(&out));
let out = table_db.load(columnId, &key).await?;
let out = out.map(|out| marshall(&out));
APIResult::Ok(out)
}
@ -75,8 +75,8 @@ impl VeilidTableDB {
/// Performs a single transaction immediately.
pub async fn store(&mut self, columnId: u32, key: String, value: String) -> APIResult<()> {
self.ensureOpen().await;
let key = unmarshall(key);
let value = unmarshall(value);
let key = unmarshall(key)?;
let value = unmarshall(value)?;
let table_db = self.getTableDB()?;
table_db.store(columnId, &key, &value).await?;
@ -86,11 +86,11 @@ impl VeilidTableDB {
/// Delete key with from a column in the TableDB.
pub async fn delete(&mut self, columnId: u32, key: String) -> APIResult<Option<String>> {
self.ensureOpen().await;
let key = unmarshall(key);
let key = unmarshall(key)?;
let table_db = self.getTableDB()?;
let out = table_db.delete(columnId, &key).await?.unwrap();
let out = Some(marshall(&out));
let out = table_db.delete(columnId, &key).await?;
let out = out.map(|out| marshall(&out));
APIResult::Ok(out)
}
@ -161,15 +161,15 @@ impl VeilidTableDBTransaction {
/// Store a key with a value in a column in the TableDB.
/// Does not modify TableDB until `.commit()` is called.
pub fn store(&self, col: u32, key: String, value: String) -> APIResult<()> {
let key = unmarshall(key);
let value = unmarshall(value);
let key = unmarshall(key)?;
let value = unmarshall(value)?;
let transaction = self.getTransaction()?;
transaction.store(col, &key, &value)
}
/// Delete key with from a column in the TableDB
pub fn deleteKey(&self, col: u32, key: String) -> APIResult<()> {
let key = unmarshall(key);
let key = unmarshall(key)?;
let transaction = self.getTransaction()?;
transaction.delete(col, &key)
}