ffi work

veilid-flutter/rust/src/dart_ffi.rs

@@ -494,10 +494,10 @@ pub extern "C" fn routing_context_app_message(port: i64, id: u32, target: FfiStr
 
 #[no_mangle]
 pub extern "C" fn routing_context_create_dht_record(port: i64, id: u32, kind: u32, schema: FfiStr) {
-    let crypto_kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind.to_be_bytes());
+    let crypto_kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
     let schema: veilid_core::DHTSchema = veilid_core::deserialize_opt_json(schema.into_opt_string()).unwrap();
 
-    DartIsolateWrapper::new(port).spawn_result(async move {        
+    DartIsolateWrapper::new(port).spawn_result_json(async move {        
         let routing_context = {
             let rc = ROUTING_CONTEXTS.lock();
             let Some(routing_context) = rc.get(&id) else {
@@ -507,16 +507,15 @@ pub extern "C" fn routing_context_create_dht_record(port: i64, id: u32, kind: u3
         };
         
         let dht_record_descriptor = routing_context.create_dht_record(crypto_kind, schema).await?;
-        let out = veilid_core::serialize_json(dht_record_descriptor);
-        APIResult::Ok(out)
+        APIResult::Ok(dht_record_descriptor)
     });
 }
 
 #[no_mangle]
 pub extern "C" fn routing_context_open_dht_record(port: i64, id: u32, key: FfiStr, writer: FfiStr) {
     let key: veilid_core::TypedKey = veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
-    let writer: Option<KeyPair> = writer.into_opt_string().map(|s| veilid_core::deserialize_json(&s).unwrap());
-    DartIsolateWrapper::new(port).spawn_result(async move {        
+    let writer: Option<veilid_core::KeyPair> = writer.into_opt_string().map(|s| veilid_core::deserialize_json(&s).unwrap());
+    DartIsolateWrapper::new(port).spawn_result_json(async move {        
         let routing_context = {
             let rc = ROUTING_CONTEXTS.lock();
             let Some(routing_context) = rc.get(&id) else {
@@ -524,31 +523,125 @@ pub extern "C" fn routing_context_open_dht_record(port: i64, id: u32, key: FfiSt
             };
             routing_context.clone()
         };
-        let writer = match writer {
-            Some(w) => w.to_key_pair(key.kind)?,
-            None => None
-        };
         let dht_record_descriptor = routing_context.open_dht_record(key, writer).await?;
-        let out = veilid_core::serialize_json(dht_record_descriptor);
-        APIResult::Ok(out)
+        APIResult::Ok(dht_record_descriptor)
     });
 }
 
 
-
-// final _RoutingContextCloseDHTRecordDart _RoutingContextCloseDHTRecord;
-// final _RoutingContextDeleteDHTRecordDart _RoutingContextDeleteDHTRecord;
-// final _RoutingContextGetDHTValueDart _RoutingContextGetDHTValue;
-// final _RoutingContextSetDHTValueDart _RoutingContextSetDHTValue;
-// final _RoutingContextWatchDHTValuesDart _RoutingContextWatchDHTValues;
-// final _RoutingContextCancelDHTWatchDart _RoutingContextCancelDHTWatch;
+#[no_mangle]
+pub extern "C" fn routing_context_close_dht_record(port: i64, id: u32, key: FfiStr) {
+    let key: veilid_core::TypedKey = veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    DartIsolateWrapper::new(port).spawn_result(async move {        
+        let routing_context = {
+            let rc = ROUTING_CONTEXTS.lock();
+            let Some(routing_context) = rc.get(&id) else {
+                return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_close_dht_record", "id", id));
+            };
+            routing_context.clone()
+        };
+        routing_context.close_dht_record(key).await?;
+        APIRESULT_VOID
+    });
+}
 
 
+#[no_mangle]
+pub extern "C" fn routing_context_delete_dht_record(port: i64, id: u32, key: FfiStr) {
+    let key: veilid_core::TypedKey = veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    DartIsolateWrapper::new(port).spawn_result(async move {        
+        let routing_context = {
+            let rc = ROUTING_CONTEXTS.lock();
+            let Some(routing_context) = rc.get(&id) else {
+                return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_delete_dht_record", "id", id));
+            };
+            routing_context.clone()
+        };
+        routing_context.delete_dht_record(key).await?;
+        APIRESULT_VOID
+    });
+}
 
 
+#[no_mangle]
+pub extern "C" fn routing_context_get_dht_value(port: i64, id: u32, key: FfiStr, subkey: u32, force_refresh: bool) {
+    let key: veilid_core::TypedKey = veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    DartIsolateWrapper::new(port).spawn_result_json(async move {        
+        let routing_context = {
+            let rc = ROUTING_CONTEXTS.lock();
+            let Some(routing_context) = rc.get(&id) else {
+                return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_get_dht_value", "id", id));
+            };
+            routing_context.clone()
+        };
+        let res = routing_context.get_dht_value(key, subkey, force_refresh).await?;
+        APIResult::Ok(res)
+    });
+}
 
 
+#[no_mangle]
+pub extern "C" fn routing_context_set_dht_value(port: i64, id: u32, key: FfiStr, subkey: u32, data: FfiStr) {
+    let key: veilid_core::TypedKey = veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
+    .decode(
+        data.into_opt_string()
+            .unwrap()
+            .as_bytes(),
+    )
+    .unwrap();
 
+    DartIsolateWrapper::new(port).spawn_result_json(async move {        
+        let routing_context = {
+            let rc = ROUTING_CONTEXTS.lock();
+            let Some(routing_context) = rc.get(&id) else {
+                return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_set_dht_value", "id", id));
+            };
+            routing_context.clone()
+        };
+        let res = routing_context.set_dht_value(key, subkey, data).await?;
+        APIResult::Ok(res)
+    });
+}
+
+
+#[no_mangle]
+pub extern "C" fn routing_context_watch_dht_values(port: i64, id: u32, key: FfiStr, subkeys: FfiStr, expiration: FfiStr, count: u32) {
+    let key: veilid_core::TypedKey = veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    let subkeys: veilid_core::ValueSubkeyRangeSet = veilid_core::deserialize_opt_json(subkeys.into_opt_string()).unwrap();
+    let expiration = veilid_core::Timestamp::from_str(expiration.as_opt_str().unwrap()).unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result(async move {        
+        let routing_context = {
+            let rc = ROUTING_CONTEXTS.lock();
+            let Some(routing_context) = rc.get(&id) else {
+                return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_set_dht_value", "id", id));
+            };
+            routing_context.clone()
+        };
+        let res = routing_context.watch_dht_values(key, subkeys, expiration, count).await?;
+        APIResult::Ok(res.to_string())
+    });
+}
+
+
+#[no_mangle]
+pub extern "C" fn routing_context_cancel_dht_watch(port: i64, id: u32, key: FfiStr, subkeys: FfiStr) {
+    let key: veilid_core::TypedKey = veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    let subkeys: veilid_core::ValueSubkeyRangeSet = veilid_core::deserialize_opt_json(subkeys.into_opt_string()).unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result(async move {        
+        let routing_context = {
+            let rc = ROUTING_CONTEXTS.lock();
+            let Some(routing_context) = rc.get(&id) else {
+                return APIResult::Err(veilid_core::VeilidAPIError::invalid_argument("routing_context_set_dht_value", "id", id));
+            };
+            routing_context.clone()
+        };
+        let res = routing_context.cancel_dht_watch(key, subkeys).await?;
+        APIResult::Ok(res)
+    });
+}
 
 
 #[no_mangle]
@@ -894,34 +987,390 @@ pub extern "C" fn table_db_delete(port: i64, id: u32, col: u32, key: FfiStr) {
 }
 
 
+#[no_mangle]
+pub extern "C" fn valid_crypto_kinds() -> *mut c_char {
+    veilid_core::serialize_json(veilid_core::VALID_CRYPTO_KINDS.iter().map(|k| (*k).into()).collect::<Vec<u32>>()).into_ffi_value()
+}
 
-final _ValidCryptoKindsDart _validCryptoKinds;
-final _GetCryptoSystemDart _getCryptoSystem;
-final _BestCryptoSystemDart _bestCryptoSystem;
-final _VerifySignaturesDart _verifySignatures;
-final _GenerateSignaturesDart _generateSignatures;
-final _GenerateKeyPairDart _generateKeyPair;
+#[no_mangle]
+pub extern "C" fn best_crypto_kind() -> u32 {
+    veilid_core::best_crypto_kind().into()
+}
 
-final _CryptoCachedDHDart _cryptoCachedDH;
-final _CryptoComputeDHDart _cryptoComputeDH;
-final _CryptoRandomNonceDart _cryptoRandomNonce;
-final _CryptoRandomSharedSecretDart _cryptoRandomSharedSecret;
-final _CryptoGenerateKeyPairDart _cryptoGenerateKeyPair;
-final _CryptoGenerateHashDart _cryptoGenerateHash;
-final _CryptoGenerateHashReaderDart _cryptoGenerateHashReader;
-final _CryptoValidateKeyPairDart _cryptoValidateKeyPair;
-final _CryptoValidateHashDart _cryptoValidateHash;
-final _CryptoValidateHashReaderDart _cryptoValidateHashReader;
-final _CryptoDistanceDart _cryptoDistance;
-final _CryptoSignDart _cryptoSign;
-final _CryptoVerifyDart _cryptoVerify;
-final _CryptoAaedOverheadDart _cryptoAeadOverhead;
-final _CryptoDecryptAeadDart _cryptoDecryptAead;
-final _CryptoEncryptAeadDart _cryptoEncryptAead;
-final _CryptoCryptNoAuthDart _cryptoCryptNoAuth;
+#[no_mangle]
+pub extern "C" fn verify_signatures(port: i64, node_ids: FfiStr, data: FfiStr, signatures: FfiStr) {
+    let node_ids: Vec<veilid_core::TypedKey> =
+        veilid_core::deserialize_opt_json(node_ids.into_opt_string()).unwrap();
 
-final _NowDart _now;
+    let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
+    .decode(
+        data.into_opt_string()
+            .unwrap()
+            .as_bytes(),
+    )
+    .unwrap();
 
+    let typed_signatures: Vec<veilid_core::TypedSignature> =
+        veilid_core::deserialize_opt_json(signatures.into_opt_string()).unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let out = crypto.verify_signatures(&node_ids, &data, &typed_signatures)?;
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn generate_signatures(port: i64, data: FfiStr, key_pairs: FfiStr) {
+
+    let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
+    .decode(
+        data.into_opt_string()
+            .unwrap()
+            .as_bytes(),
+    )
+    .unwrap();
+
+    let key_pairs: Vec<veilid_core::TypedKeyPair> =
+        veilid_core::deserialize_opt_json(key_pairs.into_opt_string()).unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let out = crypto.generate_signatures(&data, &key_pairs, |k, s| {
+            veilid_core::TypedSignature::new(k.kind, s)
+        })?;
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn generate_key_pair(port: i64, kind: u32) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let out = veilid_core::Crypto::generate_keypair(kind)?;
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_cached_dh(port: i64, kind: u32, key: FfiStr, secret: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    let key: veilid_core::PublicKey =
+        veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    let secret: veilid_core::SecretKey =
+        veilid_core::deserialize_opt_json(secret.into_opt_string()).unwrap();
+    
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_cached_dh", "kind", kind.to_string()))?;
+        let out = csv.cached_dh(&key, &secret)?;
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_compute_dh(port: i64, kind: u32, key: FfiStr, secret: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+    
+    let key: veilid_core::PublicKey =
+        veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    let secret: veilid_core::SecretKey =
+        veilid_core::deserialize_opt_json(secret.into_opt_string()).unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_compute_dh", "kind", kind.to_string()))?;
+        let out = csv.compute_dh(&key, &secret)?;
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_random_nonce(port: i64, kind: u32) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_random_nonce", "kind", kind.to_string()))?;
+        let out = csv.random_nonce();
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_random_shared_secret(port: i64, kind: u32) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_random_shared_secret", "kind", kind.to_string()))?;
+        let out = csv.random_shared_secret();
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_generate_key_pair(port: i64, kind: u32) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_generate_key_pair", "kind", kind.to_string()))?;
+        let out = csv.generate_keypair();
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_generate_hash(port: i64, kind: u32, data: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
+    .decode(
+        data.into_opt_string()
+            .unwrap()
+            .as_bytes(),
+    )
+    .unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_generate_hash", "kind", kind.to_string()))?;
+        let out = csv.generate_hash(&data);
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_validate_key_pair(port: i64, kind: u32, key: FfiStr, secret: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    let key: veilid_core::PublicKey =
+        veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    let secret: veilid_core::SecretKey =
+        veilid_core::deserialize_opt_json(secret.into_opt_string()).unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_validate_key_pair", "kind", kind.to_string()))?;
+        let out = csv.validate_keypair(&key, &secret);
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_validate_hash(port: i64, kind: u32, data: FfiStr, hash: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
+    .decode(
+        data.into_opt_string()
+            .unwrap()
+            .as_bytes(),
+    )
+    .unwrap();
+
+    let hash: veilid_core::HashDigest =
+        veilid_core::deserialize_opt_json(hash.into_opt_string()).unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_validate_hash", "kind", kind.to_string()))?;
+        let out = csv.validate_hash(&data, &hash);
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_distance(port: i64, kind: u32, key1: FfiStr, key2: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    let key1: veilid_core::CryptoKey =
+        veilid_core::deserialize_opt_json(key1.into_opt_string()).unwrap();
+    let key2: veilid_core::CryptoKey =
+        veilid_core::deserialize_opt_json(key2.into_opt_string()).unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_distance", "kind", kind.to_string()))?;
+        let out = csv.distance(&key1, &key2);
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_sign(port: i64, kind: u32, key: FfiStr, secret: FfiStr, data: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    let key: veilid_core::CryptoKey =
+        veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    let secret: veilid_core::CryptoKey =
+        veilid_core::deserialize_opt_json(secret.into_opt_string()).unwrap();
+    let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
+        .decode(
+            data.into_opt_string()
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+    
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_sign", "kind", kind.to_string()))?;
+        let out = csv.sign(&key, &secret, &data)?;
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_verify(port: i64, kind: u32, key: FfiStr, data: FfiStr, signature: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+
+    let key: veilid_core::CryptoKey =
+        veilid_core::deserialize_opt_json(key.into_opt_string()).unwrap();
+    let data: Vec<u8> = data_encoding::BASE64URL_NOPAD
+        .decode(
+            data.into_opt_string()
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+    let signature: veilid_core::Signature =
+        veilid_core::deserialize_opt_json(signature.into_opt_string()).unwrap();
+    
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_verify", "kind", kind.to_string()))?;
+        let out = csv.verify(&key, &data, &signature)?;
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_aead_overhead(port: i64, kind: u32) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+    
+    DartIsolateWrapper::new(port).spawn_result(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_aead_overhead", "kind", kind.to_string()))?;
+        let out = csv.aead_overhead();
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_decrypt_aead(port: i64, kind: u32, body: FfiStr, nonce: FfiStr, shared_secret: FfiStr, associated_data: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+    
+    let body: Vec<u8> = data_encoding::BASE64URL_NOPAD
+        .decode(
+            body.into_opt_string()
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+    
+    let nonce: veilid_core::Nonce =
+        veilid_core::deserialize_opt_json(nonce.into_opt_string()).unwrap();
+    
+    let shared_secret: veilid_core::SharedSecret =
+        veilid_core::deserialize_opt_json(shared_secret.into_opt_string()).unwrap();
+
+    let associated_data: Option<Vec<u8>> = associated_data.into_opt_string().map(|s| data_encoding::BASE64URL_NOPAD.decode(s.as_bytes()).unwrap());
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_decrypt_aead", "kind", kind.to_string()))?;
+        let out = csv.decrypt_aead(&body, &nonce, &shared_secret, match &associated_data {
+            Some(ad) => Some(ad.as_slice()),
+            None => None
+        })?;
+        APIResult::Ok(out)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn crypto_encrypt_aead(port: i64, kind: u32, body: FfiStr, nonce: FfiStr, shared_secret: FfiStr, associated_data: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+    
+    let body: Vec<u8> = data_encoding::BASE64URL_NOPAD
+        .decode(
+            body.into_opt_string()
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+    
+    let nonce: veilid_core::Nonce =
+        veilid_core::deserialize_opt_json(nonce.into_opt_string()).unwrap();
+    
+    let shared_secret: veilid_core::SharedSecret =
+        veilid_core::deserialize_opt_json(shared_secret.into_opt_string()).unwrap();
+
+    let associated_data: Option<Vec<u8>> = associated_data.into_opt_string().map(|s| data_encoding::BASE64URL_NOPAD.decode(s.as_bytes()).unwrap());
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_encrypt_aead", "kind", kind.to_string()))?;
+        let out = csv.encrypt_aead(&body, &nonce, &shared_secret, match &associated_data {
+            Some(ad) => Some(ad.as_slice()),
+            None => None
+        })?;
+        APIResult::Ok(out)
+    });
+}
+
+
+
+#[no_mangle]
+pub extern "C" fn crypto_crypt_no_auth(port: i64, kind: u32, body: FfiStr, nonce: FfiStr, shared_secret: FfiStr) {
+    let kind: veilid_core::CryptoKind = veilid_core::FourCC::from(kind);
+    
+    let mut body: Vec<u8> = data_encoding::BASE64URL_NOPAD
+        .decode(
+            body.into_opt_string()
+                .unwrap()
+                .as_bytes(),
+        )
+        .unwrap();
+    
+    let nonce: veilid_core::Nonce =
+        veilid_core::deserialize_opt_json(nonce.into_opt_string()).unwrap();
+    
+    let shared_secret: veilid_core::SharedSecret =
+        veilid_core::deserialize_opt_json(shared_secret.into_opt_string()).unwrap();
+
+    DartIsolateWrapper::new(port).spawn_result_json(async move {
+        let veilid_api = get_veilid_api().await?;
+        let crypto = veilid_api.crypto()?;
+        let csv = crypto.get(kind).ok_or_else(|| veilid_core::VeilidAPIError::invalid_argument("crypto_crypt_no_auth", "kind", kind.to_string()))?;
+        csv.crypt_in_place_no_auth(&mut body, &nonce, &shared_secret);
+        APIResult::Ok(body)
+    });
+}
+
+#[no_mangle]
+pub extern "C" fn now() -> u64 {
+    veilid_core::get_aligned_timestamp().as_u64()
+}
 
 #[no_mangle]
 pub extern "C" fn debug(port: i64, command: FfiStr) {