Cleanup

Author: jsdt

crates/core/src/host/instance_env.rs

@@ -16,6 +16,7 @@ use spacetimedb_sats::{
 };
 use spacetimedb_table::indexes::RowPointer;
 use spacetimedb_table::table::RowRef;
+use std::fmt::Display;
 use std::ops::DerefMut;
 use std::sync::Arc;
 
@@ -499,6 +500,13 @@ impl From<GetTxError> for NodesError {
     }
 }
 
+impl Display for GetTxError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "not in a transaction")
+    }
+}
+impl std::error::Error for GetTxError {}
+
 #[cfg(test)]
 mod test {
     use super::*;

crates/core/src/host/wasmtime/wasm_instance_env.rs

@@ -1214,15 +1214,13 @@ impl WasmInstanceEnv {
         connection_id: WasmPtr<ConnectionId>,
         out_ptr: WasmPtr<u32>,
     ) -> RtResult<()> {
-        log::info!("Calling has_jwt");
         Self::with_span(caller, AbiCall::JwtLength, |caller| {
             let (mem, env) = Self::mem_env(caller);
             let cid = ConnectionId::read_from(mem, connection_id)?;
             let length = env
                 .instance_env
                 .tx
-                .get()
-                .unwrap()
+                .get()?
                 .get_jwt_payload(cid)?
                 .map(|p| p.len() as u32)
                 .unwrap_or(0u32);
@@ -1241,33 +1239,27 @@ impl WasmInstanceEnv {
         Self::with_span(caller, AbiCall::GetJwt, |caller| {
             let (mem, env) = Self::mem_env(caller);
             let cid = ConnectionId::read_from(mem, connection_id)?;
-            let jwt = match env.instance_env.tx.get().unwrap().get_jwt_payload(cid)? {
+            let jwt = match env.instance_env.tx.get()?.get_jwt_payload(cid)? {
                 None => {
                     // Consider logging here, since this should only happen during an upgrade.
                     0u32.write_to(mem, target_ptr_len)?;
                     return Ok(());
                 }
                 Some(jwt) => jwt,
             };
-            log::info!("JWT payload found for connection ID: {:?}: {}", cid.to_hex(), jwt);
             let jwt_len = jwt.len();
             // Read `buffer_len`, i.e., the capacity of `buffer` pointed to by `buffer_ptr`.
             let buffer_len = u32::read_from(mem, target_ptr_len)?;
-            log::info!("buffer_len: {buffer_len}");
             if buffer_len < jwt_len as u32 {
                 return Err(anyhow::anyhow!("buffer too small to hold JWT payload"));
             }
-            log::info!("About to write length");
             // Write the length of the JWT payload to the target pointer.
             (jwt_len as u32).write_to(mem, target_ptr_len)?;
-            log::info!("wrote length of {jwt_len}");
-            log::info!("Byte len {}", jwt.len());
 
             // Write the JWT payload to the target pointer.
             // Get a mutable view to the `buffer`.
             let buffer = mem.deref_slice_mut(target_ptr, buffer_len)?;
             buffer[..jwt_len].copy_from_slice(jwt.as_bytes());
-            log::info!("wrote jwt bytes to slice");
             Ok(())
         })
     }