Merge pull request #45 from freenet/fix-flatbuffers-and-add-notfound

feat: add NotFound variant to ContractResponse

Author: sanity

rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "freenet-stdlib"
-version = "0.1.28"
+version = "0.1.29"
 edition = "2021"
 rust-version = "1.71.1"
 publish = true

rust/src/client_api/client_events.rs

@@ -31,10 +31,10 @@ use crate::generated::host_response::{
     ContractResponse as FbsContractResponse, ContractResponseArgs, ContractResponseType,
     DelegateKey as FbsDelegateKey, DelegateKeyArgs, DelegateResponse as FbsDelegateResponse,
     DelegateResponseArgs, GetResponse as FbsGetResponse, GetResponseArgs,
-    HostResponse as FbsHostResponse, HostResponseArgs, HostResponseType, Ok as FbsOk, OkArgs,
-    OutboundDelegateMsg as FbsOutboundDelegateMsg, OutboundDelegateMsgArgs,
-    OutboundDelegateMsgType, PutResponse as FbsPutResponse, PutResponseArgs,
-    RequestUserInput as FbsRequestUserInput, RequestUserInputArgs,
+    HostResponse as FbsHostResponse, HostResponseArgs, HostResponseType, NotFound as FbsNotFound,
+    NotFoundArgs, Ok as FbsOk, OkArgs, OutboundDelegateMsg as FbsOutboundDelegateMsg,
+    OutboundDelegateMsgArgs, OutboundDelegateMsgType, PutResponse as FbsPutResponse,
+    PutResponseArgs, RequestUserInput as FbsRequestUserInput, RequestUserInputArgs,
     SetSecretRequest as FbsSetSecretRequest, SetSecretRequestArgs,
     UpdateNotification as FbsUpdateNotification, UpdateNotificationArgs,
     UpdateResponse as FbsUpdateResponse, UpdateResponseArgs,
@@ -1349,6 +1349,41 @@ impl HostResponse {
                     Ok(builder.finished_data().to_vec())
                 }
                 ContractResponse::SubscribeResponse { .. } => todo!(),
+                ContractResponse::NotFound { instance_id } => {
+                    let instance_data = builder.create_vector(instance_id.as_bytes());
+                    let instance_offset = FbsContractInstanceId::create(
+                        &mut builder,
+                        &ContractInstanceIdArgs {
+                            data: Some(instance_data),
+                        },
+                    );
+
+                    let not_found_offset = FbsNotFound::create(
+                        &mut builder,
+                        &NotFoundArgs {
+                            instance_id: Some(instance_offset),
+                        },
+                    );
+
+                    let contract_response_offset = FbsContractResponse::create(
+                        &mut builder,
+                        &ContractResponseArgs {
+                            contract_response_type: ContractResponseType::NotFound,
+                            contract_response: Some(not_found_offset.as_union_value()),
+                        },
+                    );
+
+                    let response_offset = FbsHostResponse::create(
+                        &mut builder,
+                        &HostResponseArgs {
+                            response: Some(contract_response_offset.as_union_value()),
+                            response_type: HostResponseType::ContractResponse,
+                        },
+                    );
+
+                    finish_host_response_buffer(&mut builder, response_offset);
+                    Ok(builder.finished_data().to_vec())
+                }
             },
             HostResponse::DelegateResponse { key, values } => {
                 let key_data = builder.create_vector(key.bytes());
@@ -1588,6 +1623,9 @@ impl Display for HostResponse {
                 ContractResponse::SubscribeResponse { key, .. } => {
                     f.write_fmt(format_args!("subscribe response for `{key}`"))
                 }
+                ContractResponse::NotFound { instance_id } => {
+                    f.write_fmt(format_args!("not found for `{instance_id}`"))
+                }
             },
             HostResponse::DelegateResponse { .. } => write!(f, "delegate responses"),
             HostResponse::Ok => write!(f, "ok response"),
@@ -1624,6 +1662,13 @@ pub enum ContractResponse<T = WrappedState> {
         key: ContractKey,
         subscribed: bool,
     },
+    /// Contract was not found after exhaustive search.
+    /// This is an explicit response that distinguishes "contract doesn't exist"
+    /// from other failure modes like timeouts or network errors.
+    NotFound {
+        /// The instance ID that was searched for.
+        instance_id: ContractInstanceId,
+    },
 }
 
 impl<T> From<ContractResponse<T>> for HostResponse<T> {

rust/src/generated/client_request_generated.rs

@@ -4707,7 +4707,7 @@ pub mod client_request {
     /// `root_as_client_request_unchecked`.
     pub fn root_as_client_request(
         buf: &[u8],
-    ) -> Result<ClientRequest<'_>, flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<ClientRequest, flatbuffers::InvalidFlatbuffer> {
         flatbuffers::root::<ClientRequest>(buf)
     }
     #[inline]
@@ -4719,7 +4719,7 @@ pub mod client_request {
     /// `size_prefixed_root_as_client_request_unchecked`.
     pub fn size_prefixed_root_as_client_request(
         buf: &[u8],
-    ) -> Result<ClientRequest<'_>, flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<ClientRequest, flatbuffers::InvalidFlatbuffer> {
         flatbuffers::size_prefixed_root::<ClientRequest>(buf)
     }
     #[inline]
@@ -4752,14 +4752,14 @@ pub mod client_request {
     /// Assumes, without verification, that a buffer of bytes contains a ClientRequest and returns it.
     /// # Safety
     /// Callers must trust the given bytes do indeed contain a valid `ClientRequest`.
-    pub unsafe fn root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest<'_> {
+    pub unsafe fn root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest {
         flatbuffers::root_unchecked::<ClientRequest>(buf)
     }
     #[inline]
     /// Assumes, without verification, that a buffer of bytes contains a size prefixed ClientRequest and returns it.
     /// # Safety
     /// Callers must trust the given bytes do indeed contain a valid size prefixed `ClientRequest`.
-    pub unsafe fn size_prefixed_root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest<'_> {
+    pub unsafe fn size_prefixed_root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest {
         flatbuffers::size_prefixed_root_unchecked::<ClientRequest>(buf)
     }
     #[inline]

rust/src/generated/host_response_generated.rs

@@ -28,18 +28,19 @@ pub mod host_response {
         since = "2.0.0",
         note = "Use associated constants instead. This will no longer be generated in 2021."
     )]
-    pub const ENUM_MAX_CONTRACT_RESPONSE_TYPE: u8 = 4;
+    pub const ENUM_MAX_CONTRACT_RESPONSE_TYPE: u8 = 5;
     #[deprecated(
         since = "2.0.0",
         note = "Use associated constants instead. This will no longer be generated in 2021."
     )]
     #[allow(non_camel_case_types)]
-    pub const ENUM_VALUES_CONTRACT_RESPONSE_TYPE: [ContractResponseType; 5] = [
+    pub const ENUM_VALUES_CONTRACT_RESPONSE_TYPE: [ContractResponseType; 6] = [
         ContractResponseType::NONE,
         ContractResponseType::GetResponse,
         ContractResponseType::PutResponse,
         ContractResponseType::UpdateNotification,
         ContractResponseType::UpdateResponse,
+        ContractResponseType::NotFound,
     ];
 
     #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
@@ -52,15 +53,17 @@ pub mod host_response {
         pub const PutResponse: Self = Self(2);
         pub const UpdateNotification: Self = Self(3);
         pub const UpdateResponse: Self = Self(4);
+        pub const NotFound: Self = Self(5);
 
         pub const ENUM_MIN: u8 = 0;
-        pub const ENUM_MAX: u8 = 4;
+        pub const ENUM_MAX: u8 = 5;
         pub const ENUM_VALUES: &'static [Self] = &[
             Self::NONE,
             Self::GetResponse,
             Self::PutResponse,
             Self::UpdateNotification,
             Self::UpdateResponse,
+            Self::NotFound,
         ];
         /// Returns the variant's name or "" if unknown.
         pub fn variant_name(self) -> Option<&'static str> {
@@ -70,6 +73,7 @@ pub mod host_response {
                 Self::PutResponse => Some("PutResponse"),
                 Self::UpdateNotification => Some("UpdateNotification"),
                 Self::UpdateResponse => Some("UpdateResponse"),
+                Self::NotFound => Some("NotFound"),
                 _ => None,
             }
         }
@@ -996,6 +1000,134 @@ pub mod host_response {
             ds.finish()
         }
     }
+    pub enum NotFoundOffset {}
+    #[derive(Copy, Clone, PartialEq)]
+
+    pub struct NotFound<'a> {
+        pub _tab: flatbuffers::Table<'a>,
+    }
+
+    impl<'a> flatbuffers::Follow<'a> for NotFound<'a> {
+        type Inner = NotFound<'a>;
+        #[inline]
+        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+            Self {
+                _tab: flatbuffers::Table::new(buf, loc),
+            }
+        }
+    }
+
+    impl<'a> NotFound<'a> {
+        pub const VT_INSTANCE_ID: flatbuffers::VOffsetT = 4;
+
+        #[inline]
+        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+            NotFound { _tab: table }
+        }
+        #[allow(unused_mut)]
+        pub fn create<
+            'bldr: 'args,
+            'args: 'mut_bldr,
+            'mut_bldr,
+            A: flatbuffers::Allocator + 'bldr,
+        >(
+            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            args: &'args NotFoundArgs<'args>,
+        ) -> flatbuffers::WIPOffset<NotFound<'bldr>> {
+            let mut builder = NotFoundBuilder::new(_fbb);
+            if let Some(x) = args.instance_id {
+                builder.add_instance_id(x);
+            }
+            builder.finish()
+        }
+
+        #[inline]
+        pub fn instance_id(&self) -> super::common::ContractInstanceId<'a> {
+            // Safety:
+            // Created from valid Table for this object
+            // which contains a valid value in this slot
+            unsafe {
+                self._tab
+                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
+                        NotFound::VT_INSTANCE_ID,
+                        None,
+                    )
+                    .unwrap()
+            }
+        }
+    }
+
+    impl flatbuffers::Verifiable for NotFound<'_> {
+        #[inline]
+        fn run_verifier(
+            v: &mut flatbuffers::Verifier,
+            pos: usize,
+        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+            use self::flatbuffers::Verifiable;
+            v.visit_table(pos)?
+                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
+                    "instance_id",
+                    Self::VT_INSTANCE_ID,
+                    true,
+                )?
+                .finish();
+            Ok(())
+        }
+    }
+    pub struct NotFoundArgs<'a> {
+        pub instance_id: Option<flatbuffers::WIPOffset<super::common::ContractInstanceId<'a>>>,
+    }
+    impl<'a> Default for NotFoundArgs<'a> {
+        #[inline]
+        fn default() -> Self {
+            NotFoundArgs {
+                instance_id: None, // required field
+            }
+        }
+    }
+
+    pub struct NotFoundBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
+        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    }
+    impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> NotFoundBuilder<'a, 'b, A> {
+        #[inline]
+        pub fn add_instance_id(
+            &mut self,
+            instance_id: flatbuffers::WIPOffset<super::common::ContractInstanceId<'b>>,
+        ) {
+            self.fbb_
+                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractInstanceId>>(
+                    NotFound::VT_INSTANCE_ID,
+                    instance_id,
+                );
+        }
+        #[inline]
+        pub fn new(
+            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+        ) -> NotFoundBuilder<'a, 'b, A> {
+            let start = _fbb.start_table();
+            NotFoundBuilder {
+                fbb_: _fbb,
+                start_: start,
+            }
+        }
+        #[inline]
+        pub fn finish(self) -> flatbuffers::WIPOffset<NotFound<'a>> {
+            let o = self.fbb_.end_table(self.start_);
+            self.fbb_
+                .required(o, NotFound::VT_INSTANCE_ID, "instance_id");
+            flatbuffers::WIPOffset::new(o.value())
+        }
+    }
+
+    impl core::fmt::Debug for NotFound<'_> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            let mut ds = f.debug_struct("NotFound");
+            ds.field("instance_id", &self.instance_id());
+            ds.finish()
+        }
+    }
     pub enum ContractResponseOffset {}
     #[derive(Copy, Clone, PartialEq)]
 
@@ -1122,6 +1254,20 @@ pub mod host_response {
                 None
             }
         }
+
+        #[inline]
+        #[allow(non_snake_case)]
+        pub fn contract_response_as_not_found(&self) -> Option<NotFound<'a>> {
+            if self.contract_response_type() == ContractResponseType::NotFound {
+                let u = self.contract_response();
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                Some(unsafe { NotFound::init_from_table(u) })
+            } else {
+                None
+            }
+        }
     }
 
     impl flatbuffers::Verifiable for ContractResponse<'_> {
@@ -1138,6 +1284,7 @@ pub mod host_response {
           ContractResponseType::PutResponse => v.verify_union_variant::<flatbuffers::ForwardsUOffset<PutResponse>>("ContractResponseType::PutResponse", pos),
           ContractResponseType::UpdateNotification => v.verify_union_variant::<flatbuffers::ForwardsUOffset<UpdateNotification>>("ContractResponseType::UpdateNotification", pos),
           ContractResponseType::UpdateResponse => v.verify_union_variant::<flatbuffers::ForwardsUOffset<UpdateResponse>>("ContractResponseType::UpdateResponse", pos),
+          ContractResponseType::NotFound => v.verify_union_variant::<flatbuffers::ForwardsUOffset<NotFound>>("ContractResponseType::NotFound", pos),
           _ => Ok(()),
         }
      })?
@@ -1249,6 +1396,16 @@ pub mod host_response {
                         )
                     }
                 }
+                ContractResponseType::NotFound => {
+                    if let Some(x) = self.contract_response_as_not_found() {
+                        ds.field("contract_response", &x)
+                    } else {
+                        ds.field(
+                            "contract_response",
+                            &"InvalidFlatbuffer: Union discriminant does not match value.",
+                        )
+                    }
+                }
                 _ => {
                     let x: Option<()> = None;
                     ds.field("contract_response", &x)
@@ -3338,7 +3495,7 @@ pub mod host_response {
     /// `root_as_host_response_unchecked`.
     pub fn root_as_host_response(
         buf: &[u8],
-    ) -> Result<HostResponse<'_>, flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<HostResponse, flatbuffers::InvalidFlatbuffer> {
         flatbuffers::root::<HostResponse>(buf)
     }
     #[inline]
@@ -3350,7 +3507,7 @@ pub mod host_response {
     /// `size_prefixed_root_as_host_response_unchecked`.
     pub fn size_prefixed_root_as_host_response(
         buf: &[u8],
-    ) -> Result<HostResponse<'_>, flatbuffers::InvalidFlatbuffer> {
+    ) -> Result<HostResponse, flatbuffers::InvalidFlatbuffer> {
         flatbuffers::size_prefixed_root::<HostResponse>(buf)
     }
     #[inline]
@@ -3383,14 +3540,14 @@ pub mod host_response {
     /// Assumes, without verification, that a buffer of bytes contains a HostResponse and returns it.
     /// # Safety
     /// Callers must trust the given bytes do indeed contain a valid `HostResponse`.
-    pub unsafe fn root_as_host_response_unchecked(buf: &[u8]) -> HostResponse<'_> {
+    pub unsafe fn root_as_host_response_unchecked(buf: &[u8]) -> HostResponse {
         flatbuffers::root_unchecked::<HostResponse>(buf)
     }
     #[inline]
     /// Assumes, without verification, that a buffer of bytes contains a size prefixed HostResponse and returns it.
     /// # Safety
     /// Callers must trust the given bytes do indeed contain a valid size prefixed `HostResponse`.
-    pub unsafe fn size_prefixed_root_as_host_response_unchecked(buf: &[u8]) -> HostResponse<'_> {
+    pub unsafe fn size_prefixed_root_as_host_response_unchecked(buf: &[u8]) -> HostResponse {
         flatbuffers::size_prefixed_root_unchecked::<HostResponse>(buf)
     }
     #[inline]