runtime: chore clippy

src/runtime/import/db.rs

@@ -63,7 +63,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
     if let Err(e) = acl_allow(env, &[ContractSection::Deploy]) {
         error!(
             target: "runtime::db::db_init",
-            "[WASM] [{}] db_init(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] db_init(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -80,7 +80,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
     let Ok(mem_slice) = ptr.slice(&memory_view, ptr_len) else {
         error!(
             target: "runtime::db::db_init",
-            "[WASM] [{}] db_init(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] db_init(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::DB_INIT_FAILED
     };
@@ -90,7 +90,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::db::db_init",
-            "[WASM] [{}] db_init(): Failed to read memory slice: {}", cid, e,
+            "[WASM] [{cid}] db_init(): Failed to read memory slice: {e}"
         );
         return darkfi_sdk::error::DB_INIT_FAILED
     };
@@ -103,7 +103,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
         Err(e) => {
             error!(
                 target: "runtime::db::db_init",
-                "[WASM] [{}] db_init(): Failed decoding ContractId: {}", cid, e,
+                "[WASM] [{cid}] db_init(): Failed decoding ContractId: {e}"
             );
             return darkfi_sdk::error::DB_INIT_FAILED
         }
@@ -114,7 +114,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
         Err(e) => {
             error!(
                 target: "runtime::db::db_init",
-                "[WASM] [{}] db_init(): Failed decoding db_name: {}", cid, e,
+                "[WASM] [{cid}] db_init(): Failed decoding db_name: {e}"
             );
             return darkfi_sdk::error::DB_INIT_FAILED
         }
@@ -124,7 +124,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
     if buf_reader.position() != ptr_len as u64 {
         error!(
             target: "runtime::db::db_init",
-            "[WASM] [{}] db_init(): Trailing bytes in argument stream", cid,
+            "[WASM] [{cid}] db_init(): Trailing bytes in argument stream"
         );
         return darkfi_sdk::error::DB_INIT_FAILED
     }
@@ -133,7 +133,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
     if read_db_name == SMART_CONTRACT_ZKAS_DB_NAME {
         error!(
             target: "runtime::db::db_init",
-            "[WASM] [{}] db_init(): Attempted to init zkas db", cid,
+            "[WASM] [{cid}] db_init(): Attempted to init zkas db"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -142,7 +142,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
     if cid != read_cid {
         error!(
             target: "runtime::db::db_init",
-            "[WASM] [{}] db_init(): Unauthorized ContractId", cid,
+            "[WASM] [{cid}] db_init(): Unauthorized ContractId"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -158,7 +158,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
         Err(e) => {
             error!(
                 target: "runtime::db::db_init",
-                "[WASM] [{}] db_init(): Failed to init db: {}", cid, e,
+                "[WASM] [{cid}] db_init(): Failed to init db: {e}"
             );
             return darkfi_sdk::error::DB_INIT_FAILED
         }
@@ -173,7 +173,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
     if db_handles.contains(&db_handle) {
         error!(
             target: "runtime::db::db_init",
-            "[WASM] [{}] db_init(): DbHandle initialized twice during execution", cid,
+            "[WASM] [{cid}] db_init(): DbHandle initialized twice during execution"
         );
         return darkfi_sdk::error::DB_INIT_FAILED
     }
@@ -188,7 +188,7 @@ pub(crate) fn db_init(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u
         Err(_) => {
             error!(
                 target: "runtime::db::db_init",
-                "[WASM] [{}] db_init(): Too many open DbHandles", cid,
+                "[WASM] [{cid}] db_init(): Too many open DbHandles"
             );
             darkfi_sdk::error::DB_INIT_FAILED
         }
@@ -220,7 +220,7 @@ pub(crate) fn db_lookup(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len:
     ) {
         error!(
             target: "runtime::db::db_lookup",
-            "[WASM] [{}] db_lookup() called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] db_lookup() called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -235,7 +235,7 @@ pub(crate) fn db_lookup(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len:
     let Ok(mem_slice) = ptr.slice(&memory_view, ptr_len) else {
         error!(
             target: "runtime::db::db_lookup",
-            "[WASM] [{}] db_lookup(): Failed to make slice from ptr.", cid,
+            "[WASM] [{cid}] db_lookup(): Failed to make slice from ptr."
         );
         return darkfi_sdk::error::DB_LOOKUP_FAILED
     };
@@ -244,7 +244,7 @@ pub(crate) fn db_lookup(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len:
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::db::db_lookup",
-            "[WASM] [{}] db_lookup(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] db_lookup(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::DB_LOOKUP_FAILED
     };
@@ -258,7 +258,7 @@ pub(crate) fn db_lookup(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len:
         Err(e) => {
             error!(
                 target: "runtime::db::db_lookup",
-                "[WASM] [{}] db_lookup(): Failed to decode ContractId: {}", cid, e,
+                "[WASM] [{cid}] db_lookup(): Failed to decode ContractId: {e}"
             );
             return darkfi_sdk::error::DB_LOOKUP_FAILED
         }
@@ -270,7 +270,7 @@ pub(crate) fn db_lookup(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len:
         Err(e) => {
             error!(
                 target: "runtime::db::db_lookup",
-                "[WASM] [{}] db_lookup(): Failed to decode db_name: {}", cid, e,
+                "[WASM] [{cid}] db_lookup(): Failed to decode db_name: {e}"
             );
             return darkfi_sdk::error::DB_LOOKUP_FAILED
         }
@@ -280,7 +280,7 @@ pub(crate) fn db_lookup(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len:
     if buf_reader.position() != ptr_len as u64 {
         error!(
             target: "runtime::db::db_lookup",
-            "[WASM] [{}] db_lookup(), Trailing bytes in argument stream", cid,
+            "[WASM] [{cid}] db_lookup(), Trailing bytes in argument stream"
         );
         return darkfi_sdk::error::DB_LOOKUP_FAILED
     }
@@ -288,7 +288,7 @@ pub(crate) fn db_lookup(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len:
     if db_name == SMART_CONTRACT_ZKAS_DB_NAME {
         error!(
             target: "runtime::db::db_lookup",
-            "[WASM] [{}] db_lookup(): Attempted to lookup zkas db", cid,
+            "[WASM] [{cid}] db_lookup(): Attempted to lookup zkas db"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -317,7 +317,7 @@ pub(crate) fn db_lookup(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len:
         Err(_) => {
             error!(
                 target: "runtime::db::db_lookup",
-                "[WASM] [{}] db_lookup(): Too many open DbHandles", cid,
+                "[WASM] [{cid}] db_lookup(): Too many open DbHandles"
             );
             darkfi_sdk::error::DB_LOOKUP_FAILED
         }
@@ -340,7 +340,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if let Err(e) = acl_allow(env, &[ContractSection::Deploy, ContractSection::Update]) {
         error!(
             target: "runtime::db::db_set",
-            "[WASM] [{}] db_set(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] db_set(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -355,7 +355,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     let Ok(mem_slice) = ptr.slice(&memory_view, ptr_len) else {
         error!(
             target: "runtime::db::db_set",
-            "[WASM] [{}] db_set(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] db_set(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     };
@@ -364,7 +364,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::db::db_set",
-            "[WASM] [{}] db_set(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] db_set(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     };
@@ -377,7 +377,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
         Err(e) => {
             error!(
                 target: "runtime::db::db_set",
-                "[WASM] [{}] db_set(): Failed to decode DbHandle: {}", cid, e,
+                "[WASM] [{cid}] db_set(): Failed to decode DbHandle: {e}"
             );
             return darkfi_sdk::error::DB_SET_FAILED
         }
@@ -391,7 +391,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
         Err(e) => {
             error!(
                 target: "runtime::db::db_set",
-                "[WASM] [{}] db_set(): Failed to decode key vec: {}", cid, e,
+                "[WASM] [{cid}] db_set(): Failed to decode key vec: {e}"
             );
             return darkfi_sdk::error::DB_SET_FAILED
         }
@@ -402,7 +402,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
         Err(e) => {
             error!(
                 target: "runtime::db::db_set",
-                "[WASM] [{}] db_set(): Failed to decode value vec: {}", cid, e,
+                "[WASM] [{cid}] db_set(): Failed to decode value vec: {e}"
             );
             return darkfi_sdk::error::DB_SET_FAILED
         }
@@ -412,7 +412,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if buf_reader.position() != ptr_len as u64 {
         error!(
             target: "runtime::db::db_set",
-            "[WASM] [{}] db_set(): Trailing bytes in argument stream", cid,
+            "[WASM] [{cid}] db_set(): Trailing bytes in argument stream"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     }
@@ -423,7 +423,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if db_handles.len() <= db_handle_index {
         error!(
             target: "runtime::db::db_set",
-            "[WASM] [{}] db_set(): Requested DbHandle that is out of bounds", cid,
+            "[WASM] [{cid}] db_set(): Requested DbHandle that is out of bounds"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     }
@@ -435,7 +435,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if db_handle.contract_id != env.contract_id {
         error!(
             target: "runtime::db::db_set",
-            "[WASM] [{}] db_set(): Unauthorized to write to DbHandle", cid,
+            "[WASM] [{cid}] db_set(): Unauthorized to write to DbHandle"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -453,7 +453,7 @@ pub(crate) fn db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     {
         error!(
             target: "runtime::db::db_set",
-            "[WASM] [{}] db_set(): Couldn't insert to db_handle tree", cid,
+            "[WASM] [{cid}] db_set(): Couldn't insert to db_handle tree"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     }
@@ -474,7 +474,7 @@ pub(crate) fn db_del(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if let Err(e) = acl_allow(env, &[ContractSection::Deploy, ContractSection::Update]) {
         error!(
             target: "runtime::db::db_del",
-            "[WASM] [{}] db_del(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] db_del(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -488,7 +488,7 @@ pub(crate) fn db_del(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     let Ok(mem_slice) = ptr.slice(&memory_view, ptr_len) else {
         error!(
             target: "runtime::db::db_del",
-            "[WASM] [{}] db_del(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] db_del(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::DB_DEL_FAILED
     };
@@ -497,7 +497,7 @@ pub(crate) fn db_del(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::db::db_del",
-            "[WASM] [{}] db_del(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] db_del(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::DB_DEL_FAILED
     };
@@ -510,7 +510,7 @@ pub(crate) fn db_del(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
         Err(e) => {
             error!(
                 target: "runtime::db::db_del",
-                "[WASM] [{}] db_del(): Failed to decode DbHandle: {}", cid, e,
+                "[WASM] [{cid}] db_del(): Failed to decode DbHandle: {e}"
             );
             return darkfi_sdk::error::DB_DEL_FAILED
         }
@@ -523,7 +523,7 @@ pub(crate) fn db_del(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
         Err(e) => {
             error!(
                 target: "runtime::db::db_del",
-                "[WASM] [{}] db_del(): Failed to decode key vec: {}", cid, e,
+                "[WASM] [{cid}] db_del(): Failed to decode key vec: {e}"
             );
             return darkfi_sdk::error::DB_DEL_FAILED
         }
@@ -533,7 +533,7 @@ pub(crate) fn db_del(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if buf_reader.position() != ptr_len as u64 {
         error!(
             target: "runtime::db::db_del",
-            "[WASM] [{}] db_del(): Trailing bytes in argument stream", cid,
+            "[WASM] [{cid}] db_del(): Trailing bytes in argument stream"
         );
         return darkfi_sdk::error::DB_DEL_FAILED
     }
@@ -543,7 +543,7 @@ pub(crate) fn db_del(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if db_handles.len() <= db_handle_index {
         error!(
             target: "runtime::db::db_del",
-            "[WASM] [{}] db_del(): Requested DbHandle that is out of bounds", cid,
+            "[WASM] [{cid}] db_del(): Requested DbHandle that is out of bounds"
         );
         return darkfi_sdk::error::DB_DEL_FAILED
     }
@@ -555,7 +555,7 @@ pub(crate) fn db_del(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if db_handle.contract_id != cid {
         error!(
             target: "runtime::db::db_del",
-            "[WASM] [{}] db_del(): Unauthorized to write to DbHandle", cid,
+            "[WASM] [{cid}] db_del(): Unauthorized to write to DbHandle"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -565,7 +565,7 @@ pub(crate) fn db_del(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     {
         error!(
             target: "runtime::db::db_del",
-            "[WASM] [{}] db_del(): Couldn't remove key from db_handle tree", cid,
+            "[WASM] [{cid}] db_del(): Couldn't remove key from db_handle tree"
         );
         return darkfi_sdk::error::DB_DEL_FAILED
     }
@@ -590,7 +590,7 @@ pub(crate) fn db_get(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     {
         error!(
             target: "runtime::db::db_get",
-            "[WASM] [{}] db_get(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] db_get(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -603,7 +603,7 @@ pub(crate) fn db_get(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     let Ok(mem_slice) = ptr.slice(&memory_view, ptr_len) else {
         error!(
             target: "runtime::db::db_get",
-            "[WASM] [{}] db_get(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] db_get(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     };
@@ -612,7 +612,7 @@ pub(crate) fn db_get(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::db::db_get",
-            "[WASM] [{}] db_get(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] db_get(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     };
@@ -625,7 +625,7 @@ pub(crate) fn db_get(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
         Err(e) => {
             error!(
                 target: "runtime::db::db_get",
-                "[WASM] [{}] db_get(): Failed to decode DbHandle: {}", cid, e,
+                "[WASM] [{cid}] db_get(): Failed to decode DbHandle: {e}"
             );
             return darkfi_sdk::error::DB_GET_FAILED
         }
@@ -639,7 +639,7 @@ pub(crate) fn db_get(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
         Err(e) => {
             error!(
                 target: "runtime::db::db_get",
-                "[WASM] [{}] db_get(): Failed to decode key from vec: {}", cid, e,
+                "[WASM] [{cid}] db_get(): Failed to decode key from vec: {e}"
             );
             return darkfi_sdk::error::DB_GET_FAILED
         }
@@ -650,7 +650,7 @@ pub(crate) fn db_get(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if buf_reader.position() != ptr_len as u64 {
         error!(
             target: "runtime::db::db_get",
-            "[WASM] [{}] db_get(): Trailing bytes in argument stream", cid,
+            "[WASM] [{cid}] db_get(): Trailing bytes in argument stream"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     }
@@ -661,7 +661,7 @@ pub(crate) fn db_get(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     if db_handles.len() <= db_handle_index {
         error!(
             target: "runtime::db::db_get",
-            "[WASM] [{}] db_get(): Requested DbHandle that is out of bounds", cid,
+            "[WASM] [{cid}] db_get(): Requested DbHandle that is out of bounds"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     }
@@ -676,7 +676,7 @@ pub(crate) fn db_get(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
             Err(e) => {
                 error!(
                     target: "runtime::db::db_get",
-                    "[WASM] [{}] db_get(): Internal error getting from tree: {}", cid, e,
+                    "[WASM] [{cid}] db_get(): Internal error getting from tree: {e}"
                 );
                 return darkfi_sdk::error::DB_GET_FAILED
             }
@@ -687,7 +687,7 @@ pub(crate) fn db_get(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_len: u3
     let Some(return_data) = ret else {
         debug!(
             target: "runtime::db::db_get",
-            "[WASM] [{}] db_get(): Return data is empty", cid,
+            "[WASM] [{cid}] db_get(): Return data is empty"
         );
         return darkfi_sdk::error::DB_GET_EMPTY
     };
@@ -727,7 +727,7 @@ pub(crate) fn db_contains_key(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, pt
     {
         error!(
             target: "runtime::db::db_contains_key",
-            "[WASM] [{}] db_contains_key(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] db_contains_key(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -740,7 +740,7 @@ pub(crate) fn db_contains_key(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, pt
     let Ok(mem_slice) = ptr.slice(&memory_view, ptr_len) else {
         error!(
             target: "runtime::db::db_contains_key",
-            "[WASM] [{}] db_contains_key(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] db_contains_key(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::DB_CONTAINS_KEY_FAILED
     };
@@ -749,7 +749,7 @@ pub(crate) fn db_contains_key(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, pt
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::db::db_contains_key",
-            "[WASM] [{}] db_contains_key(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] db_contains_key(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::DB_CONTAINS_KEY_FAILED
     };
@@ -762,7 +762,7 @@ pub(crate) fn db_contains_key(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, pt
         Err(e) => {
             error!(
                 target: "runtime::db::db_contains_key",
-                "[WASM] [{}] db_contains_key(): Failed to decode DbHandle: {}", cid, e,
+                "[WASM] [{cid}] db_contains_key(): Failed to decode DbHandle: {e}"
             );
             return darkfi_sdk::error::DB_CONTAINS_KEY_FAILED
         }
@@ -776,7 +776,7 @@ pub(crate) fn db_contains_key(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, pt
         Err(e) => {
             error!(
                 target: "runtime::db::db_contains_key",
-                "[WASM] [{}] db_contains_key(): Failed to decode key vec: {}", cid, e,
+                "[WASM] [{cid}] db_contains_key(): Failed to decode key vec: {e}"
             );
             return darkfi_sdk::error::DB_CONTAINS_KEY_FAILED
         }
@@ -787,7 +787,7 @@ pub(crate) fn db_contains_key(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, pt
     if buf_reader.position() != ptr_len as u64 {
         error!(
             target: "runtime::db::db_contains_key",
-            "[WASM] [{}] db_contains_key(): Trailing bytes in argument stream", cid,
+            "[WASM] [{cid}] db_contains_key(): Trailing bytes in argument stream"
         );
         return darkfi_sdk::error::DB_CONTAINS_KEY_FAILED
     }
@@ -798,7 +798,7 @@ pub(crate) fn db_contains_key(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, pt
     if db_handles.len() <= db_handle_index {
         error!(
             target: "runtime::db::db_contains_key",
-            "[WASM] [{}] db_contains_key(): Requested DbHandle that is out of bounds", cid,
+            "[WASM] [{cid}] db_contains_key(): Requested DbHandle that is out of bounds"
         );
         return darkfi_sdk::error::DB_CONTAINS_KEY_FAILED
     }
@@ -813,7 +813,7 @@ pub(crate) fn db_contains_key(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, pt
         Err(e) => {
             error!(
                 target: "runtime::db::db_contains_key",
-                "[WASM] [{}] db_contains_key(): sled.tree.contains_key failed: {}", cid, e,
+                "[WASM] [{cid}] db_contains_key(): sled.tree.contains_key failed: {e}"
             );
             darkfi_sdk::error::DB_CONTAINS_KEY_FAILED
         }
@@ -833,7 +833,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
     if let Err(e) = acl_allow(env, &[ContractSection::Deploy]) {
         error!(
             target: "runtime::db::zkas_db_set",
-            "[WASM] [{}] zkas_db_set(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] zkas_db_set(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -844,7 +844,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
     let Ok(mem_slice) = ptr.slice(&memory_view, ptr_len) else {
         error!(
             target: "runtime::db::zkas_db_set",
-            "[WASM] [{}] zkas_db_set(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] zkas_db_set(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     };
@@ -853,7 +853,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::db::zkas_db_set",
-            "[WASM] [{}] zkas_db_set(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] zkas_db_set(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     };
@@ -864,7 +864,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
         Err(e) => {
             error!(
                 target: "runtime::db::zkas_db_set",
-                "[WASM] [{}] zkas_db_set(): Could not deserialize bytes from buffer: {}", cid, e,
+                "[WASM] [{cid}] zkas_db_set(): Could not deserialize bytes from buffer: {e}"
             );
             return darkfi_sdk::error::DB_SET_FAILED
         }
@@ -876,7 +876,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
         Err(e) => {
             error!(
                 target: "runtime::db::zkas_db_set",
-                "[WASM] [{}] zkas_db_set(): Invalid zkas bincode passed to function: {}", cid, e,
+                "[WASM] [{cid}] zkas_db_set(): Invalid zkas bincode passed to function: {e}"
             );
             return darkfi_sdk::error::DB_SET_FAILED
         }
@@ -896,7 +896,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
     if db_handle.contract_id != cid {
         error!(
             target: "runtime::db::zkas_db_set",
-            "[WASM] [{}] zkas_db_set(): Internal error, zkas db at index 0 incorrect", cid,
+            "[WASM] [{cid}] zkas_db_set(): Internal error, zkas db at index 0 incorrect"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     }
@@ -922,8 +922,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
                 if existing_zkbin == zkbin_bytes {
                     debug!(
                         target: "runtime::db::zkas_db_set",
-                        "[WASM] [{}] zkas_db_set(): Existing zkas bincode is the same. Skipping.",
-                        cid,
+                        "[WASM] [{cid}] zkas_db_set(): Existing zkas bincode is the same. Skipping."
                     );
                     return wasm::entrypoint::SUCCESS
                 }
@@ -932,7 +931,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
         Err(e) => {
             error!(
                 target: "runtime::db::zkas_db_set",
-                "[WASM] [{}] zkas_db_set(): Internal error getting from tree: {}", cid, e,
+                "[WASM] [{cid}] zkas_db_set(): Internal error getting from tree: {e}"
             );
             return darkfi_sdk::error::DB_SET_FAILED
         }
@@ -941,8 +940,8 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
     // We didn't find any existing bincode, so let's create a new VerifyingKey and write it all.
     info!(
         target: "runtime::db::zkas_db_set",
-        "[WASM] [{}] zkas_db_set(): Creating VerifyingKey for {} zkas circuit",
-        cid, zkbin.namespace,
+        "[WASM] [{cid}] zkas_db_set(): Creating VerifyingKey for {} zkas circuit",
+        zkbin.namespace,
     );
 
     let witnesses = match empty_witnesses(&zkbin) {
@@ -950,7 +949,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
         Err(e) => {
             error!(
                 target: "runtime::db::zkas_db_set",
-                "[WASM] [{}] zkas_db_set(): Failed to create empty witnesses: {}", cid, e,
+                "[WASM] [{cid}] zkas_db_set(): Failed to create empty witnesses: {e}"
             );
             return darkfi_sdk::error::DB_SET_FAILED
         }
@@ -963,7 +962,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
     if let Err(e) = vk.write(&mut vk_buf) {
         error!(
             target: "runtime::db::zkas_db_set",
-            "[WASM] [{}] zkas_db_set(): Failed to serialize VerifyingKey: {}", cid, e,
+            "[WASM] [{cid}] zkas_db_set(): Failed to serialize VerifyingKey: {e}"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     }
@@ -983,7 +982,7 @@ pub(crate) fn zkas_db_set(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, ptr_le
     {
         error!(
             target: "runtime::db::zkas_db_set",
-            "[WASM] [{}] zkas_db_set(): Couldn't insert to db_handle tree", cid,
+            "[WASM] [{cid}] zkas_db_set(): Couldn't insert to db_handle tree"
         );
         return darkfi_sdk::error::DB_SET_FAILED
     }

src/runtime/import/merkle.rs

@@ -45,7 +45,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     if let Err(e) = acl_allow(env, &[ContractSection::Update]) {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] merkle_add(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -61,7 +61,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     let Ok(mem_slice) = ptr.slice(&memory_view, len) else {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] merkle_add(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
@@ -70,7 +70,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] merkle_add(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
@@ -88,7 +88,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
         Err(e) => {
             error!(
                 target: "runtime::merkle::merkle_add",
-                "[WASM] [{}] merkle_add(): Failed to decode db_info DbHandle: {}", cid, e,
+                "[WASM] [{cid}] merkle_add(): Failed to decode db_info DbHandle: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -100,7 +100,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
         Err(e) => {
             error!(
                 target: "runtime::merkle::merkle_add",
-                "[WASM] [{}] merkle_add(): Failed to decode db_roots DbHandle: {}", cid, e,
+                "[WASM] [{cid}] merkle_add(): Failed to decode db_roots DbHandle: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -113,7 +113,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     if n_dbs <= db_info_index || n_dbs <= db_roots_index {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Requested DbHandle that is out of bounds", cid,
+            "[WASM] [{cid}] merkle_add(): Requested DbHandle that is out of bounds"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -124,7 +124,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     if db_info.contract_id != env.contract_id || db_roots.contract_id != env.contract_id {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Unauthorized to write to DbHandle", cid,
+            "[WASM] [{cid}] merkle_add(): Unauthorized to write to DbHandle"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -135,7 +135,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
         Err(e) => {
             error!(
                 target: "runtime::merkle::merkle_add",
-                "[WASM] [{}] merkle_add(): Failed to decode key vec: {}", cid, e,
+                "[WASM] [{cid}] merkle_add(): Failed to decode key vec: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -147,7 +147,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
         Err(e) => {
             error!(
                 target: "runtime::merkle::merkle_add",
-                "[WASM] [{}] merkle_add(): Failed to decode key vec: {}", cid, e,
+                "[WASM] [{cid}] merkle_add(): Failed to decode key vec: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -159,7 +159,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
         Err(e) => {
             error!(
                 target: "runtime::merkle::merkle_add",
-                "[WASM] [{}] merkle_add(): Failed to decode MerkleNode: {}", cid, e,
+                "[WASM] [{cid}] merkle_add(): Failed to decode MerkleNode: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -169,7 +169,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     if buf_reader.position() != (len as u64) {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Mismatch between given length, and cursor length", cid,
+            "[WASM] [{cid}] merkle_add(): Mismatch between given length, and cursor length"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -183,7 +183,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
         Err(e) => {
             error!(
                 target: "runtime::merkle::merkle_add",
-                "[WASM] [{}] merkle_add(): Internal error getting from tree: {}", cid, e,
+                "[WASM] [{cid}] merkle_add(): Internal error getting from tree: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -192,7 +192,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     let Some(return_data) = ret else {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Return data is empty", cid,
+            "[WASM] [{cid}] merkle_add(): Return data is empty"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
@@ -214,7 +214,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
         Err(e) => {
             error!(
                 target: "runtime::merkle::merkle_add",
-                "[WASM] [{}] merkle_add(): Unable to read set size: {}", cid, e,
+                "[WASM] [{cid}] merkle_add(): Unable to read set size: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -225,7 +225,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
         Err(e) => {
             error!(
                 target: "runtime::merkle::merkle_add",
-                "[WASM] [{}] merkle_add(): Unable to deserialize Merkle tree: {}", cid, e,
+                "[WASM] [{cid}] merkle_add(): Unable to deserialize Merkle tree: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -244,7 +244,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Couldn't reserialize modified tree", cid,
+            "[WASM] [{cid}] merkle_add(): Couldn't reserialize modified tree"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -253,7 +253,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     if overlay.insert(&db_info.tree, &tree_key, &tree_data).is_err() {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Couldn't insert to db_info tree", cid,
+            "[WASM] [{cid}] merkle_add(): Couldn't insert to db_info tree"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -263,14 +263,14 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     let Some(latest_root) = tree.root(0) else {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Unable to read the root of tree", cid,
+            "[WASM] [{cid}] merkle_add(): Unable to read the root of tree"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
 
     debug!(
         target: "runtime::merkle::merkle_add",
-        "[WASM] [{}] merkle_add(): Appending Merkle root to db: {:?}", cid, latest_root,
+        "[WASM] [{cid}] merkle_add(): Appending Merkle root to db: {latest_root:?}"
     );
     let latest_root_data = serialize(&latest_root);
     assert_eq!(latest_root_data.len(), 32);
@@ -283,7 +283,7 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     if overlay.insert(&db_roots.tree, &latest_root_data, &value_data).is_err() {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Couldn't insert to db_roots tree", cid,
+            "[WASM] [{cid}] merkle_add(): Couldn't insert to db_roots tree"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -291,13 +291,13 @@ pub(crate) fn merkle_add(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u3
     // Write a pointer to the latest known root
     debug!(
         target: "runtime::merkle::merkle_add",
-        "[WASM] [{}] merkle_add(): Replacing latest Merkle root pointer", cid,
+        "[WASM] [{cid}] merkle_add(): Replacing latest Merkle root pointer"
     );
 
     if overlay.insert(&db_info.tree, &root_key, &latest_root_data).is_err() {
         error!(
             target: "runtime::merkle::merkle_add",
-            "[WASM] [{}] merkle_add(): Couldn't insert latest root to db_info tree", cid,
+            "[WASM] [{cid}] merkle_add(): Couldn't insert latest root to db_info tree"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }

src/runtime/import/smt.rs

@@ -48,8 +48,8 @@ impl StorageAdapter for SledStorage<'_> {
         if let Err(e) = self.overlay.insert(self.tree_key, &key.to_bytes_le(), &value.to_repr()) {
             error!(
                 target: "runtime::smt::SledStorage::put",
-                "[WASM] SledStorage::put(): inserting key {:?}, value {:?} into DB tree: {:?}: {}",
-                key, value, self.tree_key, e,
+                "[WASM] SledStorage::put(): inserting key {key:?}, value {value:?} into DB tree: {:?}: {e}",
+                self.tree_key
             );
             return Err(ContractError::SmtPutFailed)
         }
@@ -63,8 +63,8 @@ impl StorageAdapter for SledStorage<'_> {
             Err(e) => {
                 error!(
                     target: "runtime::smt::SledStorage::get",
-                    "[WASM] SledStorage::get(): Fetching key {:?} from DB tree: {:?}: {}",
-                    key, self.tree_key, e,
+                    "[WASM] SledStorage::get(): Fetching key {key:?} from DB tree: {:?}: {e}",
+                    self.tree_key
                 );
                 return None
             }
@@ -81,8 +81,8 @@ impl StorageAdapter for SledStorage<'_> {
         if let Err(e) = self.overlay.remove(self.tree_key, &key.to_bytes_le()) {
             error!(
                 target: "runtime::smt::SledStorage::del",
-                "[WASM] SledStorage::del(): Removing key {:?} from DB tree: {:?}: {}",
-                key, self.tree_key, e,
+                "[WASM] SledStorage::del(): Removing key {key:?} from DB tree: {:?}: {e}",
+                self.tree_key
             );
             return Err(ContractError::SmtDelFailed)
         }
@@ -110,7 +110,7 @@ pub(crate) fn sparse_merkle_insert_batch(
     if let Err(e) = acl_allow(env, &[ContractSection::Update]) {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -123,7 +123,7 @@ pub(crate) fn sparse_merkle_insert_batch(
     let Ok(mem_slice) = ptr.slice(&memory_view, len) else {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
@@ -132,7 +132,7 @@ pub(crate) fn sparse_merkle_insert_batch(
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
@@ -147,7 +147,7 @@ pub(crate) fn sparse_merkle_insert_batch(
         Err(e) => {
             error!(
                 target: "runtime::smt::sparse_merkle_insert_batch",
-                "[WASM] [{}] sparse_merkle_insert_batch(): Failed to decode db_info DbHandle: {}", cid, e,
+                "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to decode db_info DbHandle: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -159,7 +159,7 @@ pub(crate) fn sparse_merkle_insert_batch(
         Err(e) => {
             error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-                "[WASM] [{}] sparse_merkle_insert_batch(): Failed to decode db_smt DbHandle: {}", cid, e,
+                "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to decode db_smt DbHandle: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -171,7 +171,7 @@ pub(crate) fn sparse_merkle_insert_batch(
         Err(e) => {
             error!(
                 target: "runtime::smt::sparse_merkle_insert_batch",
-                "[WASM] [{}] sparse_merkle_insert_batch(): Failed to decode db_roots DbHandle: {}", cid, e,
+                "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to decode db_roots DbHandle: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -184,7 +184,7 @@ pub(crate) fn sparse_merkle_insert_batch(
     if n_dbs <= db_info_index || n_dbs <= db_smt_index || n_dbs <= db_roots_index {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Requested DbHandle that is out of bounds", cid,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Requested DbHandle that is out of bounds"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -199,7 +199,7 @@ pub(crate) fn sparse_merkle_insert_batch(
     {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Unauthorized to write to DbHandle", cid,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Unauthorized to write to DbHandle"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -210,7 +210,7 @@ pub(crate) fn sparse_merkle_insert_batch(
         Err(e) => {
             error!(
                 target: "runtime::smt::sparse_merkle_insert_batch",
-                "[WASM] [{}] sparse_merkle_insert_batch(): Failed to decode key vec: {}", cid, e,
+                "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to decode key vec: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -222,7 +222,7 @@ pub(crate) fn sparse_merkle_insert_batch(
         Err(e) => {
             error!(
                 target: "runtime::smt::sparse_merkle_insert_batch",
-                "[WASM] [{}] sparse_merkle_insert_batch(): Failed to decode pallas::Base: {}", cid, e,
+                "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to decode pallas::Base: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -232,7 +232,7 @@ pub(crate) fn sparse_merkle_insert_batch(
     if buf_reader.position() != (len as u64) {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Mismatch between given length, and cursor length", cid,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Mismatch between given length, and cursor length"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -258,7 +258,7 @@ pub(crate) fn sparse_merkle_insert_batch(
     if let Err(e) = smt.insert_batch(leaves) {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): SMT failed to insert batch: {}", cid, e,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): SMT failed to insert batch: {e}"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
@@ -272,7 +272,7 @@ pub(crate) fn sparse_merkle_insert_batch(
     if latest_root_data.len() != 32 {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Latest root data length missmatch: {}", cid, latest_root_data.len(),
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Latest root data length missmatch: {}", latest_root_data.len(),
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -282,21 +282,21 @@ pub(crate) fn sparse_merkle_insert_batch(
     if let Err(e) = env.tx_hash.inner().encode(&mut new_value_data) {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Failed to serialize transaction hash: {}", cid, e,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to serialize transaction hash: {e}"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
     if let Err(e) = env.call_idx.encode(&mut new_value_data) {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Failed to serialize call index: {}", cid, e,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to serialize call index: {e}"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
     if new_value_data.len() != 32 + 1 {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): New value data length missmatch: {}", cid, new_value_data.len(),
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): New value data length missmatch: {}", new_value_data.len(),
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -307,7 +307,7 @@ pub(crate) fn sparse_merkle_insert_batch(
         Err(e) => {
             error!(
                 target: "runtime::smt::sparse_merkle_insert_batch",
-                "[WASM] [{}] sparse_merkle_insert_batch(): SMT failed to retrieve current root snapshot: {}", cid, e,
+                "[WASM] [{cid}] sparse_merkle_insert_batch(): SMT failed to retrieve current root snapshot: {e}"
             );
             return darkfi_sdk::error::INTERNAL_ERROR
         }
@@ -322,7 +322,7 @@ pub(crate) fn sparse_merkle_insert_batch(
                 Err(e) => {
                     error!(
                         target: "runtime::smt::sparse_merkle_insert_batch",
-                        "[WASM] [{}] sparse_merkle_insert_batch(): Failed to deserialize current root snapshot: {}", cid, e,
+                        "[WASM] [{cid}] sparse_merkle_insert_batch(): Failed to deserialize current root snapshot: {e}"
                     );
                     return darkfi_sdk::error::INTERNAL_ERROR
                 }
@@ -340,13 +340,13 @@ pub(crate) fn sparse_merkle_insert_batch(
     // Write the latest root snapshot
     debug!(
         target: "runtime::smt::sparse_merkle_insert_batch",
-        "[WASM] [{}] sparse_merkle_insert_batch(): Appending SMT root to db: {:?}", cid, latest_root,
+        "[WASM] [{cid}] sparse_merkle_insert_batch(): Appending SMT root to db: {latest_root:?}"
     );
     if overlay.insert(&db_roots.tree, &latest_root_data, &serialize(&root_value_data_set)).is_err()
     {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Couldn't insert to db_roots tree", cid,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Couldn't insert to db_roots tree"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }
@@ -354,12 +354,12 @@ pub(crate) fn sparse_merkle_insert_batch(
     // Update the pointer to the latest known root
     debug!(
         target: "runtime::smt::sparse_merkle_insert_batch",
-        "[WASM] [{}] sparse_merkle_insert_batch(): Replacing latest SMT root pointer", cid,
+        "[WASM] [{cid}] sparse_merkle_insert_batch(): Replacing latest SMT root pointer"
     );
     if overlay.insert(&db_info.tree, &root_key, &latest_root_data).is_err() {
         error!(
             target: "runtime::smt::sparse_merkle_insert_batch",
-            "[WASM] [{}] sparse_merkle_insert_batch(): Couldn't insert latest root to db_info tree", cid,
+            "[WASM] [{cid}] sparse_merkle_insert_batch(): Couldn't insert latest root to db_info tree"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     }

src/runtime/import/util.rs

@@ -65,7 +65,7 @@ pub(crate) fn set_return_data(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, le
     if let Err(e) = acl_allow(env, &[ContractSection::Metadata, ContractSection::Exec]) {
         error!(
             target: "runtime::util::set_return_data",
-            "[WASM] [{}] set_return_data(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] set_return_data(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -103,7 +103,7 @@ pub(crate) fn get_object_bytes(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, i
     {
         error!(
             target: "runtime::util::get_object_bytes()",
-            "[WASM] [{}] get_object_bytes(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_object_bytes(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -113,7 +113,7 @@ pub(crate) fn get_object_bytes(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, i
     if idx as usize >= objects.len() {
         error!(
             target: "runtime::util::get_object_bytes",
-            "[WASM] [{}] get_object_bytes(): Tried to access object out of bounds", cid,
+            "[WASM] [{cid}] get_object_bytes(): Tried to access object out of bounds"
         );
         return darkfi_sdk::error::DATA_TOO_LARGE
     }
@@ -132,7 +132,7 @@ pub(crate) fn get_object_bytes(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, i
     let Ok(slice) = ptr.slice(&memory_view, obj.len() as u32) else {
         error!(
             target: "runtime::util::get_object_bytes",
-            "[WASM] [{}] get_object_bytes(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] get_object_bytes(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
@@ -141,7 +141,7 @@ pub(crate) fn get_object_bytes(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, i
     if let Err(e) = slice.write_slice(&obj) {
         error!(
             target: "runtime::util::get_object_bytes",
-            "[WASM] [{}] get_object_bytes(): Failed to write to memory slice: {}", cid, e,
+            "[WASM] [{cid}] get_object_bytes(): Failed to write to memory slice: {e}"
         );
         return darkfi_sdk::error::INTERNAL_ERROR
     };
@@ -164,7 +164,7 @@ pub(crate) fn get_object_size(mut ctx: FunctionEnvMut<Env>, idx: u32) -> i64 {
     {
         error!(
             target: "runtime::util::get_object_size()",
-            "[WASM] [{}] get_object_size(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_object_size(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -174,7 +174,7 @@ pub(crate) fn get_object_size(mut ctx: FunctionEnvMut<Env>, idx: u32) -> i64 {
     if idx as usize >= objects.len() {
         error!(
             target: "runtime::util::get_object_size",
-            "[WASM] [{}] get_object_size(): Tried to access object out of bounds", cid,
+            "[WASM] [{cid}] get_object_size(): Tried to access object out of bounds"
         );
         return darkfi_sdk::error::DATA_TOO_LARGE
     }
@@ -206,7 +206,7 @@ pub(crate) fn get_verifying_block_height(mut ctx: FunctionEnvMut<Env>) -> i64 {
     {
         error!(
             target: "runtime::util::get_verifying_block_height",
-            "[WASM] [{}] get_verifying_block_height(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_verifying_block_height(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -230,7 +230,7 @@ pub(crate) fn get_block_target(mut ctx: FunctionEnvMut<Env>) -> i64 {
     {
         error!(
             target: "runtime::util::get_block_target",
-            "[WASM] [{}] get_block_target(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_block_target(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -254,7 +254,7 @@ pub(crate) fn get_tx_hash(mut ctx: FunctionEnvMut<Env>) -> i64 {
     {
         error!(
             target: "runtime::util::get_tx_hash",
-            "[WASM] [{}] get_tx_hash(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_tx_hash(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -281,7 +281,7 @@ pub(crate) fn get_call_index(mut ctx: FunctionEnvMut<Env>) -> i64 {
     {
         error!(
             target: "runtime::util::get_call_index",
-            "[WASM] [{}] get_call_index(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_call_index(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -306,7 +306,7 @@ pub(crate) fn get_blockchain_time(mut ctx: FunctionEnvMut<Env>) -> i64 {
     {
         error!(
             target: "runtime::util::get_blockchain_time",
-            "[WASM] [{}] get_blockchain_time(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_blockchain_time(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -317,7 +317,7 @@ pub(crate) fn get_blockchain_time(mut ctx: FunctionEnvMut<Env>) -> i64 {
         Err(e) => {
             error!(
                 target: "runtime::util::get_blockchain_time",
-                "[WASM] [{}] get_blockchain_time(): Internal error getting from blocks tree: {}", cid, e,
+                "[WASM] [{cid}] get_blockchain_time(): Internal error getting from blocks tree: {e}"
             );
             return darkfi_sdk::error::DB_GET_FAILED
         }
@@ -358,7 +358,7 @@ pub(crate) fn get_last_block_height(mut ctx: FunctionEnvMut<Env>) -> i64 {
     {
         error!(
             target: "runtime::util::get_last_block_height",
-            "[WASM] [{}] get_last_block_height(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_last_block_height(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -369,7 +369,7 @@ pub(crate) fn get_last_block_height(mut ctx: FunctionEnvMut<Env>) -> i64 {
         Err(e) => {
             error!(
                 target: "runtime::util::get_last_block_height",
-                "[WASM] [{}] get_last_block_height(): Internal error getting from blocks tree: {}", cid, e,
+                "[WASM] [{cid}] get_last_block_height(): Internal error getting from blocks tree: {e}"
             );
             return darkfi_sdk::error::DB_GET_FAILED
         }
@@ -410,7 +410,7 @@ pub(crate) fn get_tx(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) -> i64 {
     {
         error!(
             target: "runtime::util::get_tx",
-            "[WASM] [{}] get_tx(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_tx(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -423,7 +423,7 @@ pub(crate) fn get_tx(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) -> i64 {
     let Ok(mem_slice) = ptr.slice(&memory_view, blake3::OUT_LEN as u32) else {
         error!(
             target: "runtime::util::get_tx",
-            "[WASM] [{}] get_tx(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] get_tx(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     };
@@ -432,7 +432,7 @@ pub(crate) fn get_tx(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) -> i64 {
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::util::get_tx",
-            "[WASM] [{}] get_tx(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] get_tx(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     };
@@ -445,7 +445,7 @@ pub(crate) fn get_tx(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) -> i64 {
         Err(e) => {
             error!(
                 target: "runtime::util::get_tx",
-                "[WASM] [{}] get_tx(): Failed to decode hash from vec: {}", cid, e,
+                "[WASM] [{cid}] get_tx(): Failed to decode hash from vec: {e}"
             );
             return darkfi_sdk::error::DB_GET_FAILED
         }
@@ -456,7 +456,7 @@ pub(crate) fn get_tx(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) -> i64 {
     if buf_reader.position() != blake3::OUT_LEN as u64 {
         error!(
             target: "runtime::util::get_tx",
-            "[WASM] [{}] get_tx(): Trailing bytes in argument stream", cid,
+            "[WASM] [{cid}] get_tx(): Trailing bytes in argument stream"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     }
@@ -467,7 +467,7 @@ pub(crate) fn get_tx(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) -> i64 {
         Err(e) => {
             error!(
                 target: "runtime::util::get_tx",
-                "[WASM] [{}] get_tx(): Internal error getting from tree: {}", cid, e,
+                "[WASM] [{cid}] get_tx(): Internal error getting from tree: {e}"
             );
             return darkfi_sdk::error::DB_GET_FAILED
         }
@@ -477,7 +477,7 @@ pub(crate) fn get_tx(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) -> i64 {
     let Some(return_data) = ret else {
         debug!(
             target: "runtime::util::get_tx",
-            "[WASM] [{}] get_tx(): Return data is empty", cid,
+            "[WASM] [{cid}] get_tx(): Return data is empty"
         );
         return darkfi_sdk::error::DB_GET_EMPTY
     };
@@ -518,7 +518,7 @@ pub(crate) fn get_tx_location(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) ->
     {
         error!(
             target: "runtime::util::get_tx_location",
-            "[WASM] [{}] get_tx_location(): Called in unauthorized section: {}", cid, e,
+            "[WASM] [{cid}] get_tx_location(): Called in unauthorized section: {e}"
         );
         return darkfi_sdk::error::CALLER_ACCESS_DENIED
     }
@@ -531,7 +531,7 @@ pub(crate) fn get_tx_location(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) ->
     let Ok(mem_slice) = ptr.slice(&memory_view, blake3::OUT_LEN as u32) else {
         error!(
             target: "runtime::util::get_tx_location",
-            "[WASM] [{}] get_tx_location(): Failed to make slice from ptr", cid,
+            "[WASM] [{cid}] get_tx_location(): Failed to make slice from ptr"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     };
@@ -540,7 +540,7 @@ pub(crate) fn get_tx_location(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) ->
     if let Err(e) = mem_slice.read_slice(&mut buf) {
         error!(
             target: "runtime::util::get_tx_location",
-            "[WASM] [{}] get_tx_location(): Failed to read from memory slice: {}", cid, e,
+            "[WASM] [{cid}] get_tx_location(): Failed to read from memory slice: {e}"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     };
@@ -553,7 +553,7 @@ pub(crate) fn get_tx_location(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) ->
         Err(e) => {
             error!(
                 target: "runtime::util::get_tx_location",
-                "[WASM] [{}] get_tx_location(): Failed to decode hash from vec: {}", cid, e,
+                "[WASM] [{cid}] get_tx_location(): Failed to decode hash from vec: {e}"
             );
             return darkfi_sdk::error::DB_GET_FAILED
         }
@@ -564,7 +564,7 @@ pub(crate) fn get_tx_location(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) ->
     if buf_reader.position() != blake3::OUT_LEN as u64 {
         error!(
             target: "runtime::util::get_tx_location",
-            "[WASM] [{}] get_tx_location(): Trailing bytes in argument stream", cid,
+            "[WASM] [{cid}] get_tx_location(): Trailing bytes in argument stream"
         );
         return darkfi_sdk::error::DB_GET_FAILED
     }
@@ -575,7 +575,7 @@ pub(crate) fn get_tx_location(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) ->
         Err(e) => {
             error!(
                 target: "runtime::util::get_tx_location",
-                "[WASM] [{}] get_tx_location(): Internal error getting from tree: {}", cid, e,
+                "[WASM] [{cid}] get_tx_location(): Internal error getting from tree: {e}"
             );
             return darkfi_sdk::error::DB_GET_FAILED
         }
@@ -585,7 +585,7 @@ pub(crate) fn get_tx_location(mut ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>) ->
     let Some(return_data) = ret else {
         debug!(
             target: "runtime::util::get_tx_location",
-            "[WASM] [{}] get_tx_location(): Return data is empty", cid,
+            "[WASM] [{cid}] get_tx_location(): Return data is empty"
         );
         return darkfi_sdk::error::DB_GET_EMPTY
     };

src/runtime/vm_runtime.rs

@@ -391,7 +391,7 @@ impl Runtime {
                 self.print_logs();
                 info!(target: "runtime::vm_runtime", "[WASM] {}", self.gas_info());
                 // WasmerRuntimeError panics are handled here. Return from run() immediately.
-                error!(target: "runtime::vm_runtime", "[WASM] Wasmer Runtime Error: {:#?}", e);
+                error!(target: "runtime::vm_runtime", "[WASM] Wasmer Runtime Error: {e:#?}");
                 return Err(e.into())
             }
         };
@@ -420,7 +420,7 @@ impl Runtime {
                     }
                     // The only supported return type is i64, so panic if another
                     // value is returned.
-                    _ => unreachable!("Got unexpected result return value: {:?}", ret),
+                    _ => unreachable!("Got unexpected result return value: {ret:?}"),
                 }
             }
         };
@@ -432,7 +432,7 @@ impl Runtime {
             wasm::entrypoint::SUCCESS => Ok(retdata),
             _ => {
                 let err = darkfi_sdk::error::ContractError::from(retval);
-                error!(target: "runtime::vm_runtime", "[WASM] Contract returned: {:?}", err);
+                error!(target: "runtime::vm_runtime", "[WASM] Contract returned: {err:?}");
                 Err(Error::ContractError(err))
             }
         }
@@ -450,7 +450,7 @@ impl Runtime {
     /// assume that the contract is only able to do write operations on its own overlay trees.
     pub fn deploy(&mut self, payload: &[u8]) -> Result<()> {
         let cid = self.ctx.as_ref(&self.store).contract_id;
-        info!(target: "runtime::vm_runtime", "[WASM] Running deploy() for ContractID: {}", cid);
+        info!(target: "runtime::vm_runtime", "[WASM] Running deploy() for ContractID: {cid}");
 
         // Scoped for borrows
         {
@@ -470,7 +470,7 @@ impl Runtime {
             db_handles.push(DbHandle::new(env_mut.contract_id, zkas_tree_handle));
         }
 
-        //debug!(target: "runtime::vm_runtime", "[WASM] payload: {:?}", payload);
+        //debug!(target: "runtime::vm_runtime", "[WASM] payload: {payload:?}");
         let _ = self.call(ContractSection::Deploy, payload)?;
 
         // Update the wasm bincode in the ContractStore wasm tree if the deploy exec passed successfully.
@@ -482,7 +482,7 @@ impl Runtime {
             .contracts
             .insert(env_mut.contract_id, &env_mut.contract_bincode)?;
 
-        info!(target: "runtime::vm_runtime", "[WASM] Successfully deployed ContractID: {}", cid);
+        info!(target: "runtime::vm_runtime", "[WASM] Successfully deployed ContractID: {cid}");
         Ok(())
     }
 
@@ -494,13 +494,13 @@ impl Runtime {
     /// call/transaction signatures.
     pub fn metadata(&mut self, payload: &[u8]) -> Result<Vec<u8>> {
         let cid = self.ctx.as_ref(&self.store).contract_id;
-        info!(target: "runtime::vm_runtime", "[WASM] Running metadata() for ContractID: {}", cid);
+        info!(target: "runtime::vm_runtime", "[WASM] Running metadata() for ContractID: {cid}");
 
         debug!(target: "runtime::vm_runtime", "metadata payload: {}", payload.hex());
         let ret = self.call(ContractSection::Metadata, payload)?;
         debug!(target: "runtime::vm_runtime", "metadata returned: {:?}", ret.hex());
 
-        info!(target: "runtime::vm_runtime", "[WASM] Successfully got metadata ContractID: {}", cid);
+        info!(target: "runtime::vm_runtime", "[WASM] Successfully got metadata ContractID: {cid}");
         Ok(ret)
     }
 
@@ -511,13 +511,13 @@ impl Runtime {
     /// be used inside the vm by the runtime.
     pub fn exec(&mut self, payload: &[u8]) -> Result<Vec<u8>> {
         let cid = self.ctx.as_ref(&self.store).contract_id;
-        info!(target: "runtime::vm_runtime", "[WASM] Running exec() for ContractID: {}", cid);
+        info!(target: "runtime::vm_runtime", "[WASM] Running exec() for ContractID: {cid}");
 
         debug!(target: "runtime::vm_runtime", "exec payload: {}", payload.hex());
         let ret = self.call(ContractSection::Exec, payload)?;
         debug!(target: "runtime::vm_runtime", "exec returned: {:?}", ret.hex());
 
-        info!(target: "runtime::vm_runtime", "[WASM] Successfully executed ContractID: {}", cid);
+        info!(target: "runtime::vm_runtime", "[WASM] Successfully executed ContractID: {cid}");
         Ok(ret)
     }
 
@@ -529,13 +529,13 @@ impl Runtime {
     /// a state update from `env` and passes it into the wasm runtime.
     pub fn apply(&mut self, update: &[u8]) -> Result<()> {
         let cid = self.ctx.as_ref(&self.store).contract_id;
-        info!(target: "runtime::vm_runtime", "[WASM] Running apply() for ContractID: {}", cid);
+        info!(target: "runtime::vm_runtime", "[WASM] Running apply() for ContractID: {cid}");
 
         debug!(target: "runtime::vm_runtime", "apply payload: {:?}", update.hex());
         let ret = self.call(ContractSection::Update, update)?;
         debug!(target: "runtime::vm_runtime", "apply returned: {:?}", ret.hex());
 
-        info!(target: "runtime::vm_runtime", "[WASM] Successfully applied ContractID: {}", cid);
+        info!(target: "runtime::vm_runtime", "[WASM] Successfully applied ContractID: {cid}");
         Ok(())
     }
 
@@ -543,7 +543,7 @@ impl Runtime {
     fn print_logs(&self) {
         let logs = self.ctx.as_ref(&self.store).logs.borrow();
         for msg in logs.iter() {
-            info!(target: "runtime::vm_runtime", "[WASM] Contract log: {}", msg);
+            info!(target: "runtime::vm_runtime", "[WASM] Contract log: {msg}");
         }
     }
 
@@ -573,9 +573,9 @@ impl Runtime {
         let gas_used = self.gas_used();
 
         if gas_used > GAS_LIMIT {
-            format!("Gas fully exhausted: {}/{}", gas_used, GAS_LIMIT)
+            format!("Gas fully exhausted: {gas_used}/{GAS_LIMIT}")
         } else {
-            format!("Gas used: {}/{}", gas_used, GAS_LIMIT)
+            format!("Gas used: {gas_used}/{GAS_LIMIT}")
         }
     }
 

src/tx/mod.rs

@@ -90,27 +90,27 @@ impl Transaction {
             for (proof, (zk_ns, public_vals)) in proofs.iter().zip(pubvals.iter()) {
                 if let Some(vk) = contract_map.get(zk_ns) {
                     // We have a verifying key for this
-                    debug!(target: "tx::verify_zkps", "[TX] public inputs: {:#?}", public_vals);
+                    debug!(target: "tx::verify_zkps", "[TX] public inputs: {public_vals:#?}");
                     if let Err(e) = proof.verify(vk, public_vals) {
                         error!(
                             target: "tx::verify_zkps",
-                            "[TX] Failed verifying {}::{} ZK proof: {:#?}",
-                            call.data.contract_id, zk_ns, e
+                            "[TX] Failed verifying {}::{zk_ns} ZK proof: {e:#?}",
+                            call.data.contract_id
                         );
                         return Err(TxVerifyFailed::InvalidZkProof.into())
                     }
                     debug!(
                         target: "tx::verify_zkps",
-                        "[TX] Successfully verified {}::{} ZK proof",
-                        call.data.contract_id, zk_ns,
+                        "[TX] Successfully verified {}::{zk_ns} ZK proof",
+                        call.data.contract_id
                     );
                     continue
                 }
 
                 error!(
                     target: "tx::verify_zkps",
-                    "[TX] {}::{} circuit VK nonexistent",
-                    call.data.contract_id, zk_ns,
+                    "[TX] {}::{zk_ns} circuit VK nonexistent",
+                    call.data.contract_id
                 );
                 return Err(TxVerifyFailed::InvalidZkProof.into())
             }
@@ -202,7 +202,7 @@ impl std::fmt::Debug for Transaction {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "Transaction {{")?;
         for (i, call) in self.calls.iter().enumerate() {
-            writeln!(f, "  Call {} {{", i)?;
+            writeln!(f, "  Call {i} {{")?;
             writeln!(f, "    contract_id: {:?}", call.data.contract_id.inner())?;
             let calldata = &call.data.data;
             if !calldata.is_empty() {

src/zk/gadget/native_range_check.rs

@@ -131,11 +131,11 @@ impl<const WINDOW_SIZE: usize, const NUM_BITS: usize> NativeRangeCheckChip<WINDO
         k_values_table: TableColumn,
     ) -> Result<(), plonk::Error> {
         layouter.assign_table(
-            || format!("{} window table", WINDOW_SIZE),
+            || format!("{WINDOW_SIZE} window table"),
             |mut table| {
                 for index in 0..(1 << WINDOW_SIZE) {
                     table.assign_cell(
-                        || format!("{} window assign", WINDOW_SIZE),
+                        || format!("{WINDOW_SIZE} window assign"),
                         k_values_table,
                         index,
                         || Value::known(pallas::Base::from(index as u64)),
@@ -280,7 +280,7 @@ impl<const WINDOW_SIZE: usize, const NUM_BITS: usize> NativeRangeCheckChip<WINDO
         value: Value<pallas::Base>,
     ) -> Result<(), plonk::Error> {
         layouter.assign_region(
-            || format!("witness {}-bit native range check", NUM_BITS),
+            || format!("witness {NUM_BITS}-bit native range check"),
             |mut region: Region<'_, pallas::Base>| {
                 let z_0 = region.assign_advice(|| "z_0", self.config.z, 0, || value)?;
                 self.decompose(&mut region, z_0, 0)?;
@@ -295,7 +295,7 @@ impl<const WINDOW_SIZE: usize, const NUM_BITS: usize> NativeRangeCheckChip<WINDO
         value: AssignedCell<pallas::Base, pallas::Base>,
     ) -> Result<(), plonk::Error> {
         layouter.assign_region(
-            || format!("copy {}-bit native range check", NUM_BITS),
+            || format!("copy {NUM_BITS}-bit native range check"),
             |mut region: Region<'_, pallas::Base>| {
                 let z_0 = value.copy_advice(|| "z_0", &mut region, self.config.z, 0)?;
                 self.decompose(&mut region, z_0, 0)?;

src/zk/vm.rs

@@ -691,12 +691,12 @@ impl Circuit<pallas::Base> for ZkCircuit {
                 LitType::Uint64 => match literal.1.parse::<u64>() {
                     Ok(v) => litheap.push(v),
                     Err(e) => {
-                        error!(target: "zk::vm", "Failed converting u64 literal: {}", e);
+                        error!(target: "zk::vm", "Failed converting u64 literal: {e}");
                         return Err(plonk::Error::Synthesis)
                     }
                 },
                 _ => {
-                    error!(target: "zk::vm", "Invalid literal: {:?}", literal);
+                    error!(target: "zk::vm", "Invalid literal: {literal:?}");
                     return Err(plonk::Error::Synthesis)
                 }
             }
@@ -1115,7 +1115,7 @@ impl Circuit<pallas::Base> for ZkCircuit {
                             )?;
                         }
                         x => {
-                            error!(target: "zk::vm", "Unsupported bit-range {} for range_check", x);
+                            error!(target: "zk::vm", "Unsupported bit-range {x} for range_check");
                             return Err(plonk::Error::Synthesis)
                         }
                     }

src/zk/vm_heap.rs

@@ -86,7 +86,7 @@ pub fn empty_witnesses(zkbin: &ZkBinary) -> Result<Vec<Witness>> {
             VarType::SparseMerklePath => ret.push(Witness::SparseMerklePath(Value::unknown())),
             VarType::Uint32 => ret.push(Witness::Uint32(Value::unknown())),
             VarType::Uint64 => ret.push(Witness::Uint64(Value::unknown())),
-            x => return Err(ZkasDecoderError(format!("Unsupported witness type: {:?}", x))),
+            x => return Err(ZkasDecoderError(format!("Unsupported witness type: {x:?}"))),
         }
     }
 
@@ -119,7 +119,7 @@ macro_rules! impl_try_from {
                 match value {
                     HeapVar::$variant(v) => Ok(v),
                     x => {
-                        error!("Expected {}, but instead got: {:?}", stringify!($variant), x);
+                        error!("Expected {}, but instead got: {x:?}", stringify!($variant));
                         Err(plonk::Error::Synthesis)
                     }
                 }

src/zkas/analyzer.rs

@@ -60,7 +60,7 @@ impl Analyzer {
         let mut heap = vec![];
 
         for statement in &self.statements {
-            //println!("{:?}", statement);
+            //println!("{statement:?}");
             let mut stmt = statement.clone();
 
             let (return_types, arg_types) = statement.opcode.arg_types();
@@ -199,8 +199,8 @@ impl Analyzer {
                                 if var_type != f_arg_types[inner_idx] {
                                     return Err(self.error.abort(
                                         &format!(
-                                            "Incorrect argument type. Expected `{:?}`, got `{:?}`.",
-                                            f_arg_types[inner_idx], var_type
+                                            "Incorrect argument type. Expected `{:?}`, got `{var_type:?}`.",
+                                            f_arg_types[inner_idx]
                                         ),
                                         ln,
                                         col,
@@ -255,8 +255,8 @@ impl Analyzer {
                     heap.push(v.clone());
                     self.heap.clone_from(&heap);
 
-                    //println!("{:#?}", heap);
-                    //println!("{:#?}", statements);
+                    //println!("{heap:#?}");
+                    //println!("{statements:#?}");
                     continue
                 } // <-- Arg::Func
 
@@ -276,9 +276,8 @@ impl Analyzer {
                         if var_type != VarType::Base {
                             return Err(self.error.abort(
                                 &format!(
-                                    "Incorrect argument type. Expected `{:?}`, got `{:?}`.",
-                                    VarType::Base,
-                                    var_type
+                                    "Incorrect argument type. Expected `{:?}`, got `{var_type:?}`.",
+                                    VarType::Base
                                 ),
                                 v.line,
                                 v.column,
@@ -287,9 +286,8 @@ impl Analyzer {
                     } else if arg_types[0] == VarType::ScalarArray && var_type != VarType::Scalar {
                         return Err(self.error.abort(
                             &format!(
-                                "Incorrect argument type. Expected `{:?}`, got `{:?}`.",
-                                VarType::Scalar,
-                                var_type
+                                "Incorrect argument type. Expected `{:?}`, got `{var_type:?}`.",
+                                VarType::Scalar
                             ),
                             v.line,
                             v.column,
@@ -299,8 +297,8 @@ impl Analyzer {
                     if var_type != arg_types[idx] {
                         return Err(self.error.abort(
                             &format!(
-                                "Incorrect argument type. Expected `{:?}`, got `{:?}`.",
-                                arg_types[idx], var_type
+                                "Incorrect argument type. Expected `{:?}`, got `{var_type:?}`.",
+                                arg_types[idx]
                             ),
                             v.line,
                             v.column,
@@ -325,9 +323,8 @@ impl Analyzer {
                             if var_type != VarType::Base {
                                 return Err(self.error.abort(
                                     &format!(
-                                        "Incorrect argument type. Expected `{:?}`, got `{:?}`.",
-                                        VarType::Base,
-                                        var_type
+                                        "Incorrect argument type. Expected `{:?}`, got `{var_type:?}`.",
+                                        VarType::Base
                                     ),
                                     v.line,
                                     v.column,
@@ -337,9 +334,8 @@ impl Analyzer {
                             if var_type != VarType::Scalar {
                                 return Err(self.error.abort(
                                     &format!(
-                                        "Incorrect argument type. Expected `{:?}`, got `{:?}`.",
-                                        VarType::Scalar,
-                                        var_type
+                                        "Incorrect argument type. Expected `{:?}`, got `{var_type:?}`.",
+                                        VarType::Scalar
                                     ),
                                     v.line,
                                     v.column,
@@ -348,8 +344,8 @@ impl Analyzer {
                         } else if var_type != arg_types[idx] && arg_types[idx] != VarType::Any {
                             return Err(self.error.abort(
                                 &format!(
-                                    "Incorrect argument type. Expected `{:?}`, got `{:?}`.",
-                                    arg_types[idx], var_type
+                                    "Incorrect argument type. Expected `{:?}`, got `{var_type:?}`.",
+                                    arg_types[idx]
                                 ),
                                 v.line,
                                 v.column,
@@ -393,7 +389,7 @@ impl Analyzer {
                 self.heap.clone_from(&heap);
             }
 
-            //println!("{:#?}", stmt);
+            //println!("{stmt:#?}");
             statements.push(stmt);
         } // <-- for statement in &self.statements
 
@@ -465,14 +461,14 @@ impl Analyzer {
             heap.push(&i.name);
             Analyzer::pause();
         }
-        println!("Heap:\n{:#?}\n-----", heap);
+        println!("Heap:\n{heap:#?}\n-----");
         println!("Loading witnesses...\n-----");
         for i in &self.witnesses {
             println!("Adding `{}` to heap", i.name);
             heap.push(&i.name);
             Analyzer::pause();
         }
-        println!("Heap:\n{:#?}\n-----", heap);
+        println!("Heap:\n{heap:#?}\n-----");
         println!("Loading circuit...");
         for i in &self.statements {
             let mut argnames = vec![];
@@ -485,7 +481,7 @@ impl Analyzer {
                     unreachable!()
                 }
             }
-            println!("Executing: {:?}({:?})", i.opcode, argnames);
+            println!("Executing: {:?}({argnames:?})", i.opcode);
 
             Analyzer::pause();
 
@@ -493,7 +489,7 @@ impl Analyzer {
                 if let Arg::Var(arg) = arg {
                     print!("Looking up `{}` on the heap... ", arg.name);
                     if let Some(index) = heap.iter().position(|&r| r == &arg.name) {
-                        println!("Found at heap index {}", index);
+                        println!("Found at heap index {index}");
                     } else {
                         return Err(self.error.abort(
                             &format!("Could not find `{}` on the heap", arg.name),
@@ -504,7 +500,7 @@ impl Analyzer {
                 } else if let Arg::Lit(lit) = arg {
                     println!("Using literal `{}`", lit.name);
                 } else {
-                    println!("{:#?}", arg);
+                    println!("{arg:#?}");
                     unreachable!();
                 }
 
@@ -514,7 +510,7 @@ impl Analyzer {
                 StatementType::Assign => {
                     println!("Pushing result as `{}` to heap", &i.lhs.as_ref().unwrap().name);
                     heap.push(&i.lhs.as_ref().unwrap().name);
-                    println!("Heap:\n{:#?}\n-----", heap);
+                    println!("Heap:\n{heap:#?}\n-----");
                 }
                 StatementType::Call => {
                     println!("-----");

src/zkas/decoder.rs

@@ -247,7 +247,7 @@ impl ZkBinary {
                 let heap_type = match HeapType::from_repr(heap_type) {
                     Some(v) => v,
                     None => {
-                        return Err(ZkasErr(format!("Could not decode HeapType from {}", heap_type)))
+                        return Err(ZkasErr(format!("Could not decode HeapType from {heap_type}")))
                     }
                 };
                 args.push((heap_type, heap_index.0 as usize));

src/zkas/error.rs

@@ -33,14 +33,14 @@ impl ErrorEmitter {
         let (err_msg, dbg_msg, caret) = match ln {
             0 => (msg, "".to_string(), "".to_string()),
             _ => {
-                let err_msg = format!("{} (line {}, column {})", msg, ln, col);
-                let dbg_msg = format!("{}:{}:{}: {}", self.file, ln, col, self.lines[ln - 1]);
+                let err_msg = format!("{msg} (line {ln}, column {col})");
+                let dbg_msg = format!("{}:{ln}:{col}: {}", self.file, self.lines[ln - 1]);
                 let pad = dbg_msg.split(": ").next().unwrap().len() + col + 1;
                 let caret = format!("{:width$}^", "", width = pad);
                 (err_msg, dbg_msg, caret)
             }
         };
-        format!("{}\n{}\n{}\n", err_msg, dbg_msg, caret)
+        format!("{err_msg}\n{dbg_msg}\n{caret}\n")
     }
 
     pub fn abort(&self, msg: &str, ln: usize, col: usize) -> Error {
@@ -63,12 +63,10 @@ impl ErrorEmitter {
         let mut handle = stderr.lock();
 
         match typ {
-            "error" => {
-                write!(handle, "\x1b[31;1m{} error:\x1b[0m {}", self.namespace, msg).unwrap()
-            }
+            "error" => write!(handle, "\x1b[31;1m{} error:\x1b[0m {msg}", self.namespace).unwrap(),
 
             "warning" => {
-                write!(handle, "\x1b[33;1m{} warning:\x1b[0m {}", self.namespace, msg).unwrap()
+                write!(handle, "\x1b[33;1m{} warning:\x1b[0m {msg}", self.namespace).unwrap()
             }
 
             _ => unreachable!(),

src/zkas/lexer.rs

@@ -268,7 +268,7 @@ impl<'a> Lexer<'a> {
                     }
                     _ => {
                         return Err(self.error.abort(
-                            &format!("Invalid token `{}`", c),
+                            &format!("Invalid token `{c}`"),
                             lineno,
                             column - 1,
                         ))
@@ -276,7 +276,7 @@ impl<'a> Lexer<'a> {
                 }
             }
 
-            return Err(self.error.abort(&format!("Invalid token `{}`", c), lineno, column - 1))
+            return Err(self.error.abort(&format!("Invalid token `{c}`"), lineno, column - 1))
         }
 
         Ok(tokens)

src/zkas/parser.rs

@@ -162,7 +162,7 @@ impl Parser {
             Ok(v) => v,
             Err(e) => {
                 return Err(self.error.abort(
-                    &format!("k param is invalid, max allowed is {}. Error: {}", MAX_K, e),
+                    &format!("k param is invalid, max allowed is {MAX_K}. Error: {e}"),
                     number.line,
                     number.column,
                 ))
@@ -171,7 +171,7 @@ impl Parser {
 
         if declared_k > MAX_K {
             return Err(self.error.abort(
-                &format!("k param is too high, max allowed is {}", MAX_K),
+                &format!("k param is too high, max allowed is {MAX_K}"),
                 number.line,
                 number.column,
             ))
@@ -209,8 +209,8 @@ impl Parser {
         if !ALLOWED_FIELDS.contains(&field_name.token.as_str()) {
             return Err(self.error.abort(
                 &format!(
-                    "Declared field \"{}\" is not supported. Use any of: {:?}",
-                    field_name.token, ALLOWED_FIELDS
+                    "Declared field \"{}\" is not supported. Use any of: {ALLOWED_FIELDS:?}",
+                    field_name.token
                 ),
                 field_name.line,
                 field_name.column,
@@ -267,7 +267,7 @@ impl Parser {
 
                     x => {
                         return Err(self.error.abort(
-                            &format!("Section `{}` is not a valid section", x),
+                            &format!("Section `{x}` is not a valid section"),
                             t.line,
                             t.column,
                         ))
@@ -282,7 +282,7 @@ impl Parser {
                     if let Some(ns) = namespace.clone() {
                         if ns != $t[0].token {
                             return Err(self.error.abort(
-                                &format!("Found '{}' namespace, expected '{}'.", $t[0].token, ns),
+                                &format!("Found '{}' namespace, expected '{ns}'.", $t[0].token),
                                 $t[0].line,
                                 $t[0].column,
                             ))
@@ -299,7 +299,7 @@ impl Parser {
                         namespace = Some($t[0].token.clone());
                         if namespace.as_ref().unwrap().as_bytes().len() > MAX_NS_LEN {
                             return Err(self.error.abort(
-                                &format!("Namespace too long, max {} bytes", MAX_NS_LEN),
+                                &format!("Namespace too long, max {MAX_NS_LEN} bytes"),
                                 $t[0].line,
                                 $t[0].column,
                             ))
@@ -513,12 +513,12 @@ impl Parser {
         match section {
             "constant" | "witness" => {
                 if tokens.len() == 3 {
-                    self.error.warn(&format!("{} section is empty.", section), 0, 0);
+                    self.error.warn(&format!("{section} section is empty."), 0, 0);
                 }
 
                 if tokens[2..tokens.len() - 1].len() % 3 != 0 {
                     return Err(self.error.abort(
-                        &format!("Invalid number of elements in '{}' section. Must be pairs of '<Type> <name>' separated with a comma ','.", section),
+                        &format!("Invalid number of elements in '{section}' section. Must be pairs of '<Type> <name>' separated with a comma ','."),
                         tokens[0].line,
                         tokens[0].column
                     ))
@@ -551,7 +551,7 @@ impl Parser {
         for (k, v) in ast.scam_iter() {
             if v.0.token != k {
                 return Err(self.error.abort(
-                    &format!("Constant name `{}` doesn't match token `{}`.", v.0.token, k),
+                    &format!("Constant name `{}` doesn't match token `{k}`.", v.0.token),
                     v.0.line,
                     v.0.column,
                 ))
@@ -580,9 +580,8 @@ impl Parser {
                     if !VALID_ECFIXEDPOINT.contains(&v.0.token.as_str()) {
                         return Err(self.error.abort(
                             &format!(
-                                "`{}` is not a valid EcFixedPoint constant. Supported: {:?}",
-                                v.0.token.as_str(),
-                                VALID_ECFIXEDPOINT
+                                "`{}` is not a valid EcFixedPoint constant. Supported: {VALID_ECFIXEDPOINT:?}",
+                                v.0.token.as_str()
                             ),
                             v.0.line,
                             v.0.column,
@@ -601,9 +600,8 @@ impl Parser {
                     if !VALID_ECFIXEDPOINTSHORT.contains(&v.0.token.as_str()) {
                         return Err(self.error.abort(
                             &format!(
-                                "`{}` is not a valid EcFixedPointShort constant. Supported: {:?}",
-                                v.0.token.as_str(),
-                                VALID_ECFIXEDPOINTSHORT
+                                "`{}` is not a valid EcFixedPointShort constant. Supported: {VALID_ECFIXEDPOINTSHORT:?}",
+                                v.0.token.as_str()
                             ),
                             v.0.line,
                             v.0.column,
@@ -622,9 +620,8 @@ impl Parser {
                     if !VALID_ECFIXEDPOINTBASE.contains(&v.0.token.as_str()) {
                         return Err(self.error.abort(
                             &format!(
-                                "`{}` is not a valid EcFixedPointBase constant. Supported: {:?}",
-                                v.0.token.as_str(),
-                                VALID_ECFIXEDPOINTBASE
+                                "`{}` is not a valid EcFixedPointBase constant. Supported: {VALID_ECFIXEDPOINTBASE:?}",
+                                v.0.token.as_str()
                             ),
                             v.0.line,
                             v.0.column,
@@ -641,7 +638,7 @@ impl Parser {
 
                 x => {
                     return Err(self.error.abort(
-                        &format!("`{}` is an unsupported constant type.", x),
+                        &format!("`{x}` is an unsupported constant type."),
                         v.1.line,
                         v.1.column,
                     ))
@@ -660,7 +657,7 @@ impl Parser {
         for (k, v) in ast.scam_iter() {
             if v.0.token != k {
                 return Err(self.error.abort(
-                    &format!("Witness name `{}` doesn't match token `{}`.", v.0.token, k),
+                    &format!("Witness name `{}` doesn't match token `{k}`.", v.0.token),
                     v.0.line,
                     v.0.column,
                 ))
@@ -759,7 +756,7 @@ impl Parser {
 
                 x => {
                     return Err(self.error.abort(
-                        &format!("`{}` is an unsupported witness type.", x),
+                        &format!("`{x}` is an unsupported witness type."),
                         v.1.line,
                         v.1.column,
                     ))
@@ -961,7 +958,7 @@ impl Parser {
                     stmt.rhs = rhs;
                 } else {
                     return Err(self.error.abort(
-                        &format!("Unimplemented opcode `{}`.", func_name),
+                        &format!("Unimplemented opcode `{func_name}`."),
                         token.line,
                         token.column,
                     ))
@@ -1098,7 +1095,7 @@ impl Parser {
                             Ok(_) => {}
                             Err(e) => {
                                 return Err(self.error.abort(
-                                    &format!("Failed to convert literal into u64: {}", e),
+                                    &format!("Failed to convert literal into u64: {e}"),
                                     arg.line,
                                     arg.column,
                                 ))
@@ -1126,7 +1123,7 @@ impl Parser {
                     // This assists with fuzz testing as existing features can still be tested
                     // without causing the fuzzer to choke due to the panic created
                     // by unimplmented!().
-                    // x => unimplemented!("{:#?}", x),
+                    // x => unimplemented!("{x:#?}"),
                     _ => {
                         return Err(self.error.abort(
                             "Character is illegal/unimplemented in this context",