chore: M5 CI/Workflow Sweep - final synchronisation

Author: hyperpolymath

ffi/zig/src/main.zig

@@ -1,4 +1,4 @@
-// {{PROJECT}} FFI Implementation
+// CIVIC_CONNECT FFI Implementation
 //
 // This module implements the C-compatible FFI declared in src/abi/Foreign.idr
 // All types and layouts must match the Idris2 ABI definitions.
@@ -9,7 +9,7 @@ const std = @import("std");
 
 // Version information (keep in sync with project)
 const VERSION = "0.1.0";
-const BUILD_INFO = "{{PROJECT}} built with Zig " ++ @import("builtin").zig_version_string;
+const BUILD_INFO = "CIVIC_CONNECT built with Zig " ++ @import("builtin").zig_version_string;
 
 /// Thread-local error storage
 threadlocal var last_error: ?[]const u8 = null;
@@ -51,7 +51,7 @@ pub const Handle = opaque {
 
 /// Initialize the library
 /// Returns a handle, or null on failure
-export fn {{project}}_init() ?*Handle {
+export fn civic_connect_init() ?*Handle {
     const allocator = std.heap.c_allocator;
 
     const handle = allocator.create(Handle) catch {
@@ -70,7 +70,7 @@ export fn {{project}}_init() ?*Handle {
 }
 
 /// Free the library handle
-export fn {{project}}_free(handle: ?*Handle) void {
+export fn civic_connect_free(handle: ?*Handle) void {
     const h = handle orelse return;
     const allocator = h.allocator;
 
@@ -86,7 +86,7 @@ export fn {{project}}_free(handle: ?*Handle) void {
 //==============================================================================
 
 /// Process data (example operation)
-export fn {{project}}_process(handle: ?*Handle, input: u32) Result {
+export fn civic_connect_process(handle: ?*Handle, input: u32) Result {
     const h = handle orelse {
         setError("Null handle");
         return .null_pointer;
@@ -110,7 +110,7 @@ export fn {{project}}_process(handle: ?*Handle, input: u32) Result {
 
 /// Get a string result (example)
 /// Caller must free the returned string
-export fn {{project}}_get_string(handle: ?*Handle) ?[*:0]const u8 {
+export fn civic_connect_get_string(handle: ?*Handle) ?[*:0]const u8 {
     const h = handle orelse {
         setError("Null handle");
         return null;
@@ -132,7 +132,7 @@ export fn {{project}}_get_string(handle: ?*Handle) ?[*:0]const u8 {
 }
 
 /// Free a string allocated by the library
-export fn {{project}}_free_string(str: ?[*:0]const u8) void {
+export fn civic_connect_free_string(str: ?[*:0]const u8) void {
     const s = str orelse return;
     const allocator = std.heap.c_allocator;
 
@@ -145,7 +145,7 @@ export fn {{project}}_free_string(str: ?[*:0]const u8) void {
 //==============================================================================
 
 /// Process an array of data
-export fn {{project}}_process_array(
+export fn civic_connect_process_array(
     handle: ?*Handle,
     buffer: ?[*]const u8,
     len: u32,
@@ -181,7 +181,7 @@ export fn {{project}}_process_array(
 
 /// Get the last error message
 /// Returns null if no error
-export fn {{project}}_last_error() ?[*:0]const u8 {
+export fn civic_connect_last_error() ?[*:0]const u8 {
     const err = last_error orelse return null;
 
     // Return C string (static storage, no need to free)
@@ -195,12 +195,12 @@ export fn {{project}}_last_error() ?[*:0]const u8 {
 //==============================================================================
 
 /// Get the library version
-export fn {{project}}_version() [*:0]const u8 {
+export fn civic_connect_version() [*:0]const u8 {
     return VERSION.ptr;
 }
 
 /// Get build information
-export fn {{project}}_build_info() [*:0]const u8 {
+export fn civic_connect_build_info() [*:0]const u8 {
     return BUILD_INFO.ptr;
 }
 
@@ -212,7 +212,7 @@ export fn {{project}}_build_info() [*:0]const u8 {
 pub const Callback = *const fn (u64, u32) callconv(.C) u32;
 
 /// Register a callback
-export fn {{project}}_register_callback(
+export fn civic_connect_register_callback(
     handle: ?*Handle,
     callback: ?Callback,
 ) Result {
@@ -243,7 +243,7 @@ export fn {{project}}_register_callback(
 //==============================================================================
 
 /// Check if handle is initialized
-export fn {{project}}_is_initialized(handle: ?*Handle) u32 {
+export fn civic_connect_is_initialized(handle: ?*Handle) u32 {
     const h = handle orelse return 0;
     return if (h.initialized) 1 else 0;
 }
@@ -253,22 +253,22 @@ export fn {{project}}_is_initialized(handle: ?*Handle) u32 {
 //==============================================================================
 
 test "lifecycle" {
-    const handle = {{project}}_init() orelse return error.InitFailed;
-    defer {{project}}_free(handle);
+    const handle = civic_connect_init() orelse return error.InitFailed;
+    defer civic_connect_free(handle);
 
-    try std.testing.expect({{project}}_is_initialized(handle) == 1);
+    try std.testing.expect(civic_connect_is_initialized(handle) == 1);
 }
 
 test "error handling" {
-    const result = {{project}}_process(null, 0);
+    const result = civic_connect_process(null, 0);
     try std.testing.expectEqual(Result.null_pointer, result);
 
-    const err = {{project}}_last_error();
+    const err = civic_connect_last_error();
     try std.testing.expect(err != null);
 }
 
 test "version" {
-    const ver = {{project}}_version();
+    const ver = civic_connect_version();
     const ver_str = std.mem.span(ver);
     try std.testing.expectEqualStrings(VERSION, ver_str);
 }

indieweb2-bastion/graphql-dns-api/src/blockchain.rs

@@ -120,7 +120,7 @@ impl BlockchainClient {
     pub async fn verify_hash(&self, tx_hash: &str, expected_hash: &str) -> Result<bool> {
         let tx: Transaction = self
             .provider
-            .get_transaction(tx_hash.parse::<TxHash>().unwrap())
+            .get_transaction(tx_hash.parse::<TxHash>().expect("TODO: handle error"))
             .await
             .map_err(|e| AppError::Blockchain(e.to_string()))?
             .ok_or_else(|| AppError::Blockchain("Transaction not found".to_string()))?;
@@ -143,7 +143,7 @@ impl BlockchainClient {
     pub async fn get_receipt(&self, tx_hash: &str) -> Result<TransactionReceipt> {
         let receipt = self
             .provider
-            .get_transaction_receipt(tx_hash.parse::<TxHash>().unwrap())
+            .get_transaction_receipt(tx_hash.parse::<TxHash>().expect("TODO: handle error"))
             .await
             .map_err(|e| AppError::Blockchain(e.to_string()))?
             .ok_or_else(|| AppError::Blockchain("Transaction receipt not found".to_string()))?;

indieweb2-bastion/odns-rs/common/src/crypto.rs

@@ -164,10 +164,10 @@ mod tests {
         let (pk, sk) = generate_keypair();
         let plaintext = b"example.com A query";
 
-        let encrypted = encrypt_query(plaintext, &pk).unwrap();
+        let encrypted = encrypt_query(plaintext, &pk).expect("TODO: handle error");
         assert!(encrypted.len() >= OVERHEAD);
 
-        let decrypted = decrypt_query(&encrypted, &sk).unwrap();
+        let decrypted = decrypt_query(&encrypted, &sk).expect("TODO: handle error");
         assert_eq!(decrypted, plaintext);
     }
 
@@ -176,7 +176,7 @@ mod tests {
         let (pk, _sk) = generate_keypair();
         let (_pk2, sk2) = generate_keypair();
 
-        let encrypted = encrypt_query(b"secret query", &pk).unwrap();
+        let encrypted = encrypt_query(b"secret query", &pk).expect("TODO: handle error");
         let result = decrypt_query(&encrypted, &sk2);
         assert!(result.is_err());
     }
@@ -191,11 +191,11 @@ mod tests {
     fn key_serialization_roundtrip() {
         let (pk, sk) = generate_keypair();
 
-        let pk2 = public_key_from_bytes(pk.as_bytes()).unwrap();
-        let sk2 = secret_key_from_bytes(sk.as_bytes()).unwrap();
+        let pk2 = public_key_from_bytes(pk.as_bytes()).expect("TODO: handle error");
+        let sk2 = secret_key_from_bytes(sk.as_bytes()).expect("TODO: handle error");
 
-        let encrypted = encrypt_query(b"test", &pk2).unwrap();
-        let decrypted = decrypt_query(&encrypted, &sk2).unwrap();
+        let encrypted = encrypt_query(b"test", &pk2).expect("TODO: handle error");
+        let decrypted = decrypt_query(&encrypted, &sk2).expect("TODO: handle error");
         assert_eq!(decrypted, b"test");
     }
 }

indieweb2-bastion/odns-rs/common/src/protocol.rs

@@ -59,10 +59,10 @@ mod tests {
     async fn framed_roundtrip() {
         let data = b"hello, oDNS";
         let mut buf = Vec::new();
-        write_framed(&mut buf, data).await.unwrap();
+        write_framed(&mut buf, data).await.expect("TODO: handle error");
 
         let mut cursor = std::io::Cursor::new(buf);
-        let result = read_framed(&mut cursor).await.unwrap();
+        let result = read_framed(&mut cursor).await.expect("TODO: handle error");
         assert_eq!(result, data);
     }
 

indieweb2-bastion/odns-rs/common/src/signatures.rs

@@ -211,7 +211,7 @@ mod tests {
         let msg = b"test message for hybrid signature";
 
         let sig = hybrid_sign(msg, &kp);
-        let pk = kp.public_key().unwrap();
+        let pk = kp.public_key().expect("TODO: handle error");
 
         assert!(hybrid_verify(msg, &sig, &pk).is_ok());
     }
@@ -220,7 +220,7 @@ mod tests {
     fn hybrid_rejects_wrong_message() {
         let kp = generate_hybrid_keypair();
         let sig = hybrid_sign(b"original", &kp);
-        let pk = kp.public_key().unwrap();
+        let pk = kp.public_key().expect("TODO: handle error");
 
         let result = hybrid_verify(b"tampered", &sig, &pk);
         assert!(result.is_err());
@@ -232,7 +232,7 @@ mod tests {
         let kp2 = generate_hybrid_keypair();
 
         let sig = hybrid_sign(b"test", &kp1);
-        let pk2 = kp2.public_key().unwrap();
+        let pk2 = kp2.public_key().expect("TODO: handle error");
 
         let result = hybrid_verify(b"test", &sig, &pk2);
         assert!(result.is_err());
@@ -241,12 +241,12 @@ mod tests {
     #[test]
     fn public_key_serialization_roundtrip() {
         let kp = generate_hybrid_keypair();
-        let pk = kp.public_key().unwrap();
+        let pk = kp.public_key().expect("TODO: handle error");
 
         let bytes = pk.to_bytes();
         assert_eq!(bytes.len(), HYBRID_PK_LEN);
 
-        let pk2 = HybridPublicKey::from_bytes(&bytes).unwrap();
+        let pk2 = HybridPublicKey::from_bytes(&bytes).expect("TODO: handle error");
         assert_eq!(pk.ed448_vk.to_bytes(), pk2.ed448_vk.to_bytes());
         assert_eq!(pk.dil5_pk.as_bytes(), pk2.dil5_pk.as_bytes());
     }
@@ -260,8 +260,8 @@ mod tests {
         let bytes = sig.to_bytes();
         assert_eq!(bytes.len(), HYBRID_SIG_LEN);
 
-        let sig2 = HybridSignature::from_bytes(&bytes).unwrap();
-        let pk = kp.public_key().unwrap();
+        let sig2 = HybridSignature::from_bytes(&bytes).expect("TODO: handle error");
+        let pk = kp.public_key().expect("TODO: handle error");
         assert!(hybrid_verify(msg, &sig2, &pk).is_ok());
     }
 }

indieweb2-bastion/odns-rs/common/src/sphincs_fallback.rs

@@ -147,7 +147,7 @@ mod tests {
 
         let pk_restored = public_key_from_bytes(&pk_bytes);
         assert!(pk_restored.is_ok());
-        assert_eq!(pk_restored.unwrap().as_bytes(), kp.pk.as_bytes());
+        assert_eq!(pk_restored.expect("TODO: handle error").as_bytes(), kp.pk.as_bytes());
     }
 
     #[test]