diff --git a/include/xrpl/tx/wasm/HostFunc.h b/include/xrpl/tx/wasm/HostFunc.h
index 6a849e9935..f318610488 100644
--- a/include/xrpl/tx/wasm/HostFunc.h
+++ b/include/xrpl/tx/wasm/HostFunc.h
@@ -1,16 +1,22 @@
 #pragma once
 
 #include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Asset.h>
-#include <xrpl/protocol/Keylet.h>
-#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/UintTypes.h>
 #include <xrpl/tx/wasm/WasmCommon.h>
 
+#include <cstdint>
+#include <expected>
+#include <functional>
+#include <optional>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 
 namespace xrpl {
 
@@ -109,37 +115,37 @@ public:
         return true;
     }
 
-    virtual std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<std::uint32_t, HostFunctionError>
     getLedgerSqn() const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<std::uint32_t, HostFunctionError>
     getParentLedgerTime() const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Hash, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Hash, HostFunctionError>
     getParentLedgerHash() const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<uint32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<uint32_t, HostFunctionError>
     getBaseFee() const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     isAmendmentEnabled(uint256 const& amendmentId) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     isAmendmentEnabled(std::string_view const& amendmentName) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
@@ -151,73 +157,73 @@ public:
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     getTxField(SField const& fname) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     getCurrentLedgerObjField(SField const& fname) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     getLedgerObjField(int32_t cacheIdx, SField const& fname) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     getTxNestedField(FieldLocator const& locator) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     getCurrentLedgerObjNestedField(FieldLocator const& locator) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     getLedgerObjNestedField(int32_t cacheIdx, FieldLocator const& locator) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     getTxArrayLen(SField const& fname) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     getCurrentLedgerObjArrayLen(SField const& fname) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     getTxNestedArrayLen(FieldLocator const& locator) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     getCurrentLedgerObjNestedArrayLen(FieldLocator const& locator) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     getLedgerObjNestedArrayLen(int32_t cacheIdx, FieldLocator const& locator) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
@@ -229,280 +235,280 @@ public:
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     checkSignature(Slice const& message, Slice const& signature, Slice const& pubkey) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Hash, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Hash, HostFunctionError>
     computeSha512HalfHash(Slice const& data) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     accountKeylet(AccountID const& account) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     ammKeylet(Asset const& issue1, Asset const& issue2) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     checkKeylet(AccountID const& account, std::uint32_t seq) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     credentialKeylet(AccountID const& subject, AccountID const& issuer, Slice const& credentialType)
         const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     didKeylet(AccountID const& account) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     delegateKeylet(AccountID const& account, AccountID const& authorize) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     depositPreauthKeylet(AccountID const& account, AccountID const& authorize) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     escrowKeylet(AccountID const& account, std::uint32_t seq) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     trustLineKeylet(AccountID const& account1, AccountID const& account2, Currency const& currency)
         const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     mptokenIssuanceKeylet(AccountID const& issuer, std::uint32_t seq) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     mptokenKeylet(MPTID const& mptid, AccountID const& holder) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     nftokenOfferKeylet(AccountID const& account, std::uint32_t seq) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     offerKeylet(AccountID const& account, std::uint32_t seq) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     oracleKeylet(AccountID const& account, std::uint32_t docId) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     paychannelKeylet(AccountID const& account, AccountID const& destination, std::uint32_t seq)
         const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     permissionedDomainKeylet(AccountID const& account, std::uint32_t seq) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     signerListKeylet(AccountID const& account) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     ticketKeylet(AccountID const& account, std::uint32_t seq) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     vaultKeylet(AccountID const& account, std::uint32_t seq) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     getNFT(AccountID const& account, uint256 const& nftId) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     getNFTIssuer(uint256 const& nftId) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<std::uint32_t, HostFunctionError>
     getNFTTaxon(uint256 const& nftId) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     getNFTFlags(uint256 const& nftId) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     getNFTTransferFee(uint256 const& nftId) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<std::uint32_t, HostFunctionError>
     getNFTSequence(uint256 const& nftId) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     trace(std::string_view const& msg, Slice const& data, bool asHex) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     traceNum(std::string_view const& msg, int64_t data) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     traceAccount(std::string_view const& msg, AccountID const& account) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     traceFloat(std::string_view const& msg, Slice const& data) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     traceAmount(std::string_view const& msg, STAmount const& amount) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatFromInt(int64_t x, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatFromUint(uint64_t x, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatFromSTAmount(STAmount const& x, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatFromSTNumber(STNumber const& x, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int64_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int64_t, HostFunctionError>
     floatToInt(Slice const& x, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<FloatPair, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<FloatPair, HostFunctionError>
     floatToMantExp(Slice const& x) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatFromMantExp(int64_t mantissa, int32_t exponent, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
     floatCompare(Slice const& x, Slice const& y) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatAdd(Slice const& x, Slice const& y, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatSubtract(Slice const& x, Slice const& y, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatMultiply(Slice const& x, Slice const& y, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatDivide(Slice const& x, Slice const& y, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatRoot(Slice const& x, int32_t n, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    virtual std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
     floatPower(Slice const& x, int32_t n, int32_t mode) const
     {
         return std::unexpected(HostFunctionError::Unimplemented);
diff --git a/include/xrpl/tx/wasm/HostFuncImpl.h b/include/xrpl/tx/wasm/HostFuncImpl.h
index b32023039b..37ee4af5a8 100644
--- a/include/xrpl/tx/wasm/HostFuncImpl.h
+++ b/include/xrpl/tx/wasm/HostFuncImpl.h
@@ -1,7 +1,26 @@
 #pragma once
 
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/UintTypes.h>
 #include <xrpl/tx/ApplyContext.h>
 #include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <optional>
+#include <string_view>
 
 namespace xrpl {
 
diff --git a/include/xrpl/tx/wasm/HostFuncWrapper.h b/include/xrpl/tx/wasm/HostFuncWrapper.h
index 2954c8f423..1d04d7202a 100644
--- a/include/xrpl/tx/wasm/HostFuncWrapper.h
+++ b/include/xrpl/tx/wasm/HostFuncWrapper.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <xrpl/tx/wasm/WasmImportsHelper.h>
+#include <xrpl/tx/wasm/HostFunc.h>
 
 #include <wasm.h>
 
diff --git a/include/xrpl/tx/wasm/WasmCommon.h b/include/xrpl/tx/wasm/WasmCommon.h
index 8d3cff09c7..3e55777b7c 100644
--- a/include/xrpl/tx/wasm/WasmCommon.h
+++ b/include/xrpl/tx/wasm/WasmCommon.h
@@ -4,10 +4,15 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/protocol/TER.h>
 
+#include <bit>
+#include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <optional>
 #include <stdexcept>
 #include <string_view>
+#include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace xrpl {
@@ -184,7 +189,6 @@ wasmParamsHlp(std::vector<WasmParam>& v, std::int64_t p, Types&&... args)
 inline void
 wasmParamsHlp(std::vector<WasmParam>& v)
 {
-    return;
 }
 
 template <class... Types>
diff --git a/include/xrpl/tx/wasm/WasmImportsHelper.h b/include/xrpl/tx/wasm/WasmImportsHelper.h
index a0bf74a089..b5b98f672b 100644
--- a/include/xrpl/tx/wasm/WasmImportsHelper.h
+++ b/include/xrpl/tx/wasm/WasmImportsHelper.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include <xrpl/basics/base_uint.h>
 #include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
 
 #include <boost/function_types/function_arity.hpp>
 #include <boost/function_types/parameter_types.hpp>
@@ -10,6 +10,13 @@
 
 #include <wasm.h>
 
+#include <cstdint>
+#include <optional>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
 namespace bft = boost::function_types;
 
 namespace xrpl {
@@ -37,7 +44,7 @@ WasmImpArgs(WasmImportFunc& e)
 {
     if constexpr (N < C)
     {
-        using at = typename boost::mpl::at_c<Mpl, N>::type;
+        using at = boost::mpl::at_c<Mpl, N>::type;
         if constexpr (std::is_pointer_v<at>)
         {
             e.params.push_back(WasmTypes::WtI32);
@@ -57,7 +64,6 @@ WasmImpArgs(WasmImportFunc& e)
 
         return WasmImpArgs<N + 1, C, Mpl>(e);
     }
-    return;
 }
 
 template <typename>
@@ -93,8 +99,8 @@ template <typename F>
 void
 WasmImpFuncHelper(WasmImportFunc& e)
 {
-    using rt = typename bft::result_type<F>::type;
-    using pt = typename bft::parameter_types<F>::type;
+    using rt = bft::result_type<F>::type;
+    using pt = bft::parameter_types<F>::type;
     // typename boost::mpl::at_c<mpl, N>::type
 
     WasmImpRet<rt>(e);
diff --git a/include/xrpl/tx/wasm/WasmVM.h b/include/xrpl/tx/wasm/WasmVM.h
index 3e200eca17..7d5bb1563e 100644
--- a/include/xrpl/tx/wasm/WasmVM.h
+++ b/include/xrpl/tx/wasm/WasmVM.h
@@ -1,9 +1,17 @@
 #pragma once
 
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/TER.h>
 #include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
 #include <xrpl/tx/wasm/WasmImportsHelper.h>
 
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <string>
 #include <string_view>
+#include <vector>
 
 namespace xrpl {
 
diff --git a/include/xrpl/tx/wasm/WasmiVM.h b/include/xrpl/tx/wasm/WasmiVM.h
index 9c41b05d7c..d4a026ff54 100644
--- a/include/xrpl/tx/wasm/WasmiVM.h
+++ b/include/xrpl/tx/wasm/WasmiVM.h
@@ -1,12 +1,28 @@
 #pragma once
 
+#include <xrpl/basics/contract.h>
+#include <xrpl/beast/utility/Journal.h>
 #include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+#include <xrpl/tx/wasm/WasmImportsHelper.h>
 #include <xrpl/tx/wasm/WasmVM.h>
 
 #include <wasm.h>
-#include <wasmi.h>
 
+#include <cstddef>
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <mutex>
 #include <optional>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/wasm/HostFuncImpl.cpp b/src/libxrpl/tx/wasm/HostFuncImpl.cpp
index fa2b0153d8..2067062deb 100644
--- a/src/libxrpl/tx/wasm/HostFuncImpl.cpp
+++ b/src/libxrpl/tx/wasm/HostFuncImpl.cpp
@@ -7,6 +7,7 @@
 #include <xrpl/tx/wasm/WasmCommon.h>
 
 #include <cstdint>
+#include <expected>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/wasm/HostFuncImplFloat.cpp b/src/libxrpl/tx/wasm/HostFuncImplFloat.cpp
index 57e24dd4b7..0aea18548a 100644
--- a/src/libxrpl/tx/wasm/HostFuncImplFloat.cpp
+++ b/src/libxrpl/tx/wasm/HostFuncImplFloat.cpp
@@ -10,6 +10,7 @@
 #include <boost/algorithm/hex.hpp>
 
 #include <cstdint>
+#include <expected>
 #include <iterator>
 #include <string>
 #include <utility>
@@ -91,7 +92,7 @@ public:
         return Number::operator int64_t();
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     toBytes() const
     {
         Serializer msg;
diff --git a/src/libxrpl/tx/wasm/HostFuncImplGetter.cpp b/src/libxrpl/tx/wasm/HostFuncImplGetter.cpp
index a4cb37a30e..4ae0c72426 100644
--- a/src/libxrpl/tx/wasm/HostFuncImplGetter.cpp
+++ b/src/libxrpl/tx/wasm/HostFuncImplGetter.cpp
@@ -13,6 +13,7 @@
 #include <xrpl/tx/wasm/WasmCommon.h>
 
 #include <cstdint>
+#include <expected>
 #include <stdexcept>
 #include <string>
 #include <utility>
@@ -31,7 +32,7 @@ getIntBytes(STBase const* obj)
 
     auto const* num(static_cast<STInteger<T> const*>(obj));  // NOLINT
     T const data = adjustWasmEndianess(num->value());
-    uint8_t const* b = reinterpret_cast<uint8_t const*>(&data);
+    auto const* b = reinterpret_cast<uint8_t const*>(&data);
     return Bytes{b, b + sizeof(T)};
 }
 
diff --git a/src/libxrpl/tx/wasm/HostFuncImplKeylet.cpp b/src/libxrpl/tx/wasm/HostFuncImplKeylet.cpp
index 66d96381c8..a16fc071a1 100644
--- a/src/libxrpl/tx/wasm/HostFuncImplKeylet.cpp
+++ b/src/libxrpl/tx/wasm/HostFuncImplKeylet.cpp
@@ -9,6 +9,7 @@
 #include <xrpl/tx/wasm/WasmCommon.h>
 
 #include <cstdint>
+#include <expected>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/wasm/HostFuncImplLedgerHeader.cpp b/src/libxrpl/tx/wasm/HostFuncImplLedgerHeader.cpp
index 49a4c3cdf0..9def11dc95 100644
--- a/src/libxrpl/tx/wasm/HostFuncImplLedgerHeader.cpp
+++ b/src/libxrpl/tx/wasm/HostFuncImplLedgerHeader.cpp
@@ -4,6 +4,7 @@
 #include <xrpl/tx/wasm/WasmCommon.h>
 
 #include <cstdint>
+#include <expected>
 #include <string>
 #include <string_view>
 
diff --git a/src/libxrpl/tx/wasm/HostFuncImplNFT.cpp b/src/libxrpl/tx/wasm/HostFuncImplNFT.cpp
index 118172c247..fdbf7d2e2d 100644
--- a/src/libxrpl/tx/wasm/HostFuncImplNFT.cpp
+++ b/src/libxrpl/tx/wasm/HostFuncImplNFT.cpp
@@ -8,6 +8,7 @@
 #include <xrpl/tx/wasm/WasmCommon.h>
 
 #include <cstdint>
+#include <expected>
 
 namespace xrpl {
 
diff --git a/src/libxrpl/tx/wasm/HostFuncImplTrace.cpp b/src/libxrpl/tx/wasm/HostFuncImplTrace.cpp
index fea608aa77..4e4058ea39 100644
--- a/src/libxrpl/tx/wasm/HostFuncImplTrace.cpp
+++ b/src/libxrpl/tx/wasm/HostFuncImplTrace.cpp
@@ -3,10 +3,12 @@
 #include <xrpl/protocol/STAmount.h>
 #include <xrpl/tx/wasm/HostFunc.h>
 #include <xrpl/tx/wasm/HostFuncImpl.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
 
 #include <boost/algorithm/hex.hpp>
 
 #include <cstdint>
+#include <expected>
 #include <iterator>
 #include <string>
 #include <string_view>
diff --git a/src/libxrpl/tx/wasm/HostFuncWrapper.cpp b/src/libxrpl/tx/wasm/HostFuncWrapper.cpp
index 9788bce345..ea5caec6cc 100644
--- a/src/libxrpl/tx/wasm/HostFuncWrapper.cpp
+++ b/src/libxrpl/tx/wasm/HostFuncWrapper.cpp
@@ -29,6 +29,7 @@
 #include <cstdint>
 #include <cstring>
 #include <exception>
+#include <expected>
 #include <functional>
 #include <optional>
 #include <stdexcept>
@@ -170,7 +171,7 @@ getDataSlice(WasmRuntimeWrapper& runtime, wasm_val_vec_t const* params, int32_t&
     if (std::cmp_greater(ptr + size, memory.s))
         return std::unexpected(HostFunctionError::PointerOutOfBounds);
 
-    Slice data(memory.p + ptr, size);
+    Slice const data(memory.p + ptr, size);
     return data;
 }
 
@@ -202,7 +203,7 @@ getDataUnsigned(WasmRuntimeWrapper& runtime, wasm_val_vec_t const* params, int32
         return std::unexpected(HostFunctionError::InvalidParams);
 
     T x;
-    uintptr_t const p = reinterpret_cast<uintptr_t>(r->data());
+    auto const p = reinterpret_cast<uintptr_t>(r->data());
     if (p & (alignof(T) - 1))  // unaligned
     {
         memcpy(&x, r->data(), sizeof(T));
@@ -357,7 +358,7 @@ getDataLocator(WasmRuntimeWrapper& runtime, wasm_val_vec_t const* params, int32_
         return std::unexpected(HostFunctionError::LocatorMalformed);
 
     uint32_t const locSize = slice->size() / sizeof(int32_t);
-    uintptr_t const p = reinterpret_cast<uintptr_t>(slice->data());
+    auto const p = reinterpret_cast<uintptr_t>(slice->data());
 
     if ((p & (alignof(int32_t) - 1)) != 0u)
     {  // unaligned
@@ -376,7 +377,7 @@ getDataLocator(WasmRuntimeWrapper& runtime, wasm_val_vec_t const* params, int32_
         return locator;
     }
 
-    int32_t const* locPtr = reinterpret_cast<int32_t const*>(slice->data());
+    auto const* locPtr = reinterpret_cast<int32_t const*>(slice->data());
     return FieldLocator(locPtr, locSize);
 }
 
diff --git a/src/libxrpl/tx/wasm/WasmVM.cpp b/src/libxrpl/tx/wasm/WasmVM.cpp
index 141da2dc81..d585892c69 100644
--- a/src/libxrpl/tx/wasm/WasmVM.cpp
+++ b/src/libxrpl/tx/wasm/WasmVM.cpp
@@ -7,6 +7,7 @@
 #include <xrpl/tx/wasm/WasmImportsHelper.h>
 
 #include <cstdint>
+#include <expected>
 #include <string>
 #include <vector>
 #ifdef _DEBUG
diff --git a/src/libxrpl/tx/wasm/WasmiVM.cpp b/src/libxrpl/tx/wasm/WasmiVM.cpp
index a1e3a0aee8..a174124208 100644
--- a/src/libxrpl/tx/wasm/WasmiVM.cpp
+++ b/src/libxrpl/tx/wasm/WasmiVM.cpp
@@ -18,6 +18,7 @@
 #include <cstdint>
 #include <cstring>
 #include <exception>
+#include <expected>
 #include <limits>
 #include <memory>
 #include <mutex>
@@ -427,7 +428,7 @@ ModuleWrapper::buildImports(StorePtr& s, ImportVec const& imports) const
         auto fieldName = std::string_view(fn->data, fn->size);
 
         wasm_externkind_t const itype = wasm_externtype_kind(wasm_importtype_type(importType));
-        if ((itype) != WASM_EXTERN_FUNC)
+        if (itype != WASM_EXTERN_FUNC)
         {
             Throw<std::runtime_error>(
                 "Invalid import type " + std::to_string(itype));  // LCOV_EXCL_LINE
@@ -702,9 +703,7 @@ WasmiEngine::call(FuncInfo const& f, std::vector<wasm_val_t>& in)
         // Classify the trap into a TER by matching tokens as substrings of the
         // message (see the trap-signal constants in WasmCommon.h for why).
         std::string const msg = trapMessage(trap);
-        auto const has = [&msg](std::string_view token) {
-            return msg.find(token) != std::string::npos;
-        };
+        auto const has = [&msg](std::string_view token) { return msg.contains(token); };
         if (has(hfErrInternal))
         {
             ret.ter = tecINTERNAL;
diff --git a/src/test/app/HostFuncImpl_test.cpp b/src/test/app/HostFuncImpl_test.cpp
index 40718943ad..f9943e121c 100644
--- a/src/test/app/HostFuncImpl_test.cpp
+++ b/src/test/app/HostFuncImpl_test.cpp
@@ -3859,7 +3859,6 @@ struct HostFuncImpl_test : public beast::unit_test::Suite
         printFloats("ten", 10, 0);
         printFloats("pi", 3141592653589793, -15);
         printFloats("-three", -3, 0);
-        return;
     }
 
     void
diff --git a/src/test/app/TestHostFunctions.h b/src/test/app/TestHostFunctions.h
index bc24c26932..a3ded89f33 100644
--- a/src/test/app/TestHostFunctions.h
+++ b/src/test/app/TestHostFunctions.h
@@ -1,19 +1,26 @@
 #pragma once
 
-#include <test/app/wasm_fixtures/fixtures.h>
 #include <test/jtx/Env.h>
 #include <test/unit_test/SuiteJournal.h>
 
-#include <xrpl/ledger/AmendmentTable.h>
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
 #include <xrpl/ledger/detail/ApplyViewBase.h>
-#include <xrpl/ledger/helpers/NFTokenHelpers.h>
-#include <xrpl/protocol/digest.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAmount.h>
 #include <xrpl/tx/wasm/HostFunc.h>
-#include <xrpl/tx/wasm/WasmVM.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
 
 #include <boost/algorithm/hex.hpp>
 
 #include <cstdint>
+#include <expected>
 #include <iterator>
 #include <string>
 #include <string_view>
@@ -29,7 +36,7 @@ public:
     {
     }
 
-    std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
     getLedgerSqn() const override
     {
         return env_.current()->seq();
@@ -51,37 +58,37 @@ public:
         data_ = Bytes{t.begin(), t.end()};
     }
 
-    std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
     getLedgerSqn() const override
     {
         return 12345;
     }
 
-    std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
     getParentLedgerTime() const override
     {
         return 67890;
     }
 
-    std::expected<Hash, HostFunctionError>
+    [[nodiscard]] std::expected<Hash, HostFunctionError>
     getParentLedgerHash() const override
     {
         return env_.current()->header().parentHash;
     }
 
-    std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
     getBaseFee() const override
     {
         return 10;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     isAmendmentEnabled(uint256 const& amendmentId) const override
     {
         return 1;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     isAmendmentEnabled(std::string_view const& amendmentName) const override
     {
         return 1;
@@ -93,7 +100,7 @@ public:
         return 1;
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     getTxField(SField const& fname) const override
     {
         if (fname == sfAccount)
@@ -102,7 +109,7 @@ public:
         if (fname == sfFee)
         {
             int64_t x = 235;
-            uint8_t const* p = reinterpret_cast<uint8_t const*>(&x);
+            auto const* p = reinterpret_cast<uint8_t const*>(&x);
             return Bytes{p, p + sizeof(x)};
         }
 
@@ -120,7 +127,7 @@ public:
         return Bytes();
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     getCurrentLedgerObjField(SField const& fname) const override
     {
         auto const& sn = fname.getName();
@@ -138,13 +145,13 @@ public:
         return std::unexpected(HostFunctionError::Unimplemented);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     getLedgerObjField(int32_t, SField const& fname) const override
     {
         if (fname == sfBalance)
         {
             int64_t x = 10'000;
-            uint8_t const* p = reinterpret_cast<uint8_t const*>(&x);
+            auto const* p = reinterpret_cast<uint8_t const*>(&x);
             return Bytes{p, p + sizeof(x)};
         }
 
@@ -154,7 +161,7 @@ public:
         return data_;
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     getTxNestedField(FieldLocator const& locator) const override
     {
         if (locator.size() == 1)
@@ -171,7 +178,7 @@ public:
         return Bytes(&a[0], &a[sizeof(a)]);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     getCurrentLedgerObjNestedField(FieldLocator const& locator) const override
     {
         if (locator.size() == 1)
@@ -188,7 +195,7 @@ public:
         return Bytes(&a[0], &a[sizeof(a)]);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     getLedgerObjNestedField(int32_t cacheIdx, FieldLocator const& locator) const override
     {
         if (locator.size() == 1)
@@ -205,37 +212,37 @@ public:
         return Bytes(&a[0], &a[sizeof(a)]);
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     getTxArrayLen(SField const& fname) const override
     {
         return 32;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     getCurrentLedgerObjArrayLen(SField const& fname) const override
     {
         return 32;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname) const override
     {
         return 32;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     getTxNestedArrayLen(FieldLocator const& locator) const override
     {
         return 32;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     getCurrentLedgerObjNestedArrayLen(FieldLocator const& locator) const override
     {
         return 32;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     getLedgerObjNestedArrayLen(int32_t cacheIdx, FieldLocator const& locator) const override
     {
         return 32;
@@ -247,19 +254,19 @@ public:
         return data.size();
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     checkSignature(Slice const& message, Slice const& signature, Slice const& pubkey) const override
     {
         return 1;
     }
 
-    std::expected<Hash, HostFunctionError>
+    [[nodiscard]] std::expected<Hash, HostFunctionError>
     computeSha512HalfHash(Slice const& data) const override
     {
         return env_.current()->header().parentHash;
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     accountKeylet(AccountID const& account) const override
     {
         if (!account)
@@ -268,7 +275,7 @@ public:
         return Bytes{keylet.key.begin(), keylet.key.end()};
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     ammKeylet(Asset const& issue1, Asset const& issue2) const override
     {
         if (issue1 == issue2)
@@ -279,7 +286,7 @@ public:
         return Bytes{keylet.key.begin(), keylet.key.end()};
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     checkKeylet(AccountID const& account, std::uint32_t seq) const override
     {
         if (!account)
@@ -288,7 +295,7 @@ public:
         return Bytes{keylet.key.begin(), keylet.key.end()};
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     credentialKeylet(AccountID const& subject, AccountID const& issuer, Slice const& credentialType)
         const override
     {
@@ -299,7 +306,7 @@ public:
         return Bytes{keylet.key.begin(), keylet.key.end()};
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     escrowKeylet(AccountID const& account, std::uint32_t seq) const override
     {
         if (!account)
@@ -308,7 +315,7 @@ public:
         return Bytes{keylet.key.begin(), keylet.key.end()};
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     oracleKeylet(AccountID const& account, std::uint32_t documentId) const override
     {
         if (!account)
@@ -317,7 +324,7 @@ public:
         return Bytes{keylet.key.begin(), keylet.key.end()};
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     getNFT(AccountID const& account, uint256 const& nftId) const override
     {
         if (!account || !nftId)
@@ -327,31 +334,31 @@ public:
         return Bytes(s.begin(), s.end());
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     getNFTIssuer(uint256 const& nftId) const override
     {
         return Bytes(accountID_.begin(), accountID_.end());
     }
 
-    std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
     getNFTTaxon(uint256 const& nftId) const override
     {
         return 4;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     getNFTFlags(uint256 const& nftId) const override
     {
         return 8;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     getNFTTransferFee(uint256 const& nftId) const override
     {
         return 10;
     }
 
-    std::expected<std::uint32_t, HostFunctionError>
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
     getNFTSequence(uint256 const& nftId) const override
     {
         return 4;
@@ -375,7 +382,7 @@ public:
 #endif
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     trace(std::string_view const& msg, Slice const& data, bool asHex) const override
     {
         if (!asHex)
@@ -397,113 +404,113 @@ public:
         return 0;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     traceNum(std::string_view const& msg, int64_t data) const override
     {
         log(msg, [data] { return data; });
         return 0;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     traceAccount(std::string_view const& msg, AccountID const& account) const override
     {
         log(msg, [&account] { return toBase58(account); });
         return 0;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     traceFloat(std::string_view const& msg, Slice const& data) const override
     {
         log(msg, [&data] { return wasm_float::floatToString(data); });
         return 0;
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     traceAmount(std::string_view const& msg, STAmount const& amount) const override
     {
         log(msg, [&amount] { return amount.getFullText(); });
         return 0;
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatFromInt(int64_t x, int32_t mode) const override
     {
         return wasm_float::floatFromIntImpl(x, mode);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatFromUint(uint64_t x, int32_t mode) const override
     {
         return wasm_float::floatFromUintImpl(x, mode);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatFromSTAmount(STAmount const& x, int32_t mode) const override
     {
         return wasm_float::floatFromSTAmountImpl(x, mode);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatFromSTNumber(STNumber const& x, int32_t mode) const override
     {
         return wasm_float::floatFromSTNumberImpl(x, mode);
     }
 
-    std::expected<int64_t, HostFunctionError>
+    [[nodiscard]] std::expected<int64_t, HostFunctionError>
     floatToInt(Slice const& x, int32_t mode) const override
     {
         return wasm_float::floatToIntImpl(x, mode);
     }
 
-    std::expected<FloatPair, HostFunctionError>
+    [[nodiscard]] std::expected<FloatPair, HostFunctionError>
     floatToMantExp(Slice const& x) const override
     {
         return wasm_float::floatToMantExpImpl(x);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatFromMantExp(int64_t mantissa, int32_t exponent, int32_t mode) const override
     {
         return wasm_float::floatFromMantExpImpl(mantissa, exponent, mode);
     }
 
-    std::expected<int32_t, HostFunctionError>
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
     floatCompare(Slice const& x, Slice const& y) const override
     {
         return wasm_float::floatCompareImpl(x, y);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatAdd(Slice const& x, Slice const& y, int32_t mode) const override
     {
         return wasm_float::floatAddImpl(x, y, mode);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatSubtract(Slice const& x, Slice const& y, int32_t mode) const override
     {
         return wasm_float::floatSubtractImpl(x, y, mode);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatMultiply(Slice const& x, Slice const& y, int32_t mode) const override
     {
         return wasm_float::floatMultiplyImpl(x, y, mode);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatDivide(Slice const& x, Slice const& y, int32_t mode) const override
     {
         return wasm_float::floatDivideImpl(x, y, mode);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatRoot(Slice const& x, int32_t n, int32_t mode) const override
     {
         return wasm_float::floatRootImpl(x, n, mode);
     }
 
-    std::expected<Bytes, HostFunctionError>
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
     floatPower(Slice const& x, int32_t n, int32_t mode) const override
     {
         return wasm_float::floatPowerImpl(x, n, mode);
diff --git a/src/test/app/Wasm_test.cpp b/src/test/app/Wasm_test.cpp
index 48da0597f4..401f69058e 100644
--- a/src/test/app/Wasm_test.cpp
+++ b/src/test/app/Wasm_test.cpp
@@ -1,3 +1,4 @@
+#include <expected>
 #ifdef _DEBUG
 // #define DEBUG_OUTPUT 1
 #endif
@@ -312,7 +313,7 @@ struct Wasm_test : public beast::unit_test::Suite
                 explicit FieldNotFoundHostFunctions(Env& env) : TestHostFunctions(env)
                 {
                 }
-                std::expected<Bytes, HostFunctionError>
+                [[nodiscard]] std::expected<Bytes, HostFunctionError>
                 getTxField(SField const& fname) const override
                 {
                     return std::unexpected(HostFunctionError::FieldNotFound);
@@ -330,7 +331,7 @@ struct Wasm_test : public beast::unit_test::Suite
                 explicit OversizedFieldHostFunctions(Env& env) : TestHostFunctions(env)
                 {
                 }
-                std::expected<Bytes, HostFunctionError>
+                [[nodiscard]] std::expected<Bytes, HostFunctionError>
                 getTxField(SField const& fname) const override
                 {
                     return Bytes((128 + 1) * 64 * 1024, 1);