runtime: Make DeterministicHostError field private

Author: leoyvens

chain/near/src/runtime/abi.rs

@@ -119,7 +119,7 @@ impl ToAscObj<AscActionReceipt> for codec::Receipt {
         let action = match self.receipt.as_ref().unwrap() {
             codec::receipt::Receipt::Action(action) => action,
             codec::receipt::Receipt::Data(_) => {
-                return Err(DeterministicHostError(anyhow!(
+                return Err(DeterministicHostError::from(anyhow!(
                     "Data receipt are now allowed"
                 )));
             }
@@ -413,12 +413,12 @@ impl ToAscObj<AscSuccessStatusEnum> for codec::execution_outcome::Status {
                 asc_new(heap, receipt_id.id.as_ref().unwrap())?.to_payload(),
             ),
             codec::execution_outcome::Status::Failure(_) => {
-                return Err(DeterministicHostError(anyhow!(
+                return Err(DeterministicHostError::from(anyhow!(
                     "Failure execution status are not allowed"
                 )));
             }
             codec::execution_outcome::Status::Unknown(_) => {
-                return Err(DeterministicHostError(anyhow!(
+                return Err(DeterministicHostError::from(anyhow!(
                     "Unknown execution status are not allowed"
                 )));
             }
@@ -443,7 +443,7 @@ impl ToAscObj<AscMerklePathItem> for codec::MerklePathItem {
                 0 => AscDirection::Left,
                 1 => AscDirection::Right,
                 x => {
-                    return Err(DeterministicHostError(anyhow!(
+                    return Err(DeterministicHostError::from(anyhow!(
                         "Invalid direction value {}",
                         x
                     )))
@@ -474,7 +474,7 @@ impl ToAscObj<AscSignature> for codec::Signature {
                 0 => 0,
                 1 => 1,
                 value => {
-                    return Err(DeterministicHostError(anyhow!(
+                    return Err(DeterministicHostError::from(anyhow!(
                         "Invalid signature type {}",
                         value,
                     )))
@@ -506,7 +506,7 @@ impl ToAscObj<AscPublicKey> for codec::PublicKey {
                 0 => 0,
                 1 => 1,
                 value => {
-                    return Err(DeterministicHostError(anyhow!(
+                    return Err(DeterministicHostError::from(anyhow!(
                         "Invalid public key type {}",
                         value,
                     )))

chain/near/src/trigger.rs

@@ -439,22 +439,24 @@ mod tests {
         fn get(&self, offset: u32, size: u32) -> Result<Vec<u8>, DeterministicHostError> {
             let memory_byte_count = self.memory.len();
             if memory_byte_count == 0 {
-                return Err(DeterministicHostError(anyhow!("No memory is allocated")));
+                return Err(DeterministicHostError::from(anyhow!(
+                    "No memory is allocated"
+                )));
             }
 
             let start_offset = offset as usize;
             let end_offset_exclusive = start_offset + size as usize;
 
             if start_offset >= memory_byte_count {
-                return Err(DeterministicHostError(anyhow!(
+                return Err(DeterministicHostError::from(anyhow!(
                     "Start offset {} is outside of allocated memory, max offset is {}",
                     start_offset,
                     memory_byte_count - 1
                 )));
             }
 
             if end_offset_exclusive > memory_byte_count {
-                return Err(DeterministicHostError(anyhow!(
+                return Err(DeterministicHostError::from(anyhow!(
                     "End of offset {} is outside of allocated memory, max offset is {}",
                     end_offset_exclusive,
                     memory_byte_count - 1

graph/src/components/subgraph/host.rs

@@ -26,7 +26,7 @@ impl From<anyhow::Error> for MappingError {
 
 impl From<DeterministicHostError> for MappingError {
     fn from(value: DeterministicHostError) -> MappingError {
-        MappingError::Unknown(value.0)
+        MappingError::Unknown(value.inner())
     }
 }
 

graph/src/runtime/asc_ptr.rs

@@ -158,7 +158,10 @@ impl<C: AscType> AscPtr<C> {
         self.check_is_not_null()?;
 
         let start_of_rt_size = self.0.checked_sub(SIZE_OF_RT_SIZE).ok_or_else(|| {
-            DeterministicHostError(anyhow::anyhow!("Subtract overflow on pointer: {}", self.0))
+            DeterministicHostError::from(anyhow::anyhow!(
+                "Subtract overflow on pointer: {}",
+                self.0
+            ))
         })?;
         let raw_bytes = heap.get(start_of_rt_size, size_of::<u32>() as u32)?;
         let mut u32_bytes: [u8; size_of::<u32>()] = [0; size_of::<u32>()];
@@ -183,7 +186,7 @@ impl<C: AscType> AscPtr<C> {
     /// Summary: ALWAYS call this before reading an AscPtr.
     pub fn check_is_not_null(&self) -> Result<(), DeterministicHostError> {
         if self.is_null() {
-            return Err(DeterministicHostError(anyhow::anyhow!(
+            return Err(DeterministicHostError::from(anyhow::anyhow!(
                 "Tried to read AssemblyScript value that is 'null'. Suggestion: look into the function that the error happened and add 'log' calls till you find where a 'null' value is being used as non-nullable. It's likely that you're calling a 'graph-ts' function (or operator) with a 'null' value when it doesn't support it."
             )));
         }

graph/src/runtime/gas/mod.rs

@@ -94,7 +94,7 @@ impl GasCounter {
             .unwrap();
         let new = old.saturating_add(amount.0);
         if new >= *MAX_GAS_PER_HANDLER {
-            Err(DeterministicHostError(anyhow::anyhow!(
+            Err(DeterministicHostError::from(anyhow::anyhow!(
                 "Gas limit exceeded. Used: {}",
                 new
             )))

graph/src/runtime/mod.rs

@@ -94,7 +94,7 @@ impl AscType for bool {
         _api_version: &Version,
     ) -> Result<Self, DeterministicHostError> {
         if asc_obj.len() != 1 {
-            Err(DeterministicHostError(anyhow::anyhow!(
+            Err(DeterministicHostError::from(anyhow::anyhow!(
                 "Incorrect size for bool. Expected 1, got {},",
                 asc_obj.len()
             )))
@@ -117,7 +117,7 @@ macro_rules! impl_asc_type {
 
                 fn from_asc_bytes(asc_obj: &[u8], _api_version: &Version) -> Result<Self, DeterministicHostError> {
                     let bytes = asc_obj.try_into().map_err(|_| {
-                        DeterministicHostError(anyhow::anyhow!(
+                        DeterministicHostError::from(anyhow::anyhow!(
                             "Incorrect size for {}. Expected {}, got {},",
                             stringify!($T),
                             size_of::<Self>(),
@@ -252,14 +252,26 @@ impl ToAscObj<u32> for IndexForAscTypeId {
 }
 
 #[derive(Debug)]
-pub struct DeterministicHostError(pub Error);
+pub struct DeterministicHostError(Error);
+
+impl DeterministicHostError {
+    pub fn inner(self) -> Error {
+        self.0
+    }
+}
 
 impl fmt::Display for DeterministicHostError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
     }
 }
 
+impl From<Error> for DeterministicHostError {
+    fn from(e: Error) -> DeterministicHostError {
+        DeterministicHostError(e)
+    }
+}
+
 impl std::error::Error for DeterministicHostError {}
 
 #[derive(thiserror::Error, Debug)]

runtime/derive/src/lib.rs

@@ -102,15 +102,15 @@ fn asc_type_derive_struct(item_struct: ItemStruct) -> TokenStream {
                         // that contains both versions (each in a variant), and that increased
                         // the memory size, so that's why we use less than.
                         if asc_obj.len() < std::mem::size_of::<Self>() {
-                            return Err(graph::runtime::DeterministicHostError(graph::prelude::anyhow::anyhow!("Size does not match")));
+                            return Err(graph::runtime::DeterministicHostError::from(graph::prelude::anyhow::anyhow!("Size does not match")));
                         }
                     }
                     _ => {
                         let content_size = std::mem::size_of::<Self>();
                         let aligned_size = graph::runtime::padding_to_16(content_size);
 
                         if graph::runtime::HEADER_SIZE + asc_obj.len() == aligned_size + content_size {
-                            return Err(graph::runtime::DeterministicHostError(graph::prelude::anyhow::anyhow!("Size does not match")));
+                            return Err(graph::runtime::DeterministicHostError::from(graph::prelude::anyhow::anyhow!("Size does not match")));
                         }
                     },
                 };
@@ -120,7 +120,7 @@ fn asc_type_derive_struct(item_struct: ItemStruct) -> TokenStream {
                 #(
                 let field_size = std::mem::size_of::<#field_types>();
                 let field_data = asc_obj.get(offset..(offset + field_size)).ok_or_else(|| {
-                    graph::runtime::DeterministicHostError(graph::prelude::anyhow::anyhow!("Attempted to read past end of array"))
+                    graph::runtime::DeterministicHostError::from(graph::prelude::anyhow::anyhow!("Attempted to read past end of array"))
                 })?;
                 let #field_names2 = graph::runtime::AscType::from_asc_bytes(&field_data, api_version)?;
                 offset += field_size;
@@ -163,7 +163,7 @@ fn asc_type_derive_struct(item_struct: ItemStruct) -> TokenStream {
 //     fn from_asc_bytes(asc_obj: &[u8], _api_version: graph::semver::Version) -> Result<Self, graph::runtime::DeterministicHostError> {
 //         let mut u32_bytes: [u8; size_of::<u32>()] = [0; size_of::<u32>()];
 //         if std::mem::size_of_val(&u32_bytes) != std::mem::size_of_val(&asc_obj) {
-//             return Err(graph::runtime::DeterministicHostError(graph::prelude::anyhow::anyhow!("Invalid asc bytes size")));
+//             return Err(graph::runtime::DeterministicHostError::from(graph::prelude::anyhow::anyhow!("Invalid asc bytes size")));
 //         }
 //         u32_bytes.copy_from_slice(&asc_obj);
 //         let discr = u32::from_le_bytes(u32_bytes);
@@ -174,7 +174,7 @@ fn asc_type_derive_struct(item_struct: ItemStruct) -> TokenStream {
 //             3u32 => JsonValueKind::String,
 //             4u32 => JsonValueKind::Array,
 //             5u32 => JsonValueKind::Object,
-//             _ => Err(graph::runtime::DeterministicHostError(graph::prelude::anyhow::anyhow!("value {} is out of range for {}", discr, "JsonValueKind"))),
+//             _ => Err(graph::runtime::DeterministicHostError::from(graph::prelude::anyhow::anyhow!("value {} is out of range for {}", discr, "JsonValueKind"))),
 //         }
 //     }
 // }
@@ -206,11 +206,11 @@ fn asc_type_derive_enum(item_enum: ItemEnum) -> TokenStream {
 
             fn from_asc_bytes(asc_obj: &[u8], _api_version: &graph::semver::Version) -> Result<Self, graph::runtime::DeterministicHostError> {
                 let u32_bytes = ::std::convert::TryFrom::try_from(asc_obj)
-                    .map_err(|_| graph::runtime::DeterministicHostError(graph::prelude::anyhow::anyhow!("Invalid asc bytes size")))?;
+                    .map_err(|_| graph::runtime::DeterministicHostError::from(graph::prelude::anyhow::anyhow!("Invalid asc bytes size")))?;
                 let discr = u32::from_le_bytes(u32_bytes);
                 match discr {
                     #(#variant_discriminant2 => Ok(#enum_name_iter2::#variant_paths2),)*
-                    _ => Err(graph::runtime::DeterministicHostError(graph::prelude::anyhow::anyhow!("value {} is out of range for {}", discr, stringify!(#enum_name))))
+                    _ => Err(graph::runtime::DeterministicHostError::from(graph::prelude::anyhow::anyhow!("value {} is out of range for {}", discr, stringify!(#enum_name))))
                 }
             }
         }

runtime/wasm/src/asc_abi/v0_0_4.rs

@@ -32,7 +32,7 @@ impl ArrayBuffer {
         }
 
         if content.len() > u32::max_value() as usize {
-            return Err(DeterministicHostError(anyhow::anyhow!(
+            return Err(DeterministicHostError::from(anyhow::anyhow!(
                 "slice cannot fit in WASM memory"
             )));
         }
@@ -69,7 +69,7 @@ impl ArrayBuffer {
         self.content
             .get(range)
             .ok_or_else(|| {
-                DeterministicHostError(anyhow::anyhow!("Attempted to read past end of array"))
+                DeterministicHostError::from(anyhow::anyhow!("Attempted to read past end of array"))
             })?
             .chunks_exact(size_of::<T>())
             .map(|bytes| T::from_asc_bytes(bytes))
@@ -106,10 +106,10 @@ impl AscType for ArrayBuffer {
         // Skip `byte_length` and the padding.
         let content_offset = size_of::<u32>() + 4;
         let byte_length = asc_obj.get(..size_of::<u32>()).ok_or_else(|| {
-            DeterministicHostError(anyhow!("Attempted to read past end of array"))
+            DeterministicHostError::from(anyhow!("Attempted to read past end of array"))
         })?;
         let content = asc_obj.get(content_offset..).ok_or_else(|| {
-            DeterministicHostError(anyhow!("Attempted to read past end of array"))
+            DeterministicHostError::from(anyhow!("Attempted to read past end of array"))
         })?;
         Ok(ArrayBuffer {
             byte_length: u32::from_asc_bytes(&byte_length, api_version)?,
@@ -188,7 +188,7 @@ pub struct AscString {
 impl AscString {
     pub fn new(content: &[u16]) -> Result<Self, DeterministicHostError> {
         if size_of_val(content) > u32::max_value() as usize {
-            return Err(DeterministicHostError(anyhow!(
+            return Err(DeterministicHostError::from(anyhow!(
                 "string cannot fit in WASM memory"
             )));
         }
@@ -229,21 +229,21 @@ impl AscType for AscString {
 
         let length = asc_obj
             .get(..offset)
-            .ok_or(DeterministicHostError(anyhow::anyhow!(
+            .ok_or(DeterministicHostError::from(anyhow::anyhow!(
                 "String bytes not long enough to contain length"
             )))?;
 
         // Does not panic - already validated slice length == size_of::<i32>.
         let length = i32::from_le_bytes(length.try_into().unwrap());
         if length.checked_mul(2).and_then(|l| l.checked_add(4)) != asc_obj.len().try_into().ok() {
-            return Err(DeterministicHostError(anyhow::anyhow!(
+            return Err(DeterministicHostError::from(anyhow::anyhow!(
                 "String length header does not equal byte length"
             )));
         }
 
         // Prevents panic when accessing offset + 1 in the loop
         if asc_obj.len() % 2 != 0 {
-            return Err(DeterministicHostError(anyhow::anyhow!(
+            return Err(DeterministicHostError::from(anyhow::anyhow!(
                 "Invalid string length"
             )));
         }
@@ -279,7 +279,7 @@ impl AscType for AscString {
         let data_size = code_point_size.checked_mul(length);
         let total_size = data_size.and_then(|d| d.checked_add(length_size));
         total_size.ok_or_else(|| {
-            DeterministicHostError(anyhow::anyhow!("Overflowed when getting size of string"))
+            DeterministicHostError::from(anyhow::anyhow!("Overflowed when getting size of string"))
         })
     }
 }

runtime/wasm/src/asc_abi/v0_0_5.rs

@@ -29,7 +29,7 @@ impl ArrayBuffer {
         }
 
         if content.len() > u32::max_value() as usize {
-            return Err(DeterministicHostError(anyhow::anyhow!(
+            return Err(DeterministicHostError::from(anyhow::anyhow!(
                 "slice cannot fit in WASM memory"
             )));
         }
@@ -141,7 +141,7 @@ impl<T: AscValue> TypedArray<T> {
             .data_start
             .checked_sub(self.buffer.wasm_ptr())
             .ok_or_else(|| {
-                DeterministicHostError(anyhow::anyhow!(
+                DeterministicHostError::from(anyhow::anyhow!(
                     "Subtract overflow on pointer: {}",
                     self.data_start
                 ))
@@ -169,7 +169,7 @@ pub struct AscString {
 impl AscString {
     pub fn new(content: &[u16]) -> Result<Self, DeterministicHostError> {
         if size_of_val(content) > u32::max_value() as usize {
-            return Err(DeterministicHostError(anyhow!(
+            return Err(DeterministicHostError::from(anyhow!(
                 "string cannot fit in WASM memory"
             )));
         }
@@ -222,7 +222,7 @@ impl AscType for AscString {
             let code_point_bytes = [
                 pair[0],
                 *pair.get(1).ok_or_else(|| {
-                    DeterministicHostError(anyhow!(
+                    DeterministicHostError::from(anyhow!(
                         "Attempted to read past end of string content bytes chunk"
                     ))
                 })?,
@@ -290,7 +290,7 @@ impl<T: AscValue> Array<T> {
             .buffer_data_start
             .checked_sub(self.buffer.wasm_ptr())
             .ok_or_else(|| {
-                DeterministicHostError(anyhow::anyhow!(
+                DeterministicHostError::from(anyhow::anyhow!(
                     "Subtract overflow on pointer: {}",
                     self.buffer_data_start
                 ))

runtime/wasm/src/error.rs

@@ -26,6 +26,6 @@ impl IntoTrap for DeterministicHostError {
         DeterminismLevel::Deterministic
     }
     fn into_trap(self) -> Trap {
-        Trap::from(self.0)
+        Trap::from(self.inner())
     }
 }