diff --git a/rust-macros/src/delegate_impl.rs b/rust-macros/src/delegate_impl.rs
index 080501e..81dd113 100644
--- a/rust-macros/src/delegate_impl.rs
+++ b/rust-macros/src/delegate_impl.rs
@@ -28,7 +28,7 @@ impl ImplStruct {
         quote! {
             #[no_mangle]
             #[cfg(feature = "freenet-main-delegate")]
-            pub extern "C" fn process(parameters: i64, attested: i64, inbound: i64) -> #ret {
+            pub extern "C" fn process(parameters: i64, origin: i64, inbound: i64) -> #ret {
                 #set_logger
                 let parameters = unsafe {
                     let param_buf = &*(parameters as *const ::freenet_stdlib::memory::buf::BufferBuilder);
@@ -38,16 +38,19 @@ impl ImplStruct {
                     );
                     Parameters::from(bytes)
                 };
-                let attested = unsafe {
-                    let attested_buf = &*(attested as *const ::freenet_stdlib::memory::buf::BufferBuilder);
+                let origin: Option<::freenet_stdlib::prelude::MessageOrigin> = unsafe {
+                    let origin_buf = &*(origin as *const ::freenet_stdlib::memory::buf::BufferBuilder);
                     let bytes = &*std::ptr::slice_from_raw_parts(
-                        attested_buf.start(),
-                        attested_buf.bytes_written(),
+                        origin_buf.start(),
+                        origin_buf.bytes_written(),
                     );
                     if bytes.is_empty() {
                         None
                     } else {
-                        Some(bytes)
+                        match ::freenet_stdlib::prelude::bincode::deserialize(bytes) {
+                            Ok(v) => Some(v),
+                            Err(_) => None,
+                        }
                     }
                 };
                 let inbound = unsafe {
@@ -70,7 +73,7 @@ impl ImplStruct {
                 let result = <#type_name as ::freenet_stdlib::prelude::DelegateInterface>::process(
                     &mut ctx,
                     parameters,
-                    attested,
+                    origin,
                     inbound
                 );
                 ::freenet_stdlib::prelude::DelegateInterfaceResult::from(result).into_raw()
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index 37f59a1..847bbe4 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "freenet-stdlib"
-version = "0.2.2"
+version = "0.3.0"
 edition = "2021"
 rust-version = "1.80"
 publish = true
diff --git a/rust/src/client_api/client_events.rs b/rust/src/client_api/client_events.rs
index c54793e..bacec84 100644
--- a/rust/src/client_api/client_events.rs
+++ b/rust/src/client_api/client_events.rs
@@ -1443,19 +1443,11 @@ impl HostResponse {
                 let mut messages: Vec<WIPOffset<FbsOutboundDelegateMsg>> = Vec::new();
                 values.iter().for_each(|msg| match msg {
                     OutboundDelegateMsg::ApplicationMessage(app) => {
-                        let instance_data = builder.create_vector(key.bytes());
-                        let instance_offset = FbsContractInstanceId::create(
-                            &mut builder,
-                            &ContractInstanceIdArgs {
-                                data: Some(instance_data),
-                            },
-                        );
                         let payload_data = builder.create_vector(&app.payload);
                         let delegate_context_data = builder.create_vector(app.context.as_ref());
                         let app_offset = FbsApplicationMessage::create(
                             &mut builder,
                             &ApplicationMessageArgs {
-                                app: Some(instance_offset),
                                 payload: Some(payload_data),
                                 context: Some(delegate_context_data),
                                 processed: app.processed,
diff --git a/rust/src/delegate_interface.rs b/rust/src/delegate_interface.rs
index 21c51d7..aadc626 100644
--- a/rust/src/delegate_interface.rs
+++ b/rust/src/delegate_interface.rs
@@ -20,7 +20,7 @@ use crate::common_generated::common::SecretsId as FbsSecretsId;
 
 use crate::client_api::{TryFromFbs, WsApiError};
 use crate::contract_interface::{RelatedContracts, UpdateData};
-use crate::prelude::{ContractInstanceId, WrappedState, CONTRACT_KEY_SIZE};
+use crate::prelude::{ContractInstanceId, WrappedState};
 use crate::versioning::ContractContainer;
 use crate::{code_hash::CodeHash, prelude::Parameters};
 
@@ -363,6 +363,18 @@ impl<'a> TryFromFbs<&FbsSecretsId<'a>> for SecretsId {
     }
 }
 
+/// Identifies where an inbound application message originated from.
+///
+/// When a web app sends a message to a delegate through the WebSocket API with
+/// an authentication token, the runtime resolves the token to the originating
+/// contract and wraps it in `MessageOrigin::WebApp`. Delegates receive this as
+/// the `origin` parameter of [`DelegateInterface::process`].
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum MessageOrigin {
+    /// The message was sent by a web application backed by the given contract.
+    WebApp(ContractInstanceId),
+}
+
 /// A Delegate is a webassembly code designed to act as an agent for the user on
 /// Freenet. Delegates can:
 ///
@@ -391,7 +403,7 @@ impl<'a> TryFromFbs<&FbsSecretsId<'a>> for SecretsId {
 ///     fn process(
 ///         ctx: &mut DelegateCtx,
 ///         _params: Parameters<'static>,
-///         _attested: Option<&'static [u8]>,
+///         _origin: Option<MessageOrigin>,
 ///         message: InboundDelegateMsg,
 ///     ) -> Result<Vec<OutboundDelegateMsg>, DelegateError> {
 ///         // Access secrets synchronously - no round-trip needed!
@@ -415,13 +427,13 @@ pub trait DelegateInterface {
     ///   - **Context** (temporary): `read()`, `write()`, `len()`, `clear()` - state within a batch
     ///   - **Secrets** (persistent): `get_secret()`, `set_secret()`, `has_secret()`, `remove_secret()`
     /// - `parameters`: The delegate's initialization parameters.
-    /// - `attested`: An optional identifier for the client of this function. Usually
-    ///   will be a [`ContractInstanceId`].
+    /// - `origin`: An optional [`MessageOrigin`] identifying where the message came from.
+    ///   For messages sent by web applications, this is `MessageOrigin::WebApp(contract_id)`.
     /// - `message`: The inbound message to process.
     fn process(
         ctx: &mut crate::delegate_host::DelegateCtx,
         parameters: Parameters<'static>,
-        attested: Option<&'static [u8]>,
+        origin: Option<MessageOrigin>,
         message: InboundDelegateMsg,
     ) -> Result<Vec<OutboundDelegateMsg>, DelegateError>;
 }
@@ -555,11 +567,7 @@ impl<'a> TryFromFbs<&FbsInboundDelegateMsg<'a>> for InboundDelegateMsg<'a> {
         match msg.inbound_type() {
             InboundDelegateMsgType::common_ApplicationMessage => {
                 let app_msg = msg.inbound_as_common_application_message().unwrap();
-                let mut instance_key_bytes = [0; CONTRACT_KEY_SIZE];
-                instance_key_bytes
-                    .copy_from_slice(app_msg.app().data().bytes().to_vec().as_slice());
                 let app_msg = ApplicationMessage {
-                    app: ContractInstanceId::new(instance_key_bytes),
                     payload: app_msg.payload().bytes().to_vec(),
                     context: DelegateContext::new(app_msg.context().bytes().to_vec()),
                     processed: app_msg.processed(),
@@ -585,16 +593,14 @@ impl<'a> TryFromFbs<&FbsInboundDelegateMsg<'a>> for InboundDelegateMsg<'a> {
 #[non_exhaustive]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ApplicationMessage {
-    pub app: ContractInstanceId,
     pub payload: Vec<u8>,
     pub context: DelegateContext,
     pub processed: bool,
 }
 
 impl ApplicationMessage {
-    pub fn new(app: ContractInstanceId, payload: Vec<u8>) -> Self {
+    pub fn new(payload: Vec<u8>) -> Self {
         Self {
-            app,
             payload,
             context: DelegateContext::default(),
             processed: false,
diff --git a/rust/src/generated/client_request_generated.rs b/rust/src/generated/client_request_generated.rs
index e25782b..045569e 100644
--- a/rust/src/generated/client_request_generated.rs
+++ b/rust/src/generated/client_request_generated.rs
@@ -1,23 +1,13 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-
 // @generated
+extern crate alloc;
 
 use crate::common_generated::*;
-use core::cmp::Ordering;
-use core::mem;
-
-extern crate flatbuffers;
-use self::flatbuffers::{EndianScalar, Follow};
 
 #[allow(unused_imports, dead_code)]
 pub mod client_request {
 
     use crate::common_generated::*;
-    use core::cmp::Ordering;
-    use core::mem;
-
-    extern crate flatbuffers;
-    use self::flatbuffers::{EndianScalar, Follow};
 
     #[deprecated(
         since = "2.0.0",
@@ -57,8 +47,8 @@ pub mod client_request {
             }
         }
     }
-    impl core::fmt::Debug for DelegateType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DelegateType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -66,24 +56,24 @@ pub mod client_request {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for DelegateType {
+    impl<'a> ::flatbuffers::Follow<'a> for DelegateType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for DelegateType {
+    impl ::flatbuffers::Push for DelegateType {
         type Output = DelegateType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for DelegateType {
+    impl ::flatbuffers::EndianScalar for DelegateType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -97,18 +87,17 @@ pub mod client_request {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for DelegateType {
+    impl<'a> ::flatbuffers::Verifiable for DelegateType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for DelegateType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for DelegateType {}
     pub struct DelegateTypeUnionTableOffset {}
 
     #[deprecated(
@@ -166,8 +155,8 @@ pub mod client_request {
             }
         }
     }
-    impl core::fmt::Debug for ContractRequestType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContractRequestType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -175,24 +164,24 @@ pub mod client_request {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for ContractRequestType {
+    impl<'a> ::flatbuffers::Follow<'a> for ContractRequestType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for ContractRequestType {
+    impl ::flatbuffers::Push for ContractRequestType {
         type Output = ContractRequestType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for ContractRequestType {
+    impl ::flatbuffers::EndianScalar for ContractRequestType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -206,18 +195,17 @@ pub mod client_request {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for ContractRequestType {
+    impl<'a> ::flatbuffers::Verifiable for ContractRequestType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for ContractRequestType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for ContractRequestType {}
     pub struct ContractRequestTypeUnionTableOffset {}
 
     #[deprecated(
@@ -267,8 +255,8 @@ pub mod client_request {
             }
         }
     }
-    impl core::fmt::Debug for InboundDelegateMsgType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for InboundDelegateMsgType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -276,24 +264,24 @@ pub mod client_request {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for InboundDelegateMsgType {
+    impl<'a> ::flatbuffers::Follow<'a> for InboundDelegateMsgType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for InboundDelegateMsgType {
+    impl ::flatbuffers::Push for InboundDelegateMsgType {
         type Output = InboundDelegateMsgType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for InboundDelegateMsgType {
+    impl ::flatbuffers::EndianScalar for InboundDelegateMsgType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -307,18 +295,17 @@ pub mod client_request {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for InboundDelegateMsgType {
+    impl<'a> ::flatbuffers::Verifiable for InboundDelegateMsgType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for InboundDelegateMsgType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for InboundDelegateMsgType {}
     pub struct InboundDelegateMsgTypeUnionTableOffset {}
 
     #[deprecated(
@@ -372,8 +359,8 @@ pub mod client_request {
             }
         }
     }
-    impl core::fmt::Debug for DelegateRequestType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DelegateRequestType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -381,24 +368,24 @@ pub mod client_request {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for DelegateRequestType {
+    impl<'a> ::flatbuffers::Follow<'a> for DelegateRequestType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for DelegateRequestType {
+    impl ::flatbuffers::Push for DelegateRequestType {
         type Output = DelegateRequestType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for DelegateRequestType {
+    impl ::flatbuffers::EndianScalar for DelegateRequestType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -412,18 +399,17 @@ pub mod client_request {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for DelegateRequestType {
+    impl<'a> ::flatbuffers::Verifiable for DelegateRequestType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for DelegateRequestType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for DelegateRequestType {}
     pub struct DelegateRequestTypeUnionTableOffset {}
 
     #[deprecated(
@@ -485,8 +471,8 @@ pub mod client_request {
             }
         }
     }
-    impl core::fmt::Debug for ClientRequestType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ClientRequestType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -494,24 +480,24 @@ pub mod client_request {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for ClientRequestType {
+    impl<'a> ::flatbuffers::Follow<'a> for ClientRequestType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for ClientRequestType {
+    impl ::flatbuffers::Push for ClientRequestType {
         type Output = ClientRequestType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for ClientRequestType {
+    impl ::flatbuffers::EndianScalar for ClientRequestType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -525,43 +511,42 @@ pub mod client_request {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for ClientRequestType {
+    impl<'a> ::flatbuffers::Verifiable for ClientRequestType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for ClientRequestType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for ClientRequestType {}
     pub struct ClientRequestTypeUnionTableOffset {}
 
     pub enum DelegateCodeOffset {}
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct DelegateCode<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for DelegateCode<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for DelegateCode<'a> {
         type Inner = DelegateCode<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> DelegateCode<'a> {
-        pub const VT_DATA: flatbuffers::VOffsetT = 4;
-        pub const VT_CODE_HASH: flatbuffers::VOffsetT = 6;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CODE_HASH: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             DelegateCode { _tab: table }
         }
         #[allow(unused_mut)]
@@ -569,11 +554,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args DelegateCodeArgs<'args>,
-        ) -> flatbuffers::WIPOffset<DelegateCode<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<DelegateCode<'bldr>> {
             let mut builder = DelegateCodeBuilder::new(_fbb);
             if let Some(x) = args.code_hash {
                 builder.add_code_hash(x);
@@ -585,13 +570,13 @@ pub mod client_request {
         }
 
         #[inline]
-        pub fn data(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         DelegateCode::VT_DATA,
                         None,
                     )
@@ -599,13 +584,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn code_hash(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn code_hash(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         DelegateCode::VT_CODE_HASH,
                         None,
                     )
@@ -614,20 +599,19 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for DelegateCode<'_> {
+    impl ::flatbuffers::Verifiable for DelegateCode<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "data",
                     Self::VT_DATA,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "code_hash",
                     Self::VT_CODE_HASH,
                     true,
@@ -637,8 +621,8 @@ pub mod client_request {
         }
     }
     pub struct DelegateCodeArgs<'a> {
-        pub data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub code_hash: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub code_hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for DelegateCodeArgs<'a> {
         #[inline]
@@ -650,29 +634,29 @@ pub mod client_request {
         }
     }
 
-    pub struct DelegateCodeBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct DelegateCodeBuilder<'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> DelegateCodeBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateCodeBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(DelegateCode::VT_DATA, data);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(DelegateCode::VT_DATA, data);
         }
         #[inline]
         pub fn add_code_hash(
             &mut self,
-            code_hash: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            code_hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 DelegateCode::VT_CODE_HASH,
                 code_hash,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> DelegateCodeBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             DelegateCodeBuilder {
@@ -681,17 +665,17 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<DelegateCode<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<DelegateCode<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, DelegateCode::VT_DATA, "data");
             self.fbb_
                 .required(o, DelegateCode::VT_CODE_HASH, "code_hash");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for DelegateCode<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DelegateCode<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("DelegateCode");
             ds.field("data", &self.data());
             ds.field("code_hash", &self.code_hash());
@@ -702,25 +686,25 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct DelegateKey<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for DelegateKey<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for DelegateKey<'a> {
         type Inner = DelegateKey<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> DelegateKey<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_CODE_HASH: flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CODE_HASH: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             DelegateKey { _tab: table }
         }
         #[allow(unused_mut)]
@@ -728,11 +712,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args DelegateKeyArgs<'args>,
-        ) -> flatbuffers::WIPOffset<DelegateKey<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<DelegateKey<'bldr>> {
             let mut builder = DelegateKeyBuilder::new(_fbb);
             if let Some(x) = args.code_hash {
                 builder.add_code_hash(x);
@@ -744,13 +728,13 @@ pub mod client_request {
         }
 
         #[inline]
-        pub fn key(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn key(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         DelegateKey::VT_KEY,
                         None,
                     )
@@ -758,13 +742,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn code_hash(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn code_hash(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         DelegateKey::VT_CODE_HASH,
                         None,
                     )
@@ -773,20 +757,19 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for DelegateKey<'_> {
+    impl ::flatbuffers::Verifiable for DelegateKey<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "code_hash",
                     Self::VT_CODE_HASH,
                     true,
@@ -796,8 +779,8 @@ pub mod client_request {
         }
     }
     pub struct DelegateKeyArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub code_hash: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub key: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub code_hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for DelegateKeyArgs<'a> {
         #[inline]
@@ -809,29 +792,29 @@ pub mod client_request {
         }
     }
 
-    pub struct DelegateKeyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct DelegateKeyBuilder<'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> DelegateKeyBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateKeyBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(DelegateKey::VT_KEY, key);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(DelegateKey::VT_KEY, key);
         }
         #[inline]
         pub fn add_code_hash(
             &mut self,
-            code_hash: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            code_hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 DelegateKey::VT_CODE_HASH,
                 code_hash,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> DelegateKeyBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             DelegateKeyBuilder {
@@ -840,17 +823,17 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<DelegateKey<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<DelegateKey<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, DelegateKey::VT_KEY, "key");
             self.fbb_
                 .required(o, DelegateKey::VT_CODE_HASH, "code_hash");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for DelegateKey<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DelegateKey<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("DelegateKey");
             ds.field("key", &self.key());
             ds.field("code_hash", &self.code_hash());
@@ -861,24 +844,24 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct DelegateContext<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for DelegateContext<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for DelegateContext<'a> {
         type Inner = DelegateContext<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> DelegateContext<'a> {
-        pub const VT_DATA: flatbuffers::VOffsetT = 4;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             DelegateContext { _tab: table }
         }
         #[allow(unused_mut)]
@@ -886,11 +869,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args DelegateContextArgs<'args>,
-        ) -> flatbuffers::WIPOffset<DelegateContext<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<DelegateContext<'bldr>> {
             let mut builder = DelegateContextBuilder::new(_fbb);
             if let Some(x) = args.data {
                 builder.add_data(x);
@@ -899,13 +882,13 @@ pub mod client_request {
         }
 
         #[inline]
-        pub fn data(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         DelegateContext::VT_DATA,
                         None,
                     )
@@ -914,15 +897,14 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for DelegateContext<'_> {
+    impl ::flatbuffers::Verifiable for DelegateContext<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "data",
                     Self::VT_DATA,
                     true,
@@ -932,7 +914,7 @@ pub mod client_request {
         }
     }
     pub struct DelegateContextArgs<'a> {
-        pub data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for DelegateContextArgs<'a> {
         #[inline]
@@ -943,19 +925,19 @@ pub mod client_request {
         }
     }
 
-    pub struct DelegateContextBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct DelegateContextBuilder<'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> DelegateContextBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateContextBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(DelegateContext::VT_DATA, data);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(DelegateContext::VT_DATA, data);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> DelegateContextBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             DelegateContextBuilder {
@@ -964,15 +946,15 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<DelegateContext<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<DelegateContext<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, DelegateContext::VT_DATA, "data");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for DelegateContext<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DelegateContext<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("DelegateContext");
             ds.field("data", &self.data());
             ds.finish()
@@ -982,26 +964,26 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct WasmDelegateV1<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for WasmDelegateV1<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for WasmDelegateV1<'a> {
         type Inner = WasmDelegateV1<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> WasmDelegateV1<'a> {
-        pub const VT_PARAMETERS: flatbuffers::VOffsetT = 4;
-        pub const VT_DATA: flatbuffers::VOffsetT = 6;
-        pub const VT_KEY: flatbuffers::VOffsetT = 8;
+        pub const VT_PARAMETERS: ::flatbuffers::VOffsetT = 4;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             WasmDelegateV1 { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1009,11 +991,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args WasmDelegateV1Args<'args>,
-        ) -> flatbuffers::WIPOffset<WasmDelegateV1<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<WasmDelegateV1<'bldr>> {
             let mut builder = WasmDelegateV1Builder::new(_fbb);
             if let Some(x) = args.key {
                 builder.add_key(x);
@@ -1028,13 +1010,13 @@ pub mod client_request {
         }
 
         #[inline]
-        pub fn parameters(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn parameters(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         WasmDelegateV1::VT_PARAMETERS,
                         None,
                     )
@@ -1048,7 +1030,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<DelegateCode>>(
+                    .get::<::flatbuffers::ForwardsUOffset<DelegateCode>>(
                         WasmDelegateV1::VT_DATA,
                         None,
                     )
@@ -1062,31 +1044,33 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<DelegateKey>>(WasmDelegateV1::VT_KEY, None)
+                    .get::<::flatbuffers::ForwardsUOffset<DelegateKey>>(
+                        WasmDelegateV1::VT_KEY,
+                        None,
+                    )
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for WasmDelegateV1<'_> {
+    impl ::flatbuffers::Verifiable for WasmDelegateV1<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "parameters",
                     Self::VT_PARAMETERS,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<DelegateCode>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<DelegateCode>>(
                     "data",
                     Self::VT_DATA,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<DelegateKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<DelegateKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
@@ -1096,9 +1080,9 @@ pub mod client_request {
         }
     }
     pub struct WasmDelegateV1Args<'a> {
-        pub parameters: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub data: Option<flatbuffers::WIPOffset<DelegateCode<'a>>>,
-        pub key: Option<flatbuffers::WIPOffset<DelegateKey<'a>>>,
+        pub parameters: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub data: Option<::flatbuffers::WIPOffset<DelegateCode<'a>>>,
+        pub key: Option<::flatbuffers::WIPOffset<DelegateKey<'a>>>,
     }
     impl<'a> Default for WasmDelegateV1Args<'a> {
         #[inline]
@@ -1111,40 +1095,40 @@ pub mod client_request {
         }
     }
 
-    pub struct WasmDelegateV1Builder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct WasmDelegateV1Builder<'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> WasmDelegateV1Builder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WasmDelegateV1Builder<'a, 'b, A> {
         #[inline]
         pub fn add_parameters(
             &mut self,
-            parameters: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            parameters: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 WasmDelegateV1::VT_PARAMETERS,
                 parameters,
             );
         }
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<DelegateCode<'b>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<DelegateCode<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<DelegateCode>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<DelegateCode>>(
                     WasmDelegateV1::VT_DATA,
                     data,
                 );
         }
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<DelegateKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<DelegateKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<DelegateKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<DelegateKey>>(
                     WasmDelegateV1::VT_KEY,
                     key,
                 );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> WasmDelegateV1Builder<'a, 'b, A> {
             let start = _fbb.start_table();
             WasmDelegateV1Builder {
@@ -1153,18 +1137,18 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<WasmDelegateV1<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<WasmDelegateV1<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, WasmDelegateV1::VT_PARAMETERS, "parameters");
             self.fbb_.required(o, WasmDelegateV1::VT_DATA, "data");
             self.fbb_.required(o, WasmDelegateV1::VT_KEY, "key");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for WasmDelegateV1<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for WasmDelegateV1<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("WasmDelegateV1");
             ds.field("parameters", &self.parameters());
             ds.field("data", &self.data());
@@ -1176,25 +1160,25 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct DelegateContainer<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for DelegateContainer<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for DelegateContainer<'a> {
         type Inner = DelegateContainer<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> DelegateContainer<'a> {
-        pub const VT_DELEGATE_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_DELEGATE: flatbuffers::VOffsetT = 6;
+        pub const VT_DELEGATE_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_DELEGATE: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             DelegateContainer { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1202,11 +1186,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args DelegateContainerArgs,
-        ) -> flatbuffers::WIPOffset<DelegateContainer<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<DelegateContainer<'bldr>> {
             let mut builder = DelegateContainerBuilder::new(_fbb);
             if let Some(x) = args.delegate {
                 builder.add_delegate(x);
@@ -1230,13 +1214,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn delegate(&self) -> flatbuffers::Table<'a> {
+        pub fn delegate(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         DelegateContainer::VT_DELEGATE,
                         None,
                     )
@@ -1258,13 +1242,12 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for DelegateContainer<'_> {
+    impl ::flatbuffers::Verifiable for DelegateContainer<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
                 .visit_union::<DelegateType, _>(
                     "delegate_type",
@@ -1274,7 +1257,7 @@ pub mod client_request {
                     true,
                     |key, v, pos| match key {
                         DelegateType::WasmDelegateV1 => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<WasmDelegateV1>>(
+                            .verify_union_variant::<::flatbuffers::ForwardsUOffset<WasmDelegateV1>>(
                                 "DelegateType::WasmDelegateV1",
                                 pos,
                             ),
@@ -1287,7 +1270,7 @@ pub mod client_request {
     }
     pub struct DelegateContainerArgs {
         pub delegate_type: DelegateType,
-        pub delegate: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub delegate: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for DelegateContainerArgs {
         #[inline]
@@ -1299,11 +1282,11 @@ pub mod client_request {
         }
     }
 
-    pub struct DelegateContainerBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct DelegateContainerBuilder<'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> DelegateContainerBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateContainerBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_delegate_type(&mut self, delegate_type: DelegateType) {
             self.fbb_.push_slot::<DelegateType>(
@@ -1315,16 +1298,16 @@ pub mod client_request {
         #[inline]
         pub fn add_delegate(
             &mut self,
-            delegate: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            delegate: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 DelegateContainer::VT_DELEGATE,
                 delegate,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> DelegateContainerBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             DelegateContainerBuilder {
@@ -1333,16 +1316,16 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<DelegateContainer<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<DelegateContainer<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, DelegateContainer::VT_DELEGATE, "delegate");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for DelegateContainer<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DelegateContainer<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("DelegateContainer");
             ds.field("delegate_type", &self.delegate_type());
             match self.delegate_type() {
@@ -1368,25 +1351,25 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct RelatedContract<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for RelatedContract<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for RelatedContract<'a> {
         type Inner = RelatedContract<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> RelatedContract<'a> {
-        pub const VT_INSTANCE_ID: flatbuffers::VOffsetT = 4;
-        pub const VT_STATE: flatbuffers::VOffsetT = 6;
+        pub const VT_INSTANCE_ID: ::flatbuffers::VOffsetT = 4;
+        pub const VT_STATE: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             RelatedContract { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1394,11 +1377,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args RelatedContractArgs<'args>,
-        ) -> flatbuffers::WIPOffset<RelatedContract<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<RelatedContract<'bldr>> {
             let mut builder = RelatedContractBuilder::new(_fbb);
             if let Some(x) = args.state {
                 builder.add_state(x);
@@ -1416,7 +1399,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
                         RelatedContract::VT_INSTANCE_ID,
                         None,
                     )
@@ -1424,13 +1407,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn state(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         RelatedContract::VT_STATE,
                         None,
                     )
@@ -1439,20 +1422,19 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for RelatedContract<'_> {
+    impl ::flatbuffers::Verifiable for RelatedContract<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
                     "instance_id",
                     Self::VT_INSTANCE_ID,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "state",
                     Self::VT_STATE,
                     true,
@@ -1462,8 +1444,8 @@ pub mod client_request {
         }
     }
     pub struct RelatedContractArgs<'a> {
-        pub instance_id: Option<flatbuffers::WIPOffset<super::common::ContractInstanceId<'a>>>,
-        pub state: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub instance_id: Option<::flatbuffers::WIPOffset<super::common::ContractInstanceId<'a>>>,
+        pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for RelatedContractArgs<'a> {
         #[inline]
@@ -1475,30 +1457,33 @@ pub mod client_request {
         }
     }
 
-    pub struct RelatedContractBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct RelatedContractBuilder<'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> RelatedContractBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedContractBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_instance_id(
             &mut self,
-            instance_id: flatbuffers::WIPOffset<super::common::ContractInstanceId<'b>>,
+            instance_id: ::flatbuffers::WIPOffset<super::common::ContractInstanceId<'b>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractInstanceId>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractInstanceId>>(
                     RelatedContract::VT_INSTANCE_ID,
                     instance_id,
                 );
         }
         #[inline]
-        pub fn add_state(&mut self, state: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_state(
+            &mut self,
+            state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(RelatedContract::VT_STATE, state);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(RelatedContract::VT_STATE, state);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> RelatedContractBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             RelatedContractBuilder {
@@ -1507,17 +1492,17 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<RelatedContract<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<RelatedContract<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, RelatedContract::VT_INSTANCE_ID, "instance_id");
             self.fbb_.required(o, RelatedContract::VT_STATE, "state");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for RelatedContract<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for RelatedContract<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("RelatedContract");
             ds.field("instance_id", &self.instance_id());
             ds.field("state", &self.state());
@@ -1528,24 +1513,24 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct RelatedContracts<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for RelatedContracts<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for RelatedContracts<'a> {
         type Inner = RelatedContracts<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> RelatedContracts<'a> {
-        pub const VT_CONTRACTS: flatbuffers::VOffsetT = 4;
+        pub const VT_CONTRACTS: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             RelatedContracts { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1553,11 +1538,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args RelatedContractsArgs<'args>,
-        ) -> flatbuffers::WIPOffset<RelatedContracts<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<RelatedContracts<'bldr>> {
             let mut builder = RelatedContractsBuilder::new(_fbb);
             if let Some(x) = args.contracts {
                 builder.add_contracts(x);
@@ -1568,30 +1553,30 @@ pub mod client_request {
         #[inline]
         pub fn contracts(
             &self,
-        ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RelatedContract<'a>>> {
+        ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<RelatedContract<'a>>>
+        {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<
-                        flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RelatedContract>>,
+                    .get::<::flatbuffers::ForwardsUOffset<
+                        ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<RelatedContract>>,
                     >>(RelatedContracts::VT_CONTRACTS, None)
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for RelatedContracts<'_> {
+    impl ::flatbuffers::Verifiable for RelatedContracts<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<
-                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<RelatedContract>>,
+                .visit_field::<::flatbuffers::ForwardsUOffset<
+                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<RelatedContract>>,
                 >>("contracts", Self::VT_CONTRACTS, true)?
                 .finish();
             Ok(())
@@ -1599,8 +1584,8 @@ pub mod client_request {
     }
     pub struct RelatedContractsArgs<'a> {
         pub contracts: Option<
-            flatbuffers::WIPOffset<
-                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RelatedContract<'a>>>,
+            ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<RelatedContract<'a>>>,
             >,
         >,
     }
@@ -1613,26 +1598,26 @@ pub mod client_request {
         }
     }
 
-    pub struct RelatedContractsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct RelatedContractsBuilder<'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> RelatedContractsBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedContractsBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_contracts(
             &mut self,
-            contracts: flatbuffers::WIPOffset<
-                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<RelatedContract<'b>>>,
+            contracts: ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<RelatedContract<'b>>>,
             >,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 RelatedContracts::VT_CONTRACTS,
                 contracts,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> RelatedContractsBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             RelatedContractsBuilder {
@@ -1641,16 +1626,16 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<RelatedContracts<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<RelatedContracts<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, RelatedContracts::VT_CONTRACTS, "contracts");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for RelatedContracts<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for RelatedContracts<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("RelatedContracts");
             ds.field("contracts", &self.contracts());
             ds.finish()
@@ -1660,28 +1645,28 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct Put<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for Put<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for Put<'a> {
         type Inner = Put<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> Put<'a> {
-        pub const VT_CONTAINER: flatbuffers::VOffsetT = 4;
-        pub const VT_WRAPPED_STATE: flatbuffers::VOffsetT = 6;
-        pub const VT_RELATED_CONTRACTS: flatbuffers::VOffsetT = 8;
-        pub const VT_SUBSCRIBE: flatbuffers::VOffsetT = 10;
-        pub const VT_BLOCKING_SUBSCRIBE: flatbuffers::VOffsetT = 12;
+        pub const VT_CONTAINER: ::flatbuffers::VOffsetT = 4;
+        pub const VT_WRAPPED_STATE: ::flatbuffers::VOffsetT = 6;
+        pub const VT_RELATED_CONTRACTS: ::flatbuffers::VOffsetT = 8;
+        pub const VT_SUBSCRIBE: ::flatbuffers::VOffsetT = 10;
+        pub const VT_BLOCKING_SUBSCRIBE: ::flatbuffers::VOffsetT = 12;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             Put { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1689,11 +1674,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args PutArgs<'args>,
-        ) -> flatbuffers::WIPOffset<Put<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<Put<'bldr>> {
             let mut builder = PutBuilder::new(_fbb);
             if let Some(x) = args.related_contracts {
                 builder.add_related_contracts(x);
@@ -1716,7 +1701,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractContainer>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractContainer>>(
                         Put::VT_CONTAINER,
                         None,
                     )
@@ -1724,13 +1709,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn wrapped_state(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn wrapped_state(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         Put::VT_WRAPPED_STATE,
                         None,
                     )
@@ -1744,7 +1729,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<RelatedContracts>>(
+                    .get::<::flatbuffers::ForwardsUOffset<RelatedContracts>>(
                         Put::VT_RELATED_CONTRACTS,
                         None,
                     )
@@ -1775,25 +1760,24 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for Put<'_> {
+    impl ::flatbuffers::Verifiable for Put<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractContainer>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractContainer>>(
                     "container",
                     Self::VT_CONTAINER,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "wrapped_state",
                     Self::VT_WRAPPED_STATE,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<RelatedContracts>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<RelatedContracts>>(
                     "related_contracts",
                     Self::VT_RELATED_CONTRACTS,
                     true,
@@ -1805,9 +1789,9 @@ pub mod client_request {
         }
     }
     pub struct PutArgs<'a> {
-        pub container: Option<flatbuffers::WIPOffset<super::common::ContractContainer<'a>>>,
-        pub wrapped_state: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub related_contracts: Option<flatbuffers::WIPOffset<RelatedContracts<'a>>>,
+        pub container: Option<::flatbuffers::WIPOffset<super::common::ContractContainer<'a>>>,
+        pub wrapped_state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub related_contracts: Option<::flatbuffers::WIPOffset<RelatedContracts<'a>>>,
         pub subscribe: bool,
         pub blocking_subscribe: bool,
     }
@@ -1824,18 +1808,18 @@ pub mod client_request {
         }
     }
 
-    pub struct PutBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct PutBuilder<'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> PutBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PutBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_container(
             &mut self,
-            container: flatbuffers::WIPOffset<super::common::ContractContainer<'b>>,
+            container: ::flatbuffers::WIPOffset<super::common::ContractContainer<'b>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractContainer>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractContainer>>(
                     Put::VT_CONTAINER,
                     container,
                 );
@@ -1843,9 +1827,9 @@ pub mod client_request {
         #[inline]
         pub fn add_wrapped_state(
             &mut self,
-            wrapped_state: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            wrapped_state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 Put::VT_WRAPPED_STATE,
                 wrapped_state,
             );
@@ -1853,10 +1837,10 @@ pub mod client_request {
         #[inline]
         pub fn add_related_contracts(
             &mut self,
-            related_contracts: flatbuffers::WIPOffset<RelatedContracts<'b>>,
+            related_contracts: ::flatbuffers::WIPOffset<RelatedContracts<'b>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<RelatedContracts>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<RelatedContracts>>(
                     Put::VT_RELATED_CONTRACTS,
                     related_contracts,
                 );
@@ -1872,7 +1856,7 @@ pub mod client_request {
                 .push_slot::<bool>(Put::VT_BLOCKING_SUBSCRIBE, blocking_subscribe, false);
         }
         #[inline]
-        pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PutBuilder<'a, 'b, A> {
+        pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PutBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             PutBuilder {
                 fbb_: _fbb,
@@ -1880,19 +1864,19 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<Put<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<Put<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, Put::VT_CONTAINER, "container");
             self.fbb_
                 .required(o, Put::VT_WRAPPED_STATE, "wrapped_state");
             self.fbb_
                 .required(o, Put::VT_RELATED_CONTRACTS, "related_contracts");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for Put<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for Put<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("Put");
             ds.field("container", &self.container());
             ds.field("wrapped_state", &self.wrapped_state());
@@ -1906,25 +1890,25 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct Update<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for Update<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for Update<'a> {
         type Inner = Update<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> Update<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_DATA: flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             Update { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1932,11 +1916,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args UpdateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<Update<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<Update<'bldr>> {
             let mut builder = UpdateBuilder::new(_fbb);
             if let Some(x) = args.data {
                 builder.add_data(x);
@@ -1954,7 +1938,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                         Update::VT_KEY,
                         None,
                     )
@@ -1968,7 +1952,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::UpdateData>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::UpdateData>>(
                         Update::VT_DATA,
                         None,
                     )
@@ -1977,20 +1961,19 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for Update<'_> {
+    impl ::flatbuffers::Verifiable for Update<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::UpdateData>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::UpdateData>>(
                     "data",
                     Self::VT_DATA,
                     true,
@@ -2000,8 +1983,8 @@ pub mod client_request {
         }
     }
     pub struct UpdateArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
-        pub data: Option<flatbuffers::WIPOffset<super::common::UpdateData<'a>>>,
+        pub key: Option<::flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
+        pub data: Option<::flatbuffers::WIPOffset<super::common::UpdateData<'a>>>,
     }
     impl<'a> Default for UpdateArgs<'a> {
         #[inline]
@@ -2013,30 +1996,30 @@ pub mod client_request {
         }
     }
 
-    pub struct UpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct UpdateBuilder<'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> UpdateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UpdateBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractKey>>(
                     Update::VT_KEY,
                     key,
                 );
         }
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<super::common::UpdateData<'b>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<super::common::UpdateData<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::UpdateData>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::UpdateData>>(
                     Update::VT_DATA,
                     data,
                 );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> UpdateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             UpdateBuilder {
@@ -2045,16 +2028,16 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<Update<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<Update<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, Update::VT_KEY, "key");
             self.fbb_.required(o, Update::VT_DATA, "data");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for Update<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for Update<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("Update");
             ds.field("key", &self.key());
             ds.field("data", &self.data());
@@ -2065,27 +2048,27 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct Get<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for Get<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for Get<'a> {
         type Inner = Get<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> Get<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_FETCH_CONTRACT: flatbuffers::VOffsetT = 6;
-        pub const VT_SUBSCRIBE: flatbuffers::VOffsetT = 8;
-        pub const VT_BLOCKING_SUBSCRIBE: flatbuffers::VOffsetT = 10;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_FETCH_CONTRACT: ::flatbuffers::VOffsetT = 6;
+        pub const VT_SUBSCRIBE: ::flatbuffers::VOffsetT = 8;
+        pub const VT_BLOCKING_SUBSCRIBE: ::flatbuffers::VOffsetT = 10;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             Get { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2093,11 +2076,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args GetArgs<'args>,
-        ) -> flatbuffers::WIPOffset<Get<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<Get<'bldr>> {
             let mut builder = GetBuilder::new(_fbb);
             if let Some(x) = args.key {
                 builder.add_key(x);
@@ -2115,7 +2098,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                         Get::VT_KEY,
                         None,
                     )
@@ -2157,15 +2140,14 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for Get<'_> {
+    impl ::flatbuffers::Verifiable for Get<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
@@ -2178,7 +2160,7 @@ pub mod client_request {
         }
     }
     pub struct GetArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
+        pub key: Option<::flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
         pub fetch_contract: bool,
         pub subscribe: bool,
         pub blocking_subscribe: bool,
@@ -2195,15 +2177,15 @@ pub mod client_request {
         }
     }
 
-    pub struct GetBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct GetBuilder<'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> GetBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GetBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractKey>>(
                     Get::VT_KEY,
                     key,
                 );
@@ -2224,7 +2206,7 @@ pub mod client_request {
                 .push_slot::<bool>(Get::VT_BLOCKING_SUBSCRIBE, blocking_subscribe, false);
         }
         #[inline]
-        pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> GetBuilder<'a, 'b, A> {
+        pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GetBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             GetBuilder {
                 fbb_: _fbb,
@@ -2232,15 +2214,15 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<Get<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<Get<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, Get::VT_KEY, "key");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for Get<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for Get<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("Get");
             ds.field("key", &self.key());
             ds.field("fetch_contract", &self.fetch_contract());
@@ -2253,25 +2235,25 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct Subscribe<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for Subscribe<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for Subscribe<'a> {
         type Inner = Subscribe<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> Subscribe<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_SUMMARY: flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_SUMMARY: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             Subscribe { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2279,11 +2261,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args SubscribeArgs<'args>,
-        ) -> flatbuffers::WIPOffset<Subscribe<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<Subscribe<'bldr>> {
             let mut builder = SubscribeBuilder::new(_fbb);
             if let Some(x) = args.summary {
                 builder.add_summary(x);
@@ -2301,7 +2283,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                         Subscribe::VT_KEY,
                         None,
                     )
@@ -2309,13 +2291,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn summary(&self) -> Option<flatbuffers::Vector<'a, u8>> {
+        pub fn summary(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         Subscribe::VT_SUMMARY,
                         None,
                     )
@@ -2323,20 +2305,19 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for Subscribe<'_> {
+    impl ::flatbuffers::Verifiable for Subscribe<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "summary",
                     Self::VT_SUMMARY,
                     false,
@@ -2346,8 +2327,8 @@ pub mod client_request {
         }
     }
     pub struct SubscribeArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
-        pub summary: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub key: Option<::flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
+        pub summary: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for SubscribeArgs<'a> {
         #[inline]
@@ -2359,15 +2340,15 @@ pub mod client_request {
         }
     }
 
-    pub struct SubscribeBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct SubscribeBuilder<'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> SubscribeBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SubscribeBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractKey>>(
                     Subscribe::VT_KEY,
                     key,
                 );
@@ -2375,14 +2356,14 @@ pub mod client_request {
         #[inline]
         pub fn add_summary(
             &mut self,
-            summary: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            summary: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(Subscribe::VT_SUMMARY, summary);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(Subscribe::VT_SUMMARY, summary);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> SubscribeBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             SubscribeBuilder {
@@ -2391,15 +2372,15 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<Subscribe<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<Subscribe<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, Subscribe::VT_KEY, "key");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for Subscribe<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for Subscribe<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("Subscribe");
             ds.field("key", &self.key());
             ds.field("summary", &self.summary());
@@ -2410,24 +2391,24 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ClientResponse<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ClientResponse<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ClientResponse<'a> {
         type Inner = ClientResponse<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ClientResponse<'a> {
-        pub const VT_DATA: flatbuffers::VOffsetT = 4;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ClientResponse { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2435,11 +2416,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ClientResponseArgs<'args>,
-        ) -> flatbuffers::WIPOffset<ClientResponse<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ClientResponse<'bldr>> {
             let mut builder = ClientResponseBuilder::new(_fbb);
             if let Some(x) = args.data {
                 builder.add_data(x);
@@ -2448,13 +2429,13 @@ pub mod client_request {
         }
 
         #[inline]
-        pub fn data(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ClientResponse::VT_DATA,
                         None,
                     )
@@ -2463,15 +2444,14 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for ClientResponse<'_> {
+    impl ::flatbuffers::Verifiable for ClientResponse<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "data",
                     Self::VT_DATA,
                     true,
@@ -2481,7 +2461,7 @@ pub mod client_request {
         }
     }
     pub struct ClientResponseArgs<'a> {
-        pub data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for ClientResponseArgs<'a> {
         #[inline]
@@ -2492,19 +2472,19 @@ pub mod client_request {
         }
     }
 
-    pub struct ClientResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ClientResponseBuilder<'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> ClientResponseBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ClientResponseBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(ClientResponse::VT_DATA, data);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ClientResponse::VT_DATA, data);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ClientResponseBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ClientResponseBuilder {
@@ -2513,15 +2493,15 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ClientResponse<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ClientResponse<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, ClientResponse::VT_DATA, "data");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ClientResponse<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ClientResponse<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ClientResponse");
             ds.field("data", &self.data());
             ds.finish()
@@ -2531,26 +2511,26 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct UserInputResponse<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for UserInputResponse<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for UserInputResponse<'a> {
         type Inner = UserInputResponse<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> UserInputResponse<'a> {
-        pub const VT_REQUEST_ID: flatbuffers::VOffsetT = 4;
-        pub const VT_RESPONSE: flatbuffers::VOffsetT = 6;
-        pub const VT_DELEGATE_CONTEXT: flatbuffers::VOffsetT = 8;
+        pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 4;
+        pub const VT_RESPONSE: ::flatbuffers::VOffsetT = 6;
+        pub const VT_DELEGATE_CONTEXT: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             UserInputResponse { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2558,11 +2538,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args UserInputResponseArgs<'args>,
-        ) -> flatbuffers::WIPOffset<UserInputResponse<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<UserInputResponse<'bldr>> {
             let mut builder = UserInputResponseBuilder::new(_fbb);
             if let Some(x) = args.delegate_context {
                 builder.add_delegate_context(x);
@@ -2592,7 +2572,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<ClientResponse>>(
+                    .get::<::flatbuffers::ForwardsUOffset<ClientResponse>>(
                         UserInputResponse::VT_RESPONSE,
                         None,
                     )
@@ -2600,13 +2580,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn delegate_context(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn delegate_context(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         UserInputResponse::VT_DELEGATE_CONTEXT,
                         None,
                     )
@@ -2615,21 +2595,20 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for UserInputResponse<'_> {
+    impl ::flatbuffers::Verifiable for UserInputResponse<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
                 .visit_field::<u32>("request_id", Self::VT_REQUEST_ID, false)?
-                .visit_field::<flatbuffers::ForwardsUOffset<ClientResponse>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<ClientResponse>>(
                     "response",
                     Self::VT_RESPONSE,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "delegate_context",
                     Self::VT_DELEGATE_CONTEXT,
                     true,
@@ -2640,8 +2619,8 @@ pub mod client_request {
     }
     pub struct UserInputResponseArgs<'a> {
         pub request_id: u32,
-        pub response: Option<flatbuffers::WIPOffset<ClientResponse<'a>>>,
-        pub delegate_context: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub response: Option<::flatbuffers::WIPOffset<ClientResponse<'a>>>,
+        pub delegate_context: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for UserInputResponseArgs<'a> {
         #[inline]
@@ -2654,20 +2633,20 @@ pub mod client_request {
         }
     }
 
-    pub struct UserInputResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct UserInputResponseBuilder<'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> UserInputResponseBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UserInputResponseBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_request_id(&mut self, request_id: u32) {
             self.fbb_
                 .push_slot::<u32>(UserInputResponse::VT_REQUEST_ID, request_id, 0);
         }
         #[inline]
-        pub fn add_response(&mut self, response: flatbuffers::WIPOffset<ClientResponse<'b>>) {
+        pub fn add_response(&mut self, response: ::flatbuffers::WIPOffset<ClientResponse<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<ClientResponse>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<ClientResponse>>(
                     UserInputResponse::VT_RESPONSE,
                     response,
                 );
@@ -2675,16 +2654,16 @@ pub mod client_request {
         #[inline]
         pub fn add_delegate_context(
             &mut self,
-            delegate_context: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            delegate_context: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 UserInputResponse::VT_DELEGATE_CONTEXT,
                 delegate_context,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> UserInputResponseBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             UserInputResponseBuilder {
@@ -2693,7 +2672,7 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<UserInputResponse<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<UserInputResponse<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, UserInputResponse::VT_RESPONSE, "response");
@@ -2702,12 +2681,12 @@ pub mod client_request {
                 UserInputResponse::VT_DELEGATE_CONTEXT,
                 "delegate_context",
             );
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for UserInputResponse<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for UserInputResponse<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("UserInputResponse");
             ds.field("request_id", &self.request_id());
             ds.field("response", &self.response());
@@ -2719,25 +2698,25 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct InboundDelegateMsg<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for InboundDelegateMsg<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for InboundDelegateMsg<'a> {
         type Inner = InboundDelegateMsg<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> InboundDelegateMsg<'a> {
-        pub const VT_INBOUND_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_INBOUND: flatbuffers::VOffsetT = 6;
+        pub const VT_INBOUND_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_INBOUND: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             InboundDelegateMsg { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2745,11 +2724,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args InboundDelegateMsgArgs,
-        ) -> flatbuffers::WIPOffset<InboundDelegateMsg<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<InboundDelegateMsg<'bldr>> {
             let mut builder = InboundDelegateMsgBuilder::new(_fbb);
             if let Some(x) = args.inbound {
                 builder.add_inbound(x);
@@ -2773,13 +2752,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn inbound(&self) -> flatbuffers::Table<'a> {
+        pub fn inbound(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         InboundDelegateMsg::VT_INBOUND,
                         None,
                     )
@@ -2817,18 +2796,17 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for InboundDelegateMsg<'_> {
+    impl ::flatbuffers::Verifiable for InboundDelegateMsg<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
      .visit_union::<InboundDelegateMsgType, _>("inbound_type", Self::VT_INBOUND_TYPE, "inbound", Self::VT_INBOUND, true, |key, v, pos| {
         match key {
-          InboundDelegateMsgType::common_ApplicationMessage => v.verify_union_variant::<flatbuffers::ForwardsUOffset<super::common::ApplicationMessage>>("InboundDelegateMsgType::common_ApplicationMessage", pos),
-          InboundDelegateMsgType::UserInputResponse => v.verify_union_variant::<flatbuffers::ForwardsUOffset<UserInputResponse>>("InboundDelegateMsgType::UserInputResponse", pos),
+          InboundDelegateMsgType::common_ApplicationMessage => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<super::common::ApplicationMessage>>("InboundDelegateMsgType::common_ApplicationMessage", pos),
+          InboundDelegateMsgType::UserInputResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<UserInputResponse>>("InboundDelegateMsgType::UserInputResponse", pos),
           _ => Ok(()),
         }
      })?
@@ -2838,7 +2816,7 @@ pub mod client_request {
     }
     pub struct InboundDelegateMsgArgs {
         pub inbound_type: InboundDelegateMsgType,
-        pub inbound: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub inbound: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for InboundDelegateMsgArgs {
         #[inline]
@@ -2850,11 +2828,11 @@ pub mod client_request {
         }
     }
 
-    pub struct InboundDelegateMsgBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct InboundDelegateMsgBuilder<'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> InboundDelegateMsgBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> InboundDelegateMsgBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_inbound_type(&mut self, inbound_type: InboundDelegateMsgType) {
             self.fbb_.push_slot::<InboundDelegateMsgType>(
@@ -2866,16 +2844,16 @@ pub mod client_request {
         #[inline]
         pub fn add_inbound(
             &mut self,
-            inbound: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            inbound: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 InboundDelegateMsg::VT_INBOUND,
                 inbound,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> InboundDelegateMsgBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             InboundDelegateMsgBuilder {
@@ -2884,16 +2862,16 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<InboundDelegateMsg<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<InboundDelegateMsg<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, InboundDelegateMsg::VT_INBOUND, "inbound");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for InboundDelegateMsg<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for InboundDelegateMsg<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("InboundDelegateMsg");
             ds.field("inbound_type", &self.inbound_type());
             match self.inbound_type() {
@@ -2929,26 +2907,26 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ApplicationMessages<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ApplicationMessages<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ApplicationMessages<'a> {
         type Inner = ApplicationMessages<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ApplicationMessages<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_PARAMS: flatbuffers::VOffsetT = 6;
-        pub const VT_INBOUND: flatbuffers::VOffsetT = 8;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_PARAMS: ::flatbuffers::VOffsetT = 6;
+        pub const VT_INBOUND: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ApplicationMessages { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2956,11 +2934,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ApplicationMessagesArgs<'args>,
-        ) -> flatbuffers::WIPOffset<ApplicationMessages<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ApplicationMessages<'bldr>> {
             let mut builder = ApplicationMessagesBuilder::new(_fbb);
             if let Some(x) = args.inbound {
                 builder.add_inbound(x);
@@ -2981,7 +2959,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<DelegateKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<DelegateKey>>(
                         ApplicationMessages::VT_KEY,
                         None,
                     )
@@ -2989,13 +2967,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn params(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn params(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ApplicationMessages::VT_PARAMS,
                         None,
                     )
@@ -3005,51 +2983,54 @@ pub mod client_request {
         #[inline]
         pub fn inbound(
             &self,
-        ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<InboundDelegateMsg<'a>>> {
+        ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<InboundDelegateMsg<'a>>>
+        {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<
-                        flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<InboundDelegateMsg>>,
+                    .get::<::flatbuffers::ForwardsUOffset<
+                        ::flatbuffers::Vector<
+                            'a,
+                            ::flatbuffers::ForwardsUOffset<InboundDelegateMsg>,
+                        >,
                     >>(ApplicationMessages::VT_INBOUND, None)
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for ApplicationMessages<'_> {
+    impl ::flatbuffers::Verifiable for ApplicationMessages<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<DelegateKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<DelegateKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "params",
                     Self::VT_PARAMS,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<
-                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<InboundDelegateMsg>>,
+                .visit_field::<::flatbuffers::ForwardsUOffset<
+                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<InboundDelegateMsg>>,
                 >>("inbound", Self::VT_INBOUND, true)?
                 .finish();
             Ok(())
         }
     }
     pub struct ApplicationMessagesArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<DelegateKey<'a>>>,
-        pub params: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub key: Option<::flatbuffers::WIPOffset<DelegateKey<'a>>>,
+        pub params: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
         pub inbound: Option<
-            flatbuffers::WIPOffset<
-                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<InboundDelegateMsg<'a>>>,
+            ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<InboundDelegateMsg<'a>>>,
             >,
         >,
     }
@@ -3064,22 +3045,25 @@ pub mod client_request {
         }
     }
 
-    pub struct ApplicationMessagesBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ApplicationMessagesBuilder<'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> ApplicationMessagesBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ApplicationMessagesBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<DelegateKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<DelegateKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<DelegateKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<DelegateKey>>(
                     ApplicationMessages::VT_KEY,
                     key,
                 );
         }
         #[inline]
-        pub fn add_params(&mut self, params: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+        pub fn add_params(
+            &mut self,
+            params: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 ApplicationMessages::VT_PARAMS,
                 params,
             );
@@ -3087,18 +3071,18 @@ pub mod client_request {
         #[inline]
         pub fn add_inbound(
             &mut self,
-            inbound: flatbuffers::WIPOffset<
-                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<InboundDelegateMsg<'b>>>,
+            inbound: ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<InboundDelegateMsg<'b>>>,
             >,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 ApplicationMessages::VT_INBOUND,
                 inbound,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ApplicationMessagesBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ApplicationMessagesBuilder {
@@ -3107,19 +3091,19 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ApplicationMessages<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ApplicationMessages<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, ApplicationMessages::VT_KEY, "key");
             self.fbb_
                 .required(o, ApplicationMessages::VT_PARAMS, "params");
             self.fbb_
                 .required(o, ApplicationMessages::VT_INBOUND, "inbound");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ApplicationMessages<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ApplicationMessages<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ApplicationMessages");
             ds.field("key", &self.key());
             ds.field("params", &self.params());
@@ -3131,26 +3115,26 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct RegisterDelegate<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for RegisterDelegate<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for RegisterDelegate<'a> {
         type Inner = RegisterDelegate<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> RegisterDelegate<'a> {
-        pub const VT_DELEGATE: flatbuffers::VOffsetT = 4;
-        pub const VT_CIPHER: flatbuffers::VOffsetT = 6;
-        pub const VT_NONCE: flatbuffers::VOffsetT = 8;
+        pub const VT_DELEGATE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CIPHER: ::flatbuffers::VOffsetT = 6;
+        pub const VT_NONCE: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             RegisterDelegate { _tab: table }
         }
         #[allow(unused_mut)]
@@ -3158,11 +3142,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args RegisterDelegateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<RegisterDelegate<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<RegisterDelegate<'bldr>> {
             let mut builder = RegisterDelegateBuilder::new(_fbb);
             if let Some(x) = args.nonce {
                 builder.add_nonce(x);
@@ -3183,7 +3167,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<DelegateContainer>>(
+                    .get::<::flatbuffers::ForwardsUOffset<DelegateContainer>>(
                         RegisterDelegate::VT_DELEGATE,
                         None,
                     )
@@ -3191,13 +3175,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn cipher(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn cipher(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         RegisterDelegate::VT_CIPHER,
                         None,
                     )
@@ -3205,13 +3189,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn nonce(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn nonce(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         RegisterDelegate::VT_NONCE,
                         None,
                     )
@@ -3220,25 +3204,24 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for RegisterDelegate<'_> {
+    impl ::flatbuffers::Verifiable for RegisterDelegate<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<DelegateContainer>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<DelegateContainer>>(
                     "delegate",
                     Self::VT_DELEGATE,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "cipher",
                     Self::VT_CIPHER,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "nonce",
                     Self::VT_NONCE,
                     true,
@@ -3248,9 +3231,9 @@ pub mod client_request {
         }
     }
     pub struct RegisterDelegateArgs<'a> {
-        pub delegate: Option<flatbuffers::WIPOffset<DelegateContainer<'a>>>,
-        pub cipher: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub nonce: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub delegate: Option<::flatbuffers::WIPOffset<DelegateContainer<'a>>>,
+        pub cipher: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub nonce: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for RegisterDelegateArgs<'a> {
         #[inline]
@@ -3263,32 +3246,40 @@ pub mod client_request {
         }
     }
 
-    pub struct RegisterDelegateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct RegisterDelegateBuilder<'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> RegisterDelegateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RegisterDelegateBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_delegate(&mut self, delegate: flatbuffers::WIPOffset<DelegateContainer<'b>>) {
+        pub fn add_delegate(&mut self, delegate: ::flatbuffers::WIPOffset<DelegateContainer<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<DelegateContainer>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<DelegateContainer>>(
                     RegisterDelegate::VT_DELEGATE,
                     delegate,
                 );
         }
         #[inline]
-        pub fn add_cipher(&mut self, cipher: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
-            self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(RegisterDelegate::VT_CIPHER, cipher);
+        pub fn add_cipher(
+            &mut self,
+            cipher: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
+                RegisterDelegate::VT_CIPHER,
+                cipher,
+            );
         }
         #[inline]
-        pub fn add_nonce(&mut self, nonce: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_nonce(
+            &mut self,
+            nonce: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(RegisterDelegate::VT_NONCE, nonce);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(RegisterDelegate::VT_NONCE, nonce);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> RegisterDelegateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             RegisterDelegateBuilder {
@@ -3297,18 +3288,18 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<RegisterDelegate<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<RegisterDelegate<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, RegisterDelegate::VT_DELEGATE, "delegate");
             self.fbb_.required(o, RegisterDelegate::VT_CIPHER, "cipher");
             self.fbb_.required(o, RegisterDelegate::VT_NONCE, "nonce");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for RegisterDelegate<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for RegisterDelegate<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("RegisterDelegate");
             ds.field("delegate", &self.delegate());
             ds.field("cipher", &self.cipher());
@@ -3320,24 +3311,24 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct UnregisterDelegate<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for UnregisterDelegate<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for UnregisterDelegate<'a> {
         type Inner = UnregisterDelegate<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> UnregisterDelegate<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             UnregisterDelegate { _tab: table }
         }
         #[allow(unused_mut)]
@@ -3345,11 +3336,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args UnregisterDelegateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<UnregisterDelegate<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<UnregisterDelegate<'bldr>> {
             let mut builder = UnregisterDelegateBuilder::new(_fbb);
             if let Some(x) = args.key {
                 builder.add_key(x);
@@ -3364,7 +3355,7 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<DelegateKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<DelegateKey>>(
                         UnregisterDelegate::VT_KEY,
                         None,
                     )
@@ -3373,15 +3364,14 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for UnregisterDelegate<'_> {
+    impl ::flatbuffers::Verifiable for UnregisterDelegate<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<DelegateKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<DelegateKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
@@ -3391,7 +3381,7 @@ pub mod client_request {
         }
     }
     pub struct UnregisterDelegateArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<DelegateKey<'a>>>,
+        pub key: Option<::flatbuffers::WIPOffset<DelegateKey<'a>>>,
     }
     impl<'a> Default for UnregisterDelegateArgs<'a> {
         #[inline]
@@ -3402,22 +3392,22 @@ pub mod client_request {
         }
     }
 
-    pub struct UnregisterDelegateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct UnregisterDelegateBuilder<'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> UnregisterDelegateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UnregisterDelegateBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<DelegateKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<DelegateKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<DelegateKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<DelegateKey>>(
                     UnregisterDelegate::VT_KEY,
                     key,
                 );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> UnregisterDelegateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             UnregisterDelegateBuilder {
@@ -3426,15 +3416,15 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<UnregisterDelegate<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<UnregisterDelegate<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, UnregisterDelegate::VT_KEY, "key");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for UnregisterDelegate<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for UnregisterDelegate<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("UnregisterDelegate");
             ds.field("key", &self.key());
             ds.finish()
@@ -3444,25 +3434,25 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ContractRequest<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ContractRequest<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ContractRequest<'a> {
         type Inner = ContractRequest<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ContractRequest<'a> {
-        pub const VT_CONTRACT_REQUEST_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_CONTRACT_REQUEST: flatbuffers::VOffsetT = 6;
+        pub const VT_CONTRACT_REQUEST_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CONTRACT_REQUEST: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ContractRequest { _tab: table }
         }
         #[allow(unused_mut)]
@@ -3470,11 +3460,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ContractRequestArgs,
-        ) -> flatbuffers::WIPOffset<ContractRequest<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ContractRequest<'bldr>> {
             let mut builder = ContractRequestBuilder::new(_fbb);
             if let Some(x) = args.contract_request {
                 builder.add_contract_request(x);
@@ -3498,13 +3488,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn contract_request(&self) -> flatbuffers::Table<'a> {
+        pub fn contract_request(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         ContractRequest::VT_CONTRACT_REQUEST,
                         None,
                     )
@@ -3568,13 +3558,12 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for ContractRequest<'_> {
+    impl ::flatbuffers::Verifiable for ContractRequest<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
                 .visit_union::<ContractRequestType, _>(
                     "contract_request_type",
@@ -3584,22 +3573,22 @@ pub mod client_request {
                     true,
                     |key, v, pos| match key {
                         ContractRequestType::Put => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<Put>>(
+                            .verify_union_variant::<::flatbuffers::ForwardsUOffset<Put>>(
                                 "ContractRequestType::Put",
                                 pos,
                             ),
                         ContractRequestType::Update => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<Update>>(
+                            .verify_union_variant::<::flatbuffers::ForwardsUOffset<Update>>(
                                 "ContractRequestType::Update",
                                 pos,
                             ),
                         ContractRequestType::Get => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<Get>>(
+                            .verify_union_variant::<::flatbuffers::ForwardsUOffset<Get>>(
                                 "ContractRequestType::Get",
                                 pos,
                             ),
                         ContractRequestType::Subscribe => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<Subscribe>>(
+                            .verify_union_variant::<::flatbuffers::ForwardsUOffset<Subscribe>>(
                                 "ContractRequestType::Subscribe",
                                 pos,
                             ),
@@ -3612,7 +3601,7 @@ pub mod client_request {
     }
     pub struct ContractRequestArgs {
         pub contract_request_type: ContractRequestType,
-        pub contract_request: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub contract_request: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for ContractRequestArgs {
         #[inline]
@@ -3624,11 +3613,11 @@ pub mod client_request {
         }
     }
 
-    pub struct ContractRequestBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ContractRequestBuilder<'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> ContractRequestBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractRequestBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_contract_request_type(&mut self, contract_request_type: ContractRequestType) {
             self.fbb_.push_slot::<ContractRequestType>(
@@ -3640,16 +3629,16 @@ pub mod client_request {
         #[inline]
         pub fn add_contract_request(
             &mut self,
-            contract_request: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            contract_request: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 ContractRequest::VT_CONTRACT_REQUEST,
                 contract_request,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ContractRequestBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ContractRequestBuilder {
@@ -3658,16 +3647,16 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ContractRequest<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ContractRequest<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, ContractRequest::VT_CONTRACT_REQUEST, "contract_request");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ContractRequest<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContractRequest<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ContractRequest");
             ds.field("contract_request_type", &self.contract_request_type());
             match self.contract_request_type() {
@@ -3723,25 +3712,25 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct DelegateRequest<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for DelegateRequest<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for DelegateRequest<'a> {
         type Inner = DelegateRequest<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> DelegateRequest<'a> {
-        pub const VT_DELEGATE_REQUEST_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_DELEGATE_REQUEST: flatbuffers::VOffsetT = 6;
+        pub const VT_DELEGATE_REQUEST_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_DELEGATE_REQUEST: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             DelegateRequest { _tab: table }
         }
         #[allow(unused_mut)]
@@ -3749,11 +3738,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args DelegateRequestArgs,
-        ) -> flatbuffers::WIPOffset<DelegateRequest<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<DelegateRequest<'bldr>> {
             let mut builder = DelegateRequestBuilder::new(_fbb);
             if let Some(x) = args.delegate_request {
                 builder.add_delegate_request(x);
@@ -3777,13 +3766,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn delegate_request(&self) -> flatbuffers::Table<'a> {
+        pub fn delegate_request(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         DelegateRequest::VT_DELEGATE_REQUEST,
                         None,
                     )
@@ -3833,19 +3822,18 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for DelegateRequest<'_> {
+    impl ::flatbuffers::Verifiable for DelegateRequest<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
      .visit_union::<DelegateRequestType, _>("delegate_request_type", Self::VT_DELEGATE_REQUEST_TYPE, "delegate_request", Self::VT_DELEGATE_REQUEST, true, |key, v, pos| {
         match key {
-          DelegateRequestType::ApplicationMessages => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ApplicationMessages>>("DelegateRequestType::ApplicationMessages", pos),
-          DelegateRequestType::RegisterDelegate => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RegisterDelegate>>("DelegateRequestType::RegisterDelegate", pos),
-          DelegateRequestType::UnregisterDelegate => v.verify_union_variant::<flatbuffers::ForwardsUOffset<UnregisterDelegate>>("DelegateRequestType::UnregisterDelegate", pos),
+          DelegateRequestType::ApplicationMessages => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ApplicationMessages>>("DelegateRequestType::ApplicationMessages", pos),
+          DelegateRequestType::RegisterDelegate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RegisterDelegate>>("DelegateRequestType::RegisterDelegate", pos),
+          DelegateRequestType::UnregisterDelegate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<UnregisterDelegate>>("DelegateRequestType::UnregisterDelegate", pos),
           _ => Ok(()),
         }
      })?
@@ -3855,7 +3843,7 @@ pub mod client_request {
     }
     pub struct DelegateRequestArgs {
         pub delegate_request_type: DelegateRequestType,
-        pub delegate_request: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub delegate_request: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for DelegateRequestArgs {
         #[inline]
@@ -3867,11 +3855,11 @@ pub mod client_request {
         }
     }
 
-    pub struct DelegateRequestBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct DelegateRequestBuilder<'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> DelegateRequestBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateRequestBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_delegate_request_type(&mut self, delegate_request_type: DelegateRequestType) {
             self.fbb_.push_slot::<DelegateRequestType>(
@@ -3883,16 +3871,16 @@ pub mod client_request {
         #[inline]
         pub fn add_delegate_request(
             &mut self,
-            delegate_request: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            delegate_request: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 DelegateRequest::VT_DELEGATE_REQUEST,
                 delegate_request,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> DelegateRequestBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             DelegateRequestBuilder {
@@ -3901,16 +3889,16 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<DelegateRequest<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<DelegateRequest<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, DelegateRequest::VT_DELEGATE_REQUEST, "delegate_request");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for DelegateRequest<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DelegateRequest<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("DelegateRequest");
             ds.field("delegate_request_type", &self.delegate_request_type());
             match self.delegate_request_type() {
@@ -3956,24 +3944,24 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct Disconnect<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for Disconnect<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for Disconnect<'a> {
         type Inner = Disconnect<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> Disconnect<'a> {
-        pub const VT_CAUSE: flatbuffers::VOffsetT = 4;
+        pub const VT_CAUSE: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             Disconnect { _tab: table }
         }
         #[allow(unused_mut)]
@@ -3981,11 +3969,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args DisconnectArgs<'args>,
-        ) -> flatbuffers::WIPOffset<Disconnect<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<Disconnect<'bldr>> {
             let mut builder = DisconnectBuilder::new(_fbb);
             if let Some(x) = args.cause {
                 builder.add_cause(x);
@@ -4000,26 +3988,29 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Disconnect::VT_CAUSE, None)
+                    .get::<::flatbuffers::ForwardsUOffset<&str>>(Disconnect::VT_CAUSE, None)
             }
         }
     }
 
-    impl flatbuffers::Verifiable for Disconnect<'_> {
+    impl ::flatbuffers::Verifiable for Disconnect<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>("cause", Self::VT_CAUSE, false)?
+                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
+                    "cause",
+                    Self::VT_CAUSE,
+                    false,
+                )?
                 .finish();
             Ok(())
         }
     }
     pub struct DisconnectArgs<'a> {
-        pub cause: Option<flatbuffers::WIPOffset<&'a str>>,
+        pub cause: Option<::flatbuffers::WIPOffset<&'a str>>,
     }
     impl<'a> Default for DisconnectArgs<'a> {
         #[inline]
@@ -4028,19 +4019,19 @@ pub mod client_request {
         }
     }
 
-    pub struct DisconnectBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct DisconnectBuilder<'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> DisconnectBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DisconnectBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_cause(&mut self, cause: flatbuffers::WIPOffset<&'b str>) {
+        pub fn add_cause(&mut self, cause: ::flatbuffers::WIPOffset<&'b str>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(Disconnect::VT_CAUSE, cause);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(Disconnect::VT_CAUSE, cause);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> DisconnectBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             DisconnectBuilder {
@@ -4049,14 +4040,14 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<Disconnect<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<Disconnect<'a>> {
             let o = self.fbb_.end_table(self.start_);
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for Disconnect<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for Disconnect<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("Disconnect");
             ds.field("cause", &self.cause());
             ds.finish()
@@ -4066,24 +4057,24 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct Authenticate<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for Authenticate<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for Authenticate<'a> {
         type Inner = Authenticate<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> Authenticate<'a> {
-        pub const VT_TOKEN: flatbuffers::VOffsetT = 4;
+        pub const VT_TOKEN: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             Authenticate { _tab: table }
         }
         #[allow(unused_mut)]
@@ -4091,11 +4082,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args AuthenticateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<Authenticate<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<Authenticate<'bldr>> {
             let mut builder = AuthenticateBuilder::new(_fbb);
             if let Some(x) = args.token {
                 builder.add_token(x);
@@ -4110,27 +4101,26 @@ pub mod client_request {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Authenticate::VT_TOKEN, None)
+                    .get::<::flatbuffers::ForwardsUOffset<&str>>(Authenticate::VT_TOKEN, None)
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for Authenticate<'_> {
+    impl ::flatbuffers::Verifiable for Authenticate<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>("token", Self::VT_TOKEN, true)?
+                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("token", Self::VT_TOKEN, true)?
                 .finish();
             Ok(())
         }
     }
     pub struct AuthenticateArgs<'a> {
-        pub token: Option<flatbuffers::WIPOffset<&'a str>>,
+        pub token: Option<::flatbuffers::WIPOffset<&'a str>>,
     }
     impl<'a> Default for AuthenticateArgs<'a> {
         #[inline]
@@ -4141,19 +4131,19 @@ pub mod client_request {
         }
     }
 
-    pub struct AuthenticateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct AuthenticateBuilder<'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> AuthenticateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> AuthenticateBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_token(&mut self, token: flatbuffers::WIPOffset<&'b str>) {
+        pub fn add_token(&mut self, token: ::flatbuffers::WIPOffset<&'b str>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(Authenticate::VT_TOKEN, token);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(Authenticate::VT_TOKEN, token);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> AuthenticateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             AuthenticateBuilder {
@@ -4162,15 +4152,15 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<Authenticate<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<Authenticate<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, Authenticate::VT_TOKEN, "token");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for Authenticate<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for Authenticate<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("Authenticate");
             ds.field("token", &self.token());
             ds.finish()
@@ -4180,27 +4170,27 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct StreamChunk<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for StreamChunk<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for StreamChunk<'a> {
         type Inner = StreamChunk<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> StreamChunk<'a> {
-        pub const VT_STREAM_ID: flatbuffers::VOffsetT = 4;
-        pub const VT_INDEX: flatbuffers::VOffsetT = 6;
-        pub const VT_TOTAL: flatbuffers::VOffsetT = 8;
-        pub const VT_DATA: flatbuffers::VOffsetT = 10;
+        pub const VT_STREAM_ID: ::flatbuffers::VOffsetT = 4;
+        pub const VT_INDEX: ::flatbuffers::VOffsetT = 6;
+        pub const VT_TOTAL: ::flatbuffers::VOffsetT = 8;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 10;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             StreamChunk { _tab: table }
         }
         #[allow(unused_mut)]
@@ -4208,11 +4198,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args StreamChunkArgs<'args>,
-        ) -> flatbuffers::WIPOffset<StreamChunk<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<StreamChunk<'bldr>> {
             let mut builder = StreamChunkBuilder::new(_fbb);
             if let Some(x) = args.data {
                 builder.add_data(x);
@@ -4257,13 +4247,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn data(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         StreamChunk::VT_DATA,
                         None,
                     )
@@ -4272,18 +4262,17 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for StreamChunk<'_> {
+    impl ::flatbuffers::Verifiable for StreamChunk<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
                 .visit_field::<u32>("stream_id", Self::VT_STREAM_ID, false)?
                 .visit_field::<u32>("index", Self::VT_INDEX, false)?
                 .visit_field::<u32>("total", Self::VT_TOTAL, false)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "data",
                     Self::VT_DATA,
                     true,
@@ -4296,7 +4285,7 @@ pub mod client_request {
         pub stream_id: u32,
         pub index: u32,
         pub total: u32,
-        pub data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for StreamChunkArgs<'a> {
         #[inline]
@@ -4310,11 +4299,11 @@ pub mod client_request {
         }
     }
 
-    pub struct StreamChunkBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct StreamChunkBuilder<'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> StreamChunkBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StreamChunkBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_stream_id(&mut self, stream_id: u32) {
             self.fbb_
@@ -4329,13 +4318,13 @@ pub mod client_request {
             self.fbb_.push_slot::<u32>(StreamChunk::VT_TOTAL, total, 0);
         }
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(StreamChunk::VT_DATA, data);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(StreamChunk::VT_DATA, data);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> StreamChunkBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             StreamChunkBuilder {
@@ -4344,15 +4333,15 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<StreamChunk<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<StreamChunk<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, StreamChunk::VT_DATA, "data");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for StreamChunk<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for StreamChunk<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("StreamChunk");
             ds.field("stream_id", &self.stream_id());
             ds.field("index", &self.index());
@@ -4365,25 +4354,25 @@ pub mod client_request {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ClientRequest<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ClientRequest<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ClientRequest<'a> {
         type Inner = ClientRequest<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ClientRequest<'a> {
-        pub const VT_CLIENT_REQUEST_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_CLIENT_REQUEST: flatbuffers::VOffsetT = 6;
+        pub const VT_CLIENT_REQUEST_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CLIENT_REQUEST: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ClientRequest { _tab: table }
         }
         #[allow(unused_mut)]
@@ -4391,11 +4380,11 @@ pub mod client_request {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ClientRequestArgs,
-        ) -> flatbuffers::WIPOffset<ClientRequest<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ClientRequest<'bldr>> {
             let mut builder = ClientRequestBuilder::new(_fbb);
             if let Some(x) = args.client_request {
                 builder.add_client_request(x);
@@ -4419,13 +4408,13 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn client_request(&self) -> flatbuffers::Table<'a> {
+        pub fn client_request(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         ClientRequest::VT_CLIENT_REQUEST,
                         None,
                     )
@@ -4503,56 +4492,30 @@ pub mod client_request {
         }
     }
 
-    impl flatbuffers::Verifiable for ClientRequest<'_> {
+    impl ::flatbuffers::Verifiable for ClientRequest<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_union::<ClientRequestType, _>(
-                    "client_request_type",
-                    Self::VT_CLIENT_REQUEST_TYPE,
-                    "client_request",
-                    Self::VT_CLIENT_REQUEST,
-                    true,
-                    |key, v, pos| match key {
-                        ClientRequestType::ContractRequest => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<ContractRequest>>(
-                                "ClientRequestType::ContractRequest",
-                                pos,
-                            ),
-                        ClientRequestType::DelegateRequest => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<DelegateRequest>>(
-                                "ClientRequestType::DelegateRequest",
-                                pos,
-                            ),
-                        ClientRequestType::Disconnect => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<Disconnect>>(
-                                "ClientRequestType::Disconnect",
-                                pos,
-                            ),
-                        ClientRequestType::Authenticate => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<Authenticate>>(
-                                "ClientRequestType::Authenticate",
-                                pos,
-                            ),
-                        ClientRequestType::StreamChunk => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<StreamChunk>>(
-                                "ClientRequestType::StreamChunk",
-                                pos,
-                            ),
-                        _ => Ok(()),
-                    },
-                )?
-                .finish();
+     .visit_union::<ClientRequestType, _>("client_request_type", Self::VT_CLIENT_REQUEST_TYPE, "client_request", Self::VT_CLIENT_REQUEST, true, |key, v, pos| {
+        match key {
+          ClientRequestType::ContractRequest => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ContractRequest>>("ClientRequestType::ContractRequest", pos),
+          ClientRequestType::DelegateRequest => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<DelegateRequest>>("ClientRequestType::DelegateRequest", pos),
+          ClientRequestType::Disconnect => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Disconnect>>("ClientRequestType::Disconnect", pos),
+          ClientRequestType::Authenticate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Authenticate>>("ClientRequestType::Authenticate", pos),
+          ClientRequestType::StreamChunk => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<StreamChunk>>("ClientRequestType::StreamChunk", pos),
+          _ => Ok(()),
+        }
+     })?
+     .finish();
             Ok(())
         }
     }
     pub struct ClientRequestArgs {
         pub client_request_type: ClientRequestType,
-        pub client_request: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub client_request: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for ClientRequestArgs {
         #[inline]
@@ -4564,11 +4527,11 @@ pub mod client_request {
         }
     }
 
-    pub struct ClientRequestBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ClientRequestBuilder<'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> ClientRequestBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ClientRequestBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_client_request_type(&mut self, client_request_type: ClientRequestType) {
             self.fbb_.push_slot::<ClientRequestType>(
@@ -4580,16 +4543,16 @@ pub mod client_request {
         #[inline]
         pub fn add_client_request(
             &mut self,
-            client_request: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            client_request: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 ClientRequest::VT_CLIENT_REQUEST,
                 client_request,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ClientRequestBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ClientRequestBuilder {
@@ -4598,16 +4561,16 @@ pub mod client_request {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ClientRequest<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ClientRequest<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, ClientRequest::VT_CLIENT_REQUEST, "client_request");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ClientRequest<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ClientRequest<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ClientRequest");
             ds.field("client_request_type", &self.client_request_type());
             match self.client_request_type() {
@@ -4678,8 +4641,8 @@ pub mod client_request {
     /// `root_as_client_request_unchecked`.
     pub fn root_as_client_request(
         buf: &[u8],
-    ) -> Result<ClientRequest, flatbuffers::InvalidFlatbuffer> {
-        flatbuffers::root::<ClientRequest>(buf)
+    ) -> Result<ClientRequest<'_>, ::flatbuffers::InvalidFlatbuffer> {
+        ::flatbuffers::root::<ClientRequest>(buf)
     }
     #[inline]
     /// Verifies that a buffer of bytes contains a size prefixed
@@ -4690,8 +4653,8 @@ 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> {
-        flatbuffers::size_prefixed_root::<ClientRequest>(buf)
+    ) -> Result<ClientRequest<'_>, ::flatbuffers::InvalidFlatbuffer> {
+        ::flatbuffers::size_prefixed_root::<ClientRequest>(buf)
     }
     #[inline]
     /// Verifies, with the given options, that a buffer of bytes
@@ -4701,10 +4664,10 @@ pub mod client_request {
     /// previous, unchecked, behavior use
     /// `root_as_client_request_unchecked`.
     pub fn root_as_client_request_with_opts<'b, 'o>(
-        opts: &'o flatbuffers::VerifierOptions,
+        opts: &'o ::flatbuffers::VerifierOptions,
         buf: &'b [u8],
-    ) -> Result<ClientRequest<'b>, flatbuffers::InvalidFlatbuffer> {
-        flatbuffers::root_with_opts::<ClientRequest<'b>>(opts, buf)
+    ) -> Result<ClientRequest<'b>, ::flatbuffers::InvalidFlatbuffer> {
+        ::flatbuffers::root_with_opts::<ClientRequest<'b>>(opts, buf)
     }
     #[inline]
     /// Verifies, with the given verifier options, that a buffer of
@@ -4714,37 +4677,37 @@ pub mod client_request {
     /// previous, unchecked, behavior use
     /// `root_as_client_request_unchecked`.
     pub fn size_prefixed_root_as_client_request_with_opts<'b, 'o>(
-        opts: &'o flatbuffers::VerifierOptions,
+        opts: &'o ::flatbuffers::VerifierOptions,
         buf: &'b [u8],
-    ) -> Result<ClientRequest<'b>, flatbuffers::InvalidFlatbuffer> {
-        flatbuffers::size_prefixed_root_with_opts::<ClientRequest<'b>>(opts, buf)
+    ) -> Result<ClientRequest<'b>, ::flatbuffers::InvalidFlatbuffer> {
+        ::flatbuffers::size_prefixed_root_with_opts::<ClientRequest<'b>>(opts, buf)
     }
     #[inline]
     /// 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 {
-        flatbuffers::root_unchecked::<ClientRequest>(buf)
+    pub unsafe fn root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest<'_> {
+        unsafe { ::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 {
-        flatbuffers::size_prefixed_root_unchecked::<ClientRequest>(buf)
+    pub unsafe fn size_prefixed_root_as_client_request_unchecked(buf: &[u8]) -> ClientRequest<'_> {
+        unsafe { ::flatbuffers::size_prefixed_root_unchecked::<ClientRequest>(buf) }
     }
     #[inline]
-    pub fn finish_client_request_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
-        fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        root: flatbuffers::WIPOffset<ClientRequest<'a>>,
+    pub fn finish_client_request_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+        fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+        root: ::flatbuffers::WIPOffset<ClientRequest<'a>>,
     ) {
         fbb.finish(root, None);
     }
 
     #[inline]
-    pub fn finish_size_prefixed_client_request_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
-        fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        root: flatbuffers::WIPOffset<ClientRequest<'a>>,
+    pub fn finish_size_prefixed_client_request_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+        fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+        root: ::flatbuffers::WIPOffset<ClientRequest<'a>>,
     ) {
         fbb.finish_size_prefixed(root, None);
     }
diff --git a/rust/src/generated/common_generated.rs b/rust/src/generated/common_generated.rs
index 133b1c4..2064811 100644
--- a/rust/src/generated/common_generated.rs
+++ b/rust/src/generated/common_generated.rs
@@ -1,22 +1,10 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-
 // @generated
-
-use core::cmp::Ordering;
-use core::mem;
-
-extern crate flatbuffers;
-use self::flatbuffers::{EndianScalar, Follow};
+extern crate alloc;
 
 #[allow(unused_imports, dead_code)]
 pub mod common {
 
-    use core::cmp::Ordering;
-    use core::mem;
-
-    extern crate flatbuffers;
-    use self::flatbuffers::{EndianScalar, Follow};
-
     #[deprecated(
         since = "2.0.0",
         note = "Use associated constants instead. This will no longer be generated in 2021."
@@ -55,8 +43,8 @@ pub mod common {
             }
         }
     }
-    impl core::fmt::Debug for ContractType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContractType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -64,24 +52,24 @@ pub mod common {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for ContractType {
+    impl<'a> ::flatbuffers::Follow<'a> for ContractType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for ContractType {
+    impl ::flatbuffers::Push for ContractType {
         type Output = ContractType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for ContractType {
+    impl ::flatbuffers::EndianScalar for ContractType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -95,18 +83,17 @@ pub mod common {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for ContractType {
+    impl<'a> ::flatbuffers::Verifiable for ContractType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for ContractType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for ContractType {}
     pub struct ContractTypeUnionTableOffset {}
 
     #[deprecated(
@@ -172,8 +159,8 @@ pub mod common {
             }
         }
     }
-    impl core::fmt::Debug for UpdateDataType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for UpdateDataType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -181,24 +168,24 @@ pub mod common {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for UpdateDataType {
+    impl<'a> ::flatbuffers::Follow<'a> for UpdateDataType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for UpdateDataType {
+    impl ::flatbuffers::Push for UpdateDataType {
         type Output = UpdateDataType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for UpdateDataType {
+    impl ::flatbuffers::EndianScalar for UpdateDataType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -212,42 +199,41 @@ pub mod common {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for UpdateDataType {
+    impl<'a> ::flatbuffers::Verifiable for UpdateDataType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for UpdateDataType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for UpdateDataType {}
     pub struct UpdateDataTypeUnionTableOffset {}
 
     pub enum ContractInstanceIdOffset {}
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ContractInstanceId<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ContractInstanceId<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ContractInstanceId<'a> {
         type Inner = ContractInstanceId<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ContractInstanceId<'a> {
-        pub const VT_DATA: flatbuffers::VOffsetT = 4;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ContractInstanceId { _tab: table }
         }
         #[allow(unused_mut)]
@@ -255,11 +241,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ContractInstanceIdArgs<'args>,
-        ) -> flatbuffers::WIPOffset<ContractInstanceId<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ContractInstanceId<'bldr>> {
             let mut builder = ContractInstanceIdBuilder::new(_fbb);
             if let Some(x) = args.data {
                 builder.add_data(x);
@@ -268,13 +254,13 @@ pub mod common {
         }
 
         #[inline]
-        pub fn data(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ContractInstanceId::VT_DATA,
                         None,
                     )
@@ -283,15 +269,14 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for ContractInstanceId<'_> {
+    impl ::flatbuffers::Verifiable for ContractInstanceId<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "data",
                     Self::VT_DATA,
                     true,
@@ -301,7 +286,7 @@ pub mod common {
         }
     }
     pub struct ContractInstanceIdArgs<'a> {
-        pub data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for ContractInstanceIdArgs<'a> {
         #[inline]
@@ -312,19 +297,19 @@ pub mod common {
         }
     }
 
-    pub struct ContractInstanceIdBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ContractInstanceIdBuilder<'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> ContractInstanceIdBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractInstanceIdBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(ContractInstanceId::VT_DATA, data);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ContractInstanceId::VT_DATA, data);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ContractInstanceIdBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ContractInstanceIdBuilder {
@@ -333,15 +318,15 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ContractInstanceId<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ContractInstanceId<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, ContractInstanceId::VT_DATA, "data");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ContractInstanceId<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContractInstanceId<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ContractInstanceId");
             ds.field("data", &self.data());
             ds.finish()
@@ -351,25 +336,25 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ContractKey<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ContractKey<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ContractKey<'a> {
         type Inner = ContractKey<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ContractKey<'a> {
-        pub const VT_INSTANCE: flatbuffers::VOffsetT = 4;
-        pub const VT_CODE: flatbuffers::VOffsetT = 6;
+        pub const VT_INSTANCE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CODE: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ContractKey { _tab: table }
         }
         #[allow(unused_mut)]
@@ -377,11 +362,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ContractKeyArgs<'args>,
-        ) -> flatbuffers::WIPOffset<ContractKey<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ContractKey<'bldr>> {
             let mut builder = ContractKeyBuilder::new(_fbb);
             if let Some(x) = args.code {
                 builder.add_code(x);
@@ -399,7 +384,7 @@ pub mod common {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
+                    .get::<::flatbuffers::ForwardsUOffset<ContractInstanceId>>(
                         ContractKey::VT_INSTANCE,
                         None,
                     )
@@ -407,13 +392,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn code(&self) -> Option<flatbuffers::Vector<'a, u8>> {
+        pub fn code(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ContractKey::VT_CODE,
                         None,
                     )
@@ -421,20 +406,19 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for ContractKey<'_> {
+    impl ::flatbuffers::Verifiable for ContractKey<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<ContractInstanceId>>(
                     "instance",
                     Self::VT_INSTANCE,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "code",
                     Self::VT_CODE,
                     false,
@@ -444,8 +428,8 @@ pub mod common {
         }
     }
     pub struct ContractKeyArgs<'a> {
-        pub instance: Option<flatbuffers::WIPOffset<ContractInstanceId<'a>>>,
-        pub code: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub instance: Option<::flatbuffers::WIPOffset<ContractInstanceId<'a>>>,
+        pub code: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for ContractKeyArgs<'a> {
         #[inline]
@@ -457,27 +441,27 @@ pub mod common {
         }
     }
 
-    pub struct ContractKeyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ContractKeyBuilder<'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> ContractKeyBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractKeyBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_instance(&mut self, instance: flatbuffers::WIPOffset<ContractInstanceId<'b>>) {
+        pub fn add_instance(&mut self, instance: ::flatbuffers::WIPOffset<ContractInstanceId<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<ContractInstanceId>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<ContractInstanceId>>(
                     ContractKey::VT_INSTANCE,
                     instance,
                 );
         }
         #[inline]
-        pub fn add_code(&mut self, code: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_code(&mut self, code: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(ContractKey::VT_CODE, code);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ContractKey::VT_CODE, code);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ContractKeyBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ContractKeyBuilder {
@@ -486,15 +470,15 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ContractKey<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ContractKey<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, ContractKey::VT_INSTANCE, "instance");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ContractKey<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContractKey<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ContractKey");
             ds.field("instance", &self.instance());
             ds.field("code", &self.code());
@@ -505,25 +489,25 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct SecretsId<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for SecretsId<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for SecretsId<'a> {
         type Inner = SecretsId<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> SecretsId<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_HASH: flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_HASH: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             SecretsId { _tab: table }
         }
         #[allow(unused_mut)]
@@ -531,11 +515,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args SecretsIdArgs<'args>,
-        ) -> flatbuffers::WIPOffset<SecretsId<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<SecretsId<'bldr>> {
             let mut builder = SecretsIdBuilder::new(_fbb);
             if let Some(x) = args.hash {
                 builder.add_hash(x);
@@ -547,13 +531,13 @@ pub mod common {
         }
 
         #[inline]
-        pub fn key(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn key(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         SecretsId::VT_KEY,
                         None,
                     )
@@ -561,13 +545,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn hash(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn hash(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         SecretsId::VT_HASH,
                         None,
                     )
@@ -576,20 +560,19 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for SecretsId<'_> {
+    impl ::flatbuffers::Verifiable for SecretsId<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "hash",
                     Self::VT_HASH,
                     true,
@@ -599,8 +582,8 @@ pub mod common {
         }
     }
     pub struct SecretsIdArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub hash: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub key: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for SecretsIdArgs<'a> {
         #[inline]
@@ -612,24 +595,24 @@ pub mod common {
         }
     }
 
-    pub struct SecretsIdBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct SecretsIdBuilder<'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> SecretsIdBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SecretsIdBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(SecretsId::VT_KEY, key);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(SecretsId::VT_KEY, key);
         }
         #[inline]
-        pub fn add_hash(&mut self, hash: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_hash(&mut self, hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(SecretsId::VT_HASH, hash);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(SecretsId::VT_HASH, hash);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> SecretsIdBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             SecretsIdBuilder {
@@ -638,16 +621,16 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<SecretsId<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<SecretsId<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, SecretsId::VT_KEY, "key");
             self.fbb_.required(o, SecretsId::VT_HASH, "hash");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for SecretsId<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for SecretsId<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("SecretsId");
             ds.field("key", &self.key());
             ds.field("hash", &self.hash());
@@ -658,25 +641,25 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ContractCode<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ContractCode<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ContractCode<'a> {
         type Inner = ContractCode<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ContractCode<'a> {
-        pub const VT_DATA: flatbuffers::VOffsetT = 4;
-        pub const VT_CODE_HASH: flatbuffers::VOffsetT = 6;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CODE_HASH: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ContractCode { _tab: table }
         }
         #[allow(unused_mut)]
@@ -684,11 +667,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ContractCodeArgs<'args>,
-        ) -> flatbuffers::WIPOffset<ContractCode<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ContractCode<'bldr>> {
             let mut builder = ContractCodeBuilder::new(_fbb);
             if let Some(x) = args.code_hash {
                 builder.add_code_hash(x);
@@ -700,13 +683,13 @@ pub mod common {
         }
 
         #[inline]
-        pub fn data(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ContractCode::VT_DATA,
                         None,
                     )
@@ -714,13 +697,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn code_hash(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn code_hash(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ContractCode::VT_CODE_HASH,
                         None,
                     )
@@ -729,20 +712,19 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for ContractCode<'_> {
+    impl ::flatbuffers::Verifiable for ContractCode<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "data",
                     Self::VT_DATA,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "code_hash",
                     Self::VT_CODE_HASH,
                     true,
@@ -752,8 +734,8 @@ pub mod common {
         }
     }
     pub struct ContractCodeArgs<'a> {
-        pub data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub code_hash: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub code_hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for ContractCodeArgs<'a> {
         #[inline]
@@ -765,29 +747,29 @@ pub mod common {
         }
     }
 
-    pub struct ContractCodeBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ContractCodeBuilder<'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> ContractCodeBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractCodeBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(ContractCode::VT_DATA, data);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ContractCode::VT_DATA, data);
         }
         #[inline]
         pub fn add_code_hash(
             &mut self,
-            code_hash: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            code_hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 ContractCode::VT_CODE_HASH,
                 code_hash,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ContractCodeBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ContractCodeBuilder {
@@ -796,17 +778,17 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ContractCode<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ContractCode<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, ContractCode::VT_DATA, "data");
             self.fbb_
                 .required(o, ContractCode::VT_CODE_HASH, "code_hash");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ContractCode<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContractCode<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ContractCode");
             ds.field("data", &self.data());
             ds.field("code_hash", &self.code_hash());
@@ -817,27 +799,26 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ApplicationMessage<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ApplicationMessage<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ApplicationMessage<'a> {
         type Inner = ApplicationMessage<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ApplicationMessage<'a> {
-        pub const VT_APP: flatbuffers::VOffsetT = 4;
-        pub const VT_PAYLOAD: flatbuffers::VOffsetT = 6;
-        pub const VT_CONTEXT: flatbuffers::VOffsetT = 8;
-        pub const VT_PROCESSED: flatbuffers::VOffsetT = 10;
+        pub const VT_PAYLOAD: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CONTEXT: ::flatbuffers::VOffsetT = 6;
+        pub const VT_PROCESSED: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ApplicationMessage { _tab: table }
         }
         #[allow(unused_mut)]
@@ -845,11 +826,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ApplicationMessageArgs<'args>,
-        ) -> flatbuffers::WIPOffset<ApplicationMessage<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ApplicationMessage<'bldr>> {
             let mut builder = ApplicationMessageBuilder::new(_fbb);
             if let Some(x) = args.context {
                 builder.add_context(x);
@@ -857,35 +838,18 @@ pub mod common {
             if let Some(x) = args.payload {
                 builder.add_payload(x);
             }
-            if let Some(x) = args.app {
-                builder.add_app(x);
-            }
             builder.add_processed(args.processed);
             builder.finish()
         }
 
         #[inline]
-        pub fn app(&self) -> ContractInstanceId<'a> {
-            // Safety:
-            // Created from valid Table for this object
-            // which contains a valid value in this slot
-            unsafe {
-                self._tab
-                    .get::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
-                        ApplicationMessage::VT_APP,
-                        None,
-                    )
-                    .unwrap()
-            }
-        }
-        #[inline]
-        pub fn payload(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn payload(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ApplicationMessage::VT_PAYLOAD,
                         None,
                     )
@@ -893,13 +857,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn context(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn context(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ApplicationMessage::VT_CONTEXT,
                         None,
                     )
@@ -919,25 +883,19 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for ApplicationMessage<'_> {
+    impl ::flatbuffers::Verifiable for ApplicationMessage<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
-                    "app",
-                    Self::VT_APP,
-                    true,
-                )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "payload",
                     Self::VT_PAYLOAD,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "context",
                     Self::VT_CONTEXT,
                     true,
@@ -948,16 +906,14 @@ pub mod common {
         }
     }
     pub struct ApplicationMessageArgs<'a> {
-        pub app: Option<flatbuffers::WIPOffset<ContractInstanceId<'a>>>,
-        pub payload: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub context: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub payload: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub context: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
         pub processed: bool,
     }
     impl<'a> Default for ApplicationMessageArgs<'a> {
         #[inline]
         fn default() -> Self {
             ApplicationMessageArgs {
-                app: None,     // required field
                 payload: None, // required field
                 context: None, // required field
                 processed: false,
@@ -965,25 +921,17 @@ pub mod common {
         }
     }
 
-    pub struct ApplicationMessageBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ApplicationMessageBuilder<'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> ApplicationMessageBuilder<'a, 'b, A> {
-        #[inline]
-        pub fn add_app(&mut self, app: flatbuffers::WIPOffset<ContractInstanceId<'b>>) {
-            self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<ContractInstanceId>>(
-                    ApplicationMessage::VT_APP,
-                    app,
-                );
-        }
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ApplicationMessageBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_payload(
             &mut self,
-            payload: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            payload: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 ApplicationMessage::VT_PAYLOAD,
                 payload,
             );
@@ -991,9 +939,9 @@ pub mod common {
         #[inline]
         pub fn add_context(
             &mut self,
-            context: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            context: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 ApplicationMessage::VT_CONTEXT,
                 context,
             );
@@ -1005,7 +953,7 @@ pub mod common {
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ApplicationMessageBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ApplicationMessageBuilder {
@@ -1014,21 +962,19 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ApplicationMessage<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ApplicationMessage<'a>> {
             let o = self.fbb_.end_table(self.start_);
-            self.fbb_.required(o, ApplicationMessage::VT_APP, "app");
             self.fbb_
                 .required(o, ApplicationMessage::VT_PAYLOAD, "payload");
             self.fbb_
                 .required(o, ApplicationMessage::VT_CONTEXT, "context");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ApplicationMessage<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ApplicationMessage<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ApplicationMessage");
-            ds.field("app", &self.app());
             ds.field("payload", &self.payload());
             ds.field("context", &self.context());
             ds.field("processed", &self.processed());
@@ -1039,26 +985,26 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct WasmContractV1<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for WasmContractV1<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for WasmContractV1<'a> {
         type Inner = WasmContractV1<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> WasmContractV1<'a> {
-        pub const VT_DATA: flatbuffers::VOffsetT = 4;
-        pub const VT_PARAMETERS: flatbuffers::VOffsetT = 6;
-        pub const VT_KEY: flatbuffers::VOffsetT = 8;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 4;
+        pub const VT_PARAMETERS: ::flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             WasmContractV1 { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1066,11 +1012,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args WasmContractV1Args<'args>,
-        ) -> flatbuffers::WIPOffset<WasmContractV1<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<WasmContractV1<'bldr>> {
             let mut builder = WasmContractV1Builder::new(_fbb);
             if let Some(x) = args.key {
                 builder.add_key(x);
@@ -1091,7 +1037,7 @@ pub mod common {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<ContractCode>>(
+                    .get::<::flatbuffers::ForwardsUOffset<ContractCode>>(
                         WasmContractV1::VT_DATA,
                         None,
                     )
@@ -1099,13 +1045,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn parameters(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn parameters(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         WasmContractV1::VT_PARAMETERS,
                         None,
                     )
@@ -1119,31 +1065,33 @@ pub mod common {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<ContractKey>>(WasmContractV1::VT_KEY, None)
+                    .get::<::flatbuffers::ForwardsUOffset<ContractKey>>(
+                        WasmContractV1::VT_KEY,
+                        None,
+                    )
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for WasmContractV1<'_> {
+    impl ::flatbuffers::Verifiable for WasmContractV1<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<ContractCode>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<ContractCode>>(
                     "data",
                     Self::VT_DATA,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "parameters",
                     Self::VT_PARAMETERS,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<ContractKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<ContractKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
@@ -1153,9 +1101,9 @@ pub mod common {
         }
     }
     pub struct WasmContractV1Args<'a> {
-        pub data: Option<flatbuffers::WIPOffset<ContractCode<'a>>>,
-        pub parameters: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub key: Option<flatbuffers::WIPOffset<ContractKey<'a>>>,
+        pub data: Option<::flatbuffers::WIPOffset<ContractCode<'a>>>,
+        pub parameters: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub key: Option<::flatbuffers::WIPOffset<ContractKey<'a>>>,
     }
     impl<'a> Default for WasmContractV1Args<'a> {
         #[inline]
@@ -1168,15 +1116,15 @@ pub mod common {
         }
     }
 
-    pub struct WasmContractV1Builder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct WasmContractV1Builder<'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> WasmContractV1Builder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WasmContractV1Builder<'a, 'b, A> {
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<ContractCode<'b>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<ContractCode<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<ContractCode>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<ContractCode>>(
                     WasmContractV1::VT_DATA,
                     data,
                 );
@@ -1184,24 +1132,24 @@ pub mod common {
         #[inline]
         pub fn add_parameters(
             &mut self,
-            parameters: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            parameters: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 WasmContractV1::VT_PARAMETERS,
                 parameters,
             );
         }
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<ContractKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<ContractKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<ContractKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<ContractKey>>(
                     WasmContractV1::VT_KEY,
                     key,
                 );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> WasmContractV1Builder<'a, 'b, A> {
             let start = _fbb.start_table();
             WasmContractV1Builder {
@@ -1210,18 +1158,18 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<WasmContractV1<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<WasmContractV1<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, WasmContractV1::VT_DATA, "data");
             self.fbb_
                 .required(o, WasmContractV1::VT_PARAMETERS, "parameters");
             self.fbb_.required(o, WasmContractV1::VT_KEY, "key");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for WasmContractV1<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for WasmContractV1<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("WasmContractV1");
             ds.field("data", &self.data());
             ds.field("parameters", &self.parameters());
@@ -1233,25 +1181,25 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ContractContainer<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ContractContainer<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ContractContainer<'a> {
         type Inner = ContractContainer<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ContractContainer<'a> {
-        pub const VT_CONTRACT_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_CONTRACT: flatbuffers::VOffsetT = 6;
+        pub const VT_CONTRACT_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CONTRACT: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ContractContainer { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1259,11 +1207,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ContractContainerArgs,
-        ) -> flatbuffers::WIPOffset<ContractContainer<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ContractContainer<'bldr>> {
             let mut builder = ContractContainerBuilder::new(_fbb);
             if let Some(x) = args.contract {
                 builder.add_contract(x);
@@ -1287,13 +1235,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn contract(&self) -> flatbuffers::Table<'a> {
+        pub fn contract(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         ContractContainer::VT_CONTRACT,
                         None,
                     )
@@ -1315,13 +1263,12 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for ContractContainer<'_> {
+    impl ::flatbuffers::Verifiable for ContractContainer<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
                 .visit_union::<ContractType, _>(
                     "contract_type",
@@ -1331,7 +1278,7 @@ pub mod common {
                     true,
                     |key, v, pos| match key {
                         ContractType::WasmContractV1 => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<WasmContractV1>>(
+                            .verify_union_variant::<::flatbuffers::ForwardsUOffset<WasmContractV1>>(
                                 "ContractType::WasmContractV1",
                                 pos,
                             ),
@@ -1344,7 +1291,7 @@ pub mod common {
     }
     pub struct ContractContainerArgs {
         pub contract_type: ContractType,
-        pub contract: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub contract: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for ContractContainerArgs {
         #[inline]
@@ -1356,11 +1303,11 @@ pub mod common {
         }
     }
 
-    pub struct ContractContainerBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ContractContainerBuilder<'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> ContractContainerBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractContainerBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_contract_type(&mut self, contract_type: ContractType) {
             self.fbb_.push_slot::<ContractType>(
@@ -1372,16 +1319,16 @@ pub mod common {
         #[inline]
         pub fn add_contract(
             &mut self,
-            contract: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            contract: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 ContractContainer::VT_CONTRACT,
                 contract,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ContractContainerBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ContractContainerBuilder {
@@ -1390,16 +1337,16 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ContractContainer<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ContractContainer<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, ContractContainer::VT_CONTRACT, "contract");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ContractContainer<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContractContainer<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ContractContainer");
             ds.field("contract_type", &self.contract_type());
             match self.contract_type() {
@@ -1425,24 +1372,24 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct StateUpdate<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for StateUpdate<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for StateUpdate<'a> {
         type Inner = StateUpdate<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> StateUpdate<'a> {
-        pub const VT_STATE: flatbuffers::VOffsetT = 4;
+        pub const VT_STATE: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             StateUpdate { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1450,11 +1397,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args StateUpdateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<StateUpdate<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<StateUpdate<'bldr>> {
             let mut builder = StateUpdateBuilder::new(_fbb);
             if let Some(x) = args.state {
                 builder.add_state(x);
@@ -1463,13 +1410,13 @@ pub mod common {
         }
 
         #[inline]
-        pub fn state(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         StateUpdate::VT_STATE,
                         None,
                     )
@@ -1478,15 +1425,14 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for StateUpdate<'_> {
+    impl ::flatbuffers::Verifiable for StateUpdate<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "state",
                     Self::VT_STATE,
                     true,
@@ -1496,7 +1442,7 @@ pub mod common {
         }
     }
     pub struct StateUpdateArgs<'a> {
-        pub state: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for StateUpdateArgs<'a> {
         #[inline]
@@ -1507,19 +1453,22 @@ pub mod common {
         }
     }
 
-    pub struct StateUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct StateUpdateBuilder<'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> StateUpdateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StateUpdateBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_state(&mut self, state: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_state(
+            &mut self,
+            state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(StateUpdate::VT_STATE, state);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(StateUpdate::VT_STATE, state);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> StateUpdateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             StateUpdateBuilder {
@@ -1528,15 +1477,15 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<StateUpdate<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<StateUpdate<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, StateUpdate::VT_STATE, "state");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for StateUpdate<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for StateUpdate<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("StateUpdate");
             ds.field("state", &self.state());
             ds.finish()
@@ -1546,24 +1495,24 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct DeltaUpdate<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for DeltaUpdate<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for DeltaUpdate<'a> {
         type Inner = DeltaUpdate<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> DeltaUpdate<'a> {
-        pub const VT_DELTA: flatbuffers::VOffsetT = 4;
+        pub const VT_DELTA: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             DeltaUpdate { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1571,11 +1520,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args DeltaUpdateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<DeltaUpdate<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<DeltaUpdate<'bldr>> {
             let mut builder = DeltaUpdateBuilder::new(_fbb);
             if let Some(x) = args.delta {
                 builder.add_delta(x);
@@ -1584,13 +1533,13 @@ pub mod common {
         }
 
         #[inline]
-        pub fn delta(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn delta(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         DeltaUpdate::VT_DELTA,
                         None,
                     )
@@ -1599,15 +1548,14 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for DeltaUpdate<'_> {
+    impl ::flatbuffers::Verifiable for DeltaUpdate<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "delta",
                     Self::VT_DELTA,
                     true,
@@ -1617,7 +1565,7 @@ pub mod common {
         }
     }
     pub struct DeltaUpdateArgs<'a> {
-        pub delta: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub delta: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for DeltaUpdateArgs<'a> {
         #[inline]
@@ -1628,19 +1576,22 @@ pub mod common {
         }
     }
 
-    pub struct DeltaUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct DeltaUpdateBuilder<'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> DeltaUpdateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DeltaUpdateBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_delta(&mut self, delta: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_delta(
+            &mut self,
+            delta: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(DeltaUpdate::VT_DELTA, delta);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(DeltaUpdate::VT_DELTA, delta);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> DeltaUpdateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             DeltaUpdateBuilder {
@@ -1649,15 +1600,15 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<DeltaUpdate<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<DeltaUpdate<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, DeltaUpdate::VT_DELTA, "delta");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for DeltaUpdate<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DeltaUpdate<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("DeltaUpdate");
             ds.field("delta", &self.delta());
             ds.finish()
@@ -1667,25 +1618,25 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct StateAndDeltaUpdate<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for StateAndDeltaUpdate<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for StateAndDeltaUpdate<'a> {
         type Inner = StateAndDeltaUpdate<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> StateAndDeltaUpdate<'a> {
-        pub const VT_STATE: flatbuffers::VOffsetT = 4;
-        pub const VT_DELTA: flatbuffers::VOffsetT = 6;
+        pub const VT_STATE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_DELTA: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             StateAndDeltaUpdate { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1693,11 +1644,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args StateAndDeltaUpdateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<StateAndDeltaUpdate<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<StateAndDeltaUpdate<'bldr>> {
             let mut builder = StateAndDeltaUpdateBuilder::new(_fbb);
             if let Some(x) = args.delta {
                 builder.add_delta(x);
@@ -1709,13 +1660,13 @@ pub mod common {
         }
 
         #[inline]
-        pub fn state(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         StateAndDeltaUpdate::VT_STATE,
                         None,
                     )
@@ -1723,13 +1674,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn delta(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn delta(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         StateAndDeltaUpdate::VT_DELTA,
                         None,
                     )
@@ -1738,20 +1689,19 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for StateAndDeltaUpdate<'_> {
+    impl ::flatbuffers::Verifiable for StateAndDeltaUpdate<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "state",
                     Self::VT_STATE,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "delta",
                     Self::VT_DELTA,
                     true,
@@ -1761,8 +1711,8 @@ pub mod common {
         }
     }
     pub struct StateAndDeltaUpdateArgs<'a> {
-        pub state: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub delta: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub delta: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for StateAndDeltaUpdateArgs<'a> {
         #[inline]
@@ -1774,28 +1724,34 @@ pub mod common {
         }
     }
 
-    pub struct StateAndDeltaUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct StateAndDeltaUpdateBuilder<'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> StateAndDeltaUpdateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StateAndDeltaUpdateBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_state(&mut self, state: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+        pub fn add_state(
+            &mut self,
+            state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 StateAndDeltaUpdate::VT_STATE,
                 state,
             );
         }
         #[inline]
-        pub fn add_delta(&mut self, delta: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+        pub fn add_delta(
+            &mut self,
+            delta: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 StateAndDeltaUpdate::VT_DELTA,
                 delta,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> StateAndDeltaUpdateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             StateAndDeltaUpdateBuilder {
@@ -1804,18 +1760,18 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<StateAndDeltaUpdate<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<StateAndDeltaUpdate<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, StateAndDeltaUpdate::VT_STATE, "state");
             self.fbb_
                 .required(o, StateAndDeltaUpdate::VT_DELTA, "delta");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for StateAndDeltaUpdate<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for StateAndDeltaUpdate<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("StateAndDeltaUpdate");
             ds.field("state", &self.state());
             ds.field("delta", &self.delta());
@@ -1826,25 +1782,25 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct RelatedStateUpdate<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for RelatedStateUpdate<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for RelatedStateUpdate<'a> {
         type Inner = RelatedStateUpdate<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> RelatedStateUpdate<'a> {
-        pub const VT_RELATED_TO: flatbuffers::VOffsetT = 4;
-        pub const VT_STATE: flatbuffers::VOffsetT = 6;
+        pub const VT_RELATED_TO: ::flatbuffers::VOffsetT = 4;
+        pub const VT_STATE: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             RelatedStateUpdate { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1852,11 +1808,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args RelatedStateUpdateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<RelatedStateUpdate<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<RelatedStateUpdate<'bldr>> {
             let mut builder = RelatedStateUpdateBuilder::new(_fbb);
             if let Some(x) = args.state {
                 builder.add_state(x);
@@ -1874,7 +1830,7 @@ pub mod common {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
+                    .get::<::flatbuffers::ForwardsUOffset<ContractInstanceId>>(
                         RelatedStateUpdate::VT_RELATED_TO,
                         None,
                     )
@@ -1882,13 +1838,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn state(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         RelatedStateUpdate::VT_STATE,
                         None,
                     )
@@ -1897,20 +1853,19 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for RelatedStateUpdate<'_> {
+    impl ::flatbuffers::Verifiable for RelatedStateUpdate<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<ContractInstanceId>>(
                     "related_to",
                     Self::VT_RELATED_TO,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "state",
                     Self::VT_STATE,
                     true,
@@ -1920,8 +1875,8 @@ pub mod common {
         }
     }
     pub struct RelatedStateUpdateArgs<'a> {
-        pub related_to: Option<flatbuffers::WIPOffset<ContractInstanceId<'a>>>,
-        pub state: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub related_to: Option<::flatbuffers::WIPOffset<ContractInstanceId<'a>>>,
+        pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for RelatedStateUpdateArgs<'a> {
         #[inline]
@@ -1933,30 +1888,35 @@ pub mod common {
         }
     }
 
-    pub struct RelatedStateUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct RelatedStateUpdateBuilder<'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> RelatedStateUpdateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedStateUpdateBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_related_to(
             &mut self,
-            related_to: flatbuffers::WIPOffset<ContractInstanceId<'b>>,
+            related_to: ::flatbuffers::WIPOffset<ContractInstanceId<'b>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<ContractInstanceId>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<ContractInstanceId>>(
                     RelatedStateUpdate::VT_RELATED_TO,
                     related_to,
                 );
         }
         #[inline]
-        pub fn add_state(&mut self, state: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
-            self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(RelatedStateUpdate::VT_STATE, state);
+        pub fn add_state(
+            &mut self,
+            state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
+                RelatedStateUpdate::VT_STATE,
+                state,
+            );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> RelatedStateUpdateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             RelatedStateUpdateBuilder {
@@ -1965,17 +1925,17 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<RelatedStateUpdate<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<RelatedStateUpdate<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, RelatedStateUpdate::VT_RELATED_TO, "related_to");
             self.fbb_.required(o, RelatedStateUpdate::VT_STATE, "state");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for RelatedStateUpdate<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for RelatedStateUpdate<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("RelatedStateUpdate");
             ds.field("related_to", &self.related_to());
             ds.field("state", &self.state());
@@ -1986,25 +1946,25 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct RelatedDeltaUpdate<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for RelatedDeltaUpdate<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for RelatedDeltaUpdate<'a> {
         type Inner = RelatedDeltaUpdate<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> RelatedDeltaUpdate<'a> {
-        pub const VT_RELATED_TO: flatbuffers::VOffsetT = 4;
-        pub const VT_DELTA: flatbuffers::VOffsetT = 6;
+        pub const VT_RELATED_TO: ::flatbuffers::VOffsetT = 4;
+        pub const VT_DELTA: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             RelatedDeltaUpdate { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2012,11 +1972,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args RelatedDeltaUpdateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<RelatedDeltaUpdate<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<RelatedDeltaUpdate<'bldr>> {
             let mut builder = RelatedDeltaUpdateBuilder::new(_fbb);
             if let Some(x) = args.delta {
                 builder.add_delta(x);
@@ -2034,7 +1994,7 @@ pub mod common {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
+                    .get::<::flatbuffers::ForwardsUOffset<ContractInstanceId>>(
                         RelatedDeltaUpdate::VT_RELATED_TO,
                         None,
                     )
@@ -2042,13 +2002,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn delta(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn delta(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         RelatedDeltaUpdate::VT_DELTA,
                         None,
                     )
@@ -2057,20 +2017,19 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for RelatedDeltaUpdate<'_> {
+    impl ::flatbuffers::Verifiable for RelatedDeltaUpdate<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<ContractInstanceId>>(
                     "related_to",
                     Self::VT_RELATED_TO,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "delta",
                     Self::VT_DELTA,
                     true,
@@ -2080,8 +2039,8 @@ pub mod common {
         }
     }
     pub struct RelatedDeltaUpdateArgs<'a> {
-        pub related_to: Option<flatbuffers::WIPOffset<ContractInstanceId<'a>>>,
-        pub delta: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub related_to: Option<::flatbuffers::WIPOffset<ContractInstanceId<'a>>>,
+        pub delta: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for RelatedDeltaUpdateArgs<'a> {
         #[inline]
@@ -2093,30 +2052,35 @@ pub mod common {
         }
     }
 
-    pub struct RelatedDeltaUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct RelatedDeltaUpdateBuilder<'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> RelatedDeltaUpdateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedDeltaUpdateBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_related_to(
             &mut self,
-            related_to: flatbuffers::WIPOffset<ContractInstanceId<'b>>,
+            related_to: ::flatbuffers::WIPOffset<ContractInstanceId<'b>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<ContractInstanceId>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<ContractInstanceId>>(
                     RelatedDeltaUpdate::VT_RELATED_TO,
                     related_to,
                 );
         }
         #[inline]
-        pub fn add_delta(&mut self, delta: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
-            self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(RelatedDeltaUpdate::VT_DELTA, delta);
+        pub fn add_delta(
+            &mut self,
+            delta: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
+                RelatedDeltaUpdate::VT_DELTA,
+                delta,
+            );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> RelatedDeltaUpdateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             RelatedDeltaUpdateBuilder {
@@ -2125,17 +2089,17 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<RelatedDeltaUpdate<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<RelatedDeltaUpdate<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, RelatedDeltaUpdate::VT_RELATED_TO, "related_to");
             self.fbb_.required(o, RelatedDeltaUpdate::VT_DELTA, "delta");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for RelatedDeltaUpdate<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for RelatedDeltaUpdate<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("RelatedDeltaUpdate");
             ds.field("related_to", &self.related_to());
             ds.field("delta", &self.delta());
@@ -2146,26 +2110,26 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct RelatedStateAndDeltaUpdate<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for RelatedStateAndDeltaUpdate<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for RelatedStateAndDeltaUpdate<'a> {
         type Inner = RelatedStateAndDeltaUpdate<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> RelatedStateAndDeltaUpdate<'a> {
-        pub const VT_RELATED_TO: flatbuffers::VOffsetT = 4;
-        pub const VT_STATE: flatbuffers::VOffsetT = 6;
-        pub const VT_DELTA: flatbuffers::VOffsetT = 8;
+        pub const VT_RELATED_TO: ::flatbuffers::VOffsetT = 4;
+        pub const VT_STATE: ::flatbuffers::VOffsetT = 6;
+        pub const VT_DELTA: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             RelatedStateAndDeltaUpdate { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2173,11 +2137,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args RelatedStateAndDeltaUpdateArgs<'args>,
-        ) -> flatbuffers::WIPOffset<RelatedStateAndDeltaUpdate<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<RelatedStateAndDeltaUpdate<'bldr>> {
             let mut builder = RelatedStateAndDeltaUpdateBuilder::new(_fbb);
             if let Some(x) = args.delta {
                 builder.add_delta(x);
@@ -2198,7 +2162,7 @@ pub mod common {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
+                    .get::<::flatbuffers::ForwardsUOffset<ContractInstanceId>>(
                         RelatedStateAndDeltaUpdate::VT_RELATED_TO,
                         None,
                     )
@@ -2206,13 +2170,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn state(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         RelatedStateAndDeltaUpdate::VT_STATE,
                         None,
                     )
@@ -2220,13 +2184,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn delta(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn delta(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         RelatedStateAndDeltaUpdate::VT_DELTA,
                         None,
                     )
@@ -2235,25 +2199,24 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for RelatedStateAndDeltaUpdate<'_> {
+    impl ::flatbuffers::Verifiable for RelatedStateAndDeltaUpdate<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<ContractInstanceId>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<ContractInstanceId>>(
                     "related_to",
                     Self::VT_RELATED_TO,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "state",
                     Self::VT_STATE,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "delta",
                     Self::VT_DELTA,
                     true,
@@ -2263,9 +2226,9 @@ pub mod common {
         }
     }
     pub struct RelatedStateAndDeltaUpdateArgs<'a> {
-        pub related_to: Option<flatbuffers::WIPOffset<ContractInstanceId<'a>>>,
-        pub state: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub delta: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub related_to: Option<::flatbuffers::WIPOffset<ContractInstanceId<'a>>>,
+        pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub delta: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for RelatedStateAndDeltaUpdateArgs<'a> {
         #[inline]
@@ -2278,39 +2241,45 @@ pub mod common {
         }
     }
 
-    pub struct RelatedStateAndDeltaUpdateBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct RelatedStateAndDeltaUpdateBuilder<'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> RelatedStateAndDeltaUpdateBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RelatedStateAndDeltaUpdateBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_related_to(
             &mut self,
-            related_to: flatbuffers::WIPOffset<ContractInstanceId<'b>>,
+            related_to: ::flatbuffers::WIPOffset<ContractInstanceId<'b>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<ContractInstanceId>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<ContractInstanceId>>(
                     RelatedStateAndDeltaUpdate::VT_RELATED_TO,
                     related_to,
                 );
         }
         #[inline]
-        pub fn add_state(&mut self, state: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+        pub fn add_state(
+            &mut self,
+            state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 RelatedStateAndDeltaUpdate::VT_STATE,
                 state,
             );
         }
         #[inline]
-        pub fn add_delta(&mut self, delta: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+        pub fn add_delta(
+            &mut self,
+            delta: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 RelatedStateAndDeltaUpdate::VT_DELTA,
                 delta,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> RelatedStateAndDeltaUpdateBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             RelatedStateAndDeltaUpdateBuilder {
@@ -2319,7 +2288,7 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<RelatedStateAndDeltaUpdate<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<RelatedStateAndDeltaUpdate<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, RelatedStateAndDeltaUpdate::VT_RELATED_TO, "related_to");
@@ -2327,12 +2296,12 @@ pub mod common {
                 .required(o, RelatedStateAndDeltaUpdate::VT_STATE, "state");
             self.fbb_
                 .required(o, RelatedStateAndDeltaUpdate::VT_DELTA, "delta");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for RelatedStateAndDeltaUpdate<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for RelatedStateAndDeltaUpdate<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("RelatedStateAndDeltaUpdate");
             ds.field("related_to", &self.related_to());
             ds.field("state", &self.state());
@@ -2344,25 +2313,25 @@ pub mod common {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct UpdateData<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for UpdateData<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for UpdateData<'a> {
         type Inner = UpdateData<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> UpdateData<'a> {
-        pub const VT_UPDATE_DATA_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_UPDATE_DATA: flatbuffers::VOffsetT = 6;
+        pub const VT_UPDATE_DATA_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_UPDATE_DATA: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             UpdateData { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2370,11 +2339,11 @@ pub mod common {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args UpdateDataArgs,
-        ) -> flatbuffers::WIPOffset<UpdateData<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<UpdateData<'bldr>> {
             let mut builder = UpdateDataBuilder::new(_fbb);
             if let Some(x) = args.update_data {
                 builder.add_update_data(x);
@@ -2398,13 +2367,13 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn update_data(&self) -> flatbuffers::Table<'a> {
+        pub fn update_data(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         UpdateData::VT_UPDATE_DATA,
                         None,
                     )
@@ -2498,22 +2467,21 @@ pub mod common {
         }
     }
 
-    impl flatbuffers::Verifiable for UpdateData<'_> {
+    impl ::flatbuffers::Verifiable for UpdateData<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
      .visit_union::<UpdateDataType, _>("update_data_type", Self::VT_UPDATE_DATA_TYPE, "update_data", Self::VT_UPDATE_DATA, true, |key, v, pos| {
         match key {
-          UpdateDataType::StateUpdate => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StateUpdate>>("UpdateDataType::StateUpdate", pos),
-          UpdateDataType::DeltaUpdate => v.verify_union_variant::<flatbuffers::ForwardsUOffset<DeltaUpdate>>("UpdateDataType::DeltaUpdate", pos),
-          UpdateDataType::StateAndDeltaUpdate => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StateAndDeltaUpdate>>("UpdateDataType::StateAndDeltaUpdate", pos),
-          UpdateDataType::RelatedStateUpdate => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RelatedStateUpdate>>("UpdateDataType::RelatedStateUpdate", pos),
-          UpdateDataType::RelatedDeltaUpdate => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RelatedDeltaUpdate>>("UpdateDataType::RelatedDeltaUpdate", pos),
-          UpdateDataType::RelatedStateAndDeltaUpdate => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RelatedStateAndDeltaUpdate>>("UpdateDataType::RelatedStateAndDeltaUpdate", pos),
+          UpdateDataType::StateUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<StateUpdate>>("UpdateDataType::StateUpdate", pos),
+          UpdateDataType::DeltaUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<DeltaUpdate>>("UpdateDataType::DeltaUpdate", pos),
+          UpdateDataType::StateAndDeltaUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<StateAndDeltaUpdate>>("UpdateDataType::StateAndDeltaUpdate", pos),
+          UpdateDataType::RelatedStateUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RelatedStateUpdate>>("UpdateDataType::RelatedStateUpdate", pos),
+          UpdateDataType::RelatedDeltaUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RelatedDeltaUpdate>>("UpdateDataType::RelatedDeltaUpdate", pos),
+          UpdateDataType::RelatedStateAndDeltaUpdate => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RelatedStateAndDeltaUpdate>>("UpdateDataType::RelatedStateAndDeltaUpdate", pos),
           _ => Ok(()),
         }
      })?
@@ -2523,7 +2491,7 @@ pub mod common {
     }
     pub struct UpdateDataArgs {
         pub update_data_type: UpdateDataType,
-        pub update_data: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub update_data: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for UpdateDataArgs {
         #[inline]
@@ -2535,11 +2503,11 @@ pub mod common {
         }
     }
 
-    pub struct UpdateDataBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct UpdateDataBuilder<'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> UpdateDataBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UpdateDataBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_update_data_type(&mut self, update_data_type: UpdateDataType) {
             self.fbb_.push_slot::<UpdateDataType>(
@@ -2551,16 +2519,16 @@ pub mod common {
         #[inline]
         pub fn add_update_data(
             &mut self,
-            update_data: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            update_data: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 UpdateData::VT_UPDATE_DATA,
                 update_data,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> UpdateDataBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             UpdateDataBuilder {
@@ -2569,16 +2537,16 @@ pub mod common {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<UpdateData<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<UpdateData<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, UpdateData::VT_UPDATE_DATA, "update_data");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for UpdateData<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for UpdateData<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("UpdateData");
             ds.field("update_data_type", &self.update_data_type());
             match self.update_data_type() {
diff --git a/rust/src/generated/host_response_generated.rs b/rust/src/generated/host_response_generated.rs
index c7e535f..3126cd8 100644
--- a/rust/src/generated/host_response_generated.rs
+++ b/rust/src/generated/host_response_generated.rs
@@ -1,23 +1,13 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-
 // @generated
+extern crate alloc;
 
 use crate::common_generated::*;
-use core::cmp::Ordering;
-use core::mem;
-
-extern crate flatbuffers;
-use self::flatbuffers::{EndianScalar, Follow};
 
 #[allow(unused_imports, dead_code)]
 pub mod host_response {
 
     use crate::common_generated::*;
-    use core::cmp::Ordering;
-    use core::mem;
-
-    extern crate flatbuffers;
-    use self::flatbuffers::{EndianScalar, Follow};
 
     #[deprecated(
         since = "2.0.0",
@@ -78,8 +68,8 @@ pub mod host_response {
             }
         }
     }
-    impl core::fmt::Debug for ContractResponseType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContractResponseType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -87,24 +77,24 @@ pub mod host_response {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for ContractResponseType {
+    impl<'a> ::flatbuffers::Follow<'a> for ContractResponseType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for ContractResponseType {
+    impl ::flatbuffers::Push for ContractResponseType {
         type Output = ContractResponseType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for ContractResponseType {
+    impl ::flatbuffers::EndianScalar for ContractResponseType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -118,18 +108,17 @@ pub mod host_response {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for ContractResponseType {
+    impl<'a> ::flatbuffers::Verifiable for ContractResponseType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for ContractResponseType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for ContractResponseType {}
     pub struct ContractResponseTypeUnionTableOffset {}
 
     #[deprecated(
@@ -183,8 +172,8 @@ pub mod host_response {
             }
         }
     }
-    impl core::fmt::Debug for OutboundDelegateMsgType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for OutboundDelegateMsgType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -192,24 +181,24 @@ pub mod host_response {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for OutboundDelegateMsgType {
+    impl<'a> ::flatbuffers::Follow<'a> for OutboundDelegateMsgType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for OutboundDelegateMsgType {
+    impl ::flatbuffers::Push for OutboundDelegateMsgType {
         type Output = OutboundDelegateMsgType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for OutboundDelegateMsgType {
+    impl ::flatbuffers::EndianScalar for OutboundDelegateMsgType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -223,18 +212,17 @@ pub mod host_response {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for OutboundDelegateMsgType {
+    impl<'a> ::flatbuffers::Verifiable for OutboundDelegateMsgType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for OutboundDelegateMsgType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for OutboundDelegateMsgType {}
     pub struct OutboundDelegateMsgTypeUnionTableOffset {}
 
     #[deprecated(
@@ -300,8 +288,8 @@ pub mod host_response {
             }
         }
     }
-    impl core::fmt::Debug for HostResponseType {
-        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+    impl ::core::fmt::Debug for HostResponseType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
             if let Some(name) = self.variant_name() {
                 f.write_str(name)
             } else {
@@ -309,24 +297,24 @@ pub mod host_response {
             }
         }
     }
-    impl<'a> flatbuffers::Follow<'a> for HostResponseType {
+    impl<'a> ::flatbuffers::Follow<'a> for HostResponseType {
         type Inner = Self;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-            let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+            let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
             Self(b)
         }
     }
 
-    impl flatbuffers::Push for HostResponseType {
+    impl ::flatbuffers::Push for HostResponseType {
         type Output = HostResponseType;
         #[inline]
         unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+            unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
         }
     }
 
-    impl flatbuffers::EndianScalar for HostResponseType {
+    impl ::flatbuffers::EndianScalar for HostResponseType {
         type Scalar = u8;
         #[inline]
         fn to_little_endian(self) -> u8 {
@@ -340,44 +328,43 @@ pub mod host_response {
         }
     }
 
-    impl<'a> flatbuffers::Verifiable for HostResponseType {
+    impl<'a> ::flatbuffers::Verifiable for HostResponseType {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             u8::run_verifier(v, pos)
         }
     }
 
-    impl flatbuffers::SimpleToVerifyInSlice for HostResponseType {}
+    impl ::flatbuffers::SimpleToVerifyInSlice for HostResponseType {}
     pub struct HostResponseTypeUnionTableOffset {}
 
     pub enum GetResponseOffset {}
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct GetResponse<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for GetResponse<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for GetResponse<'a> {
         type Inner = GetResponse<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> GetResponse<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_CONTRACT: flatbuffers::VOffsetT = 6;
-        pub const VT_STATE: flatbuffers::VOffsetT = 8;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CONTRACT: ::flatbuffers::VOffsetT = 6;
+        pub const VT_STATE: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             GetResponse { _tab: table }
         }
         #[allow(unused_mut)]
@@ -385,11 +372,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args GetResponseArgs<'args>,
-        ) -> flatbuffers::WIPOffset<GetResponse<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<GetResponse<'bldr>> {
             let mut builder = GetResponseBuilder::new(_fbb);
             if let Some(x) = args.state {
                 builder.add_state(x);
@@ -410,7 +397,7 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                         GetResponse::VT_KEY,
                         None,
                     )
@@ -424,20 +411,20 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractContainer>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractContainer>>(
                         GetResponse::VT_CONTRACT,
                         None,
                     )
             }
         }
         #[inline]
-        pub fn state(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn state(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         GetResponse::VT_STATE,
                         None,
                     )
@@ -446,25 +433,24 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for GetResponse<'_> {
+    impl ::flatbuffers::Verifiable for GetResponse<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractContainer>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractContainer>>(
                     "contract",
                     Self::VT_CONTRACT,
                     false,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "state",
                     Self::VT_STATE,
                     true,
@@ -474,9 +460,9 @@ pub mod host_response {
         }
     }
     pub struct GetResponseArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
-        pub contract: Option<flatbuffers::WIPOffset<super::common::ContractContainer<'a>>>,
-        pub state: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub key: Option<::flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
+        pub contract: Option<::flatbuffers::WIPOffset<super::common::ContractContainer<'a>>>,
+        pub state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for GetResponseArgs<'a> {
         #[inline]
@@ -489,15 +475,15 @@ pub mod host_response {
         }
     }
 
-    pub struct GetResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct GetResponseBuilder<'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> GetResponseBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GetResponseBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractKey>>(
                     GetResponse::VT_KEY,
                     key,
                 );
@@ -505,22 +491,25 @@ pub mod host_response {
         #[inline]
         pub fn add_contract(
             &mut self,
-            contract: flatbuffers::WIPOffset<super::common::ContractContainer<'b>>,
+            contract: ::flatbuffers::WIPOffset<super::common::ContractContainer<'b>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractContainer>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractContainer>>(
                     GetResponse::VT_CONTRACT,
                     contract,
                 );
         }
         #[inline]
-        pub fn add_state(&mut self, state: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_state(
+            &mut self,
+            state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
+        ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(GetResponse::VT_STATE, state);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(GetResponse::VT_STATE, state);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> GetResponseBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             GetResponseBuilder {
@@ -529,16 +518,16 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<GetResponse<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<GetResponse<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, GetResponse::VT_KEY, "key");
             self.fbb_.required(o, GetResponse::VT_STATE, "state");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for GetResponse<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for GetResponse<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("GetResponse");
             ds.field("key", &self.key());
             ds.field("contract", &self.contract());
@@ -550,24 +539,24 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct PutResponse<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for PutResponse<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for PutResponse<'a> {
         type Inner = PutResponse<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> PutResponse<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             PutResponse { _tab: table }
         }
         #[allow(unused_mut)]
@@ -575,11 +564,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args PutResponseArgs<'args>,
-        ) -> flatbuffers::WIPOffset<PutResponse<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<PutResponse<'bldr>> {
             let mut builder = PutResponseBuilder::new(_fbb);
             if let Some(x) = args.key {
                 builder.add_key(x);
@@ -594,7 +583,7 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                         PutResponse::VT_KEY,
                         None,
                     )
@@ -603,15 +592,14 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for PutResponse<'_> {
+    impl ::flatbuffers::Verifiable for PutResponse<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
@@ -621,7 +609,7 @@ pub mod host_response {
         }
     }
     pub struct PutResponseArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
+        pub key: Option<::flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
     }
     impl<'a> Default for PutResponseArgs<'a> {
         #[inline]
@@ -632,22 +620,22 @@ pub mod host_response {
         }
     }
 
-    pub struct PutResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct PutResponseBuilder<'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> PutResponseBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PutResponseBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractKey>>(
                     PutResponse::VT_KEY,
                     key,
                 );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> PutResponseBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             PutResponseBuilder {
@@ -656,15 +644,15 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<PutResponse<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<PutResponse<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, PutResponse::VT_KEY, "key");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for PutResponse<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for PutResponse<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("PutResponse");
             ds.field("key", &self.key());
             ds.finish()
@@ -674,25 +662,25 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct UpdateNotification<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for UpdateNotification<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for UpdateNotification<'a> {
         type Inner = UpdateNotification<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> UpdateNotification<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_UPDATE: flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_UPDATE: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             UpdateNotification { _tab: table }
         }
         #[allow(unused_mut)]
@@ -700,11 +688,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args UpdateNotificationArgs<'args>,
-        ) -> flatbuffers::WIPOffset<UpdateNotification<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<UpdateNotification<'bldr>> {
             let mut builder = UpdateNotificationBuilder::new(_fbb);
             if let Some(x) = args.update {
                 builder.add_update(x);
@@ -722,7 +710,7 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                         UpdateNotification::VT_KEY,
                         None,
                     )
@@ -736,7 +724,7 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::UpdateData>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::UpdateData>>(
                         UpdateNotification::VT_UPDATE,
                         None,
                     )
@@ -745,20 +733,19 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for UpdateNotification<'_> {
+    impl ::flatbuffers::Verifiable for UpdateNotification<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::UpdateData>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::UpdateData>>(
                     "update",
                     Self::VT_UPDATE,
                     true,
@@ -768,8 +755,8 @@ pub mod host_response {
         }
     }
     pub struct UpdateNotificationArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
-        pub update: Option<flatbuffers::WIPOffset<super::common::UpdateData<'a>>>,
+        pub key: Option<::flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
+        pub update: Option<::flatbuffers::WIPOffset<super::common::UpdateData<'a>>>,
     }
     impl<'a> Default for UpdateNotificationArgs<'a> {
         #[inline]
@@ -781,15 +768,15 @@ pub mod host_response {
         }
     }
 
-    pub struct UpdateNotificationBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct UpdateNotificationBuilder<'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> UpdateNotificationBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UpdateNotificationBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractKey>>(
                     UpdateNotification::VT_KEY,
                     key,
                 );
@@ -797,17 +784,17 @@ pub mod host_response {
         #[inline]
         pub fn add_update(
             &mut self,
-            update: flatbuffers::WIPOffset<super::common::UpdateData<'b>>,
+            update: ::flatbuffers::WIPOffset<super::common::UpdateData<'b>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::UpdateData>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::UpdateData>>(
                     UpdateNotification::VT_UPDATE,
                     update,
                 );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> UpdateNotificationBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             UpdateNotificationBuilder {
@@ -816,17 +803,17 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<UpdateNotification<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<UpdateNotification<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, UpdateNotification::VT_KEY, "key");
             self.fbb_
                 .required(o, UpdateNotification::VT_UPDATE, "update");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for UpdateNotification<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for UpdateNotification<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("UpdateNotification");
             ds.field("key", &self.key());
             ds.field("update", &self.update());
@@ -837,25 +824,25 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct UpdateResponse<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for UpdateResponse<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for UpdateResponse<'a> {
         type Inner = UpdateResponse<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> UpdateResponse<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_SUMMARY: flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_SUMMARY: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             UpdateResponse { _tab: table }
         }
         #[allow(unused_mut)]
@@ -863,11 +850,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args UpdateResponseArgs<'args>,
-        ) -> flatbuffers::WIPOffset<UpdateResponse<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<UpdateResponse<'bldr>> {
             let mut builder = UpdateResponseBuilder::new(_fbb);
             if let Some(x) = args.summary {
                 builder.add_summary(x);
@@ -885,7 +872,7 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                         UpdateResponse::VT_KEY,
                         None,
                     )
@@ -893,13 +880,13 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn summary(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn summary(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         UpdateResponse::VT_SUMMARY,
                         None,
                     )
@@ -908,20 +895,19 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for UpdateResponse<'_> {
+    impl ::flatbuffers::Verifiable for UpdateResponse<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "summary",
                     Self::VT_SUMMARY,
                     true,
@@ -931,8 +917,8 @@ pub mod host_response {
         }
     }
     pub struct UpdateResponseArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
-        pub summary: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub key: Option<::flatbuffers::WIPOffset<super::common::ContractKey<'a>>>,
+        pub summary: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for UpdateResponseArgs<'a> {
         #[inline]
@@ -944,15 +930,15 @@ pub mod host_response {
         }
     }
 
-    pub struct UpdateResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct UpdateResponseBuilder<'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> UpdateResponseBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UpdateResponseBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<super::common::ContractKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<super::common::ContractKey>>(
                     UpdateResponse::VT_KEY,
                     key,
                 );
@@ -960,14 +946,16 @@ pub mod host_response {
         #[inline]
         pub fn add_summary(
             &mut self,
-            summary: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            summary: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(UpdateResponse::VT_SUMMARY, summary);
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
+                UpdateResponse::VT_SUMMARY,
+                summary,
+            );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> UpdateResponseBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             UpdateResponseBuilder {
@@ -976,16 +964,16 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<UpdateResponse<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<UpdateResponse<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, UpdateResponse::VT_KEY, "key");
             self.fbb_.required(o, UpdateResponse::VT_SUMMARY, "summary");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for UpdateResponse<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for UpdateResponse<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("UpdateResponse");
             ds.field("key", &self.key());
             ds.field("summary", &self.summary());
@@ -996,24 +984,24 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct NotFound<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for NotFound<'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),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> NotFound<'a> {
-        pub const VT_INSTANCE_ID: flatbuffers::VOffsetT = 4;
+        pub const VT_INSTANCE_ID: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             NotFound { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1021,11 +1009,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args NotFoundArgs<'args>,
-        ) -> flatbuffers::WIPOffset<NotFound<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<NotFound<'bldr>> {
             let mut builder = NotFoundBuilder::new(_fbb);
             if let Some(x) = args.instance_id {
                 builder.add_instance_id(x);
@@ -1040,7 +1028,7 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
+                    .get::<::flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
                         NotFound::VT_INSTANCE_ID,
                         None,
                     )
@@ -1049,15 +1037,14 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for NotFound<'_> {
+    impl ::flatbuffers::Verifiable for NotFound<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<super::common::ContractInstanceId>>(
                     "instance_id",
                     Self::VT_INSTANCE_ID,
                     true,
@@ -1067,7 +1054,7 @@ pub mod host_response {
         }
     }
     pub struct NotFoundArgs<'a> {
-        pub instance_id: Option<flatbuffers::WIPOffset<super::common::ContractInstanceId<'a>>>,
+        pub instance_id: Option<::flatbuffers::WIPOffset<super::common::ContractInstanceId<'a>>>,
     }
     impl<'a> Default for NotFoundArgs<'a> {
         #[inline]
@@ -1078,25 +1065,25 @@ pub mod host_response {
         }
     }
 
-    pub struct NotFoundBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    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> {
+    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>>,
+            instance_id: ::flatbuffers::WIPOffset<super::common::ContractInstanceId<'b>>,
         ) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<super::common::ContractInstanceId>>(
+                .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>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> NotFoundBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             NotFoundBuilder {
@@ -1105,16 +1092,16 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<NotFound<'a>> {
+        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())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for NotFound<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    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()
@@ -1124,25 +1111,25 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ContractResponse<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ContractResponse<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ContractResponse<'a> {
         type Inner = ContractResponse<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ContractResponse<'a> {
-        pub const VT_CONTRACT_RESPONSE_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_CONTRACT_RESPONSE: flatbuffers::VOffsetT = 6;
+        pub const VT_CONTRACT_RESPONSE_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CONTRACT_RESPONSE: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ContractResponse { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1150,11 +1137,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ContractResponseArgs,
-        ) -> flatbuffers::WIPOffset<ContractResponse<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ContractResponse<'bldr>> {
             let mut builder = ContractResponseBuilder::new(_fbb);
             if let Some(x) = args.contract_response {
                 builder.add_contract_response(x);
@@ -1178,13 +1165,13 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn contract_response(&self) -> flatbuffers::Table<'a> {
+        pub fn contract_response(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         ContractResponse::VT_CONTRACT_RESPONSE,
                         None,
                     )
@@ -1262,21 +1249,20 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for ContractResponse<'_> {
+    impl ::flatbuffers::Verifiable for ContractResponse<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
      .visit_union::<ContractResponseType, _>("contract_response_type", Self::VT_CONTRACT_RESPONSE_TYPE, "contract_response", Self::VT_CONTRACT_RESPONSE, true, |key, v, pos| {
         match key {
-          ContractResponseType::GetResponse => v.verify_union_variant::<flatbuffers::ForwardsUOffset<GetResponse>>("ContractResponseType::GetResponse", pos),
-          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),
+          ContractResponseType::GetResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GetResponse>>("ContractResponseType::GetResponse", pos),
+          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(()),
         }
      })?
@@ -1286,7 +1272,7 @@ pub mod host_response {
     }
     pub struct ContractResponseArgs {
         pub contract_response_type: ContractResponseType,
-        pub contract_response: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub contract_response: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for ContractResponseArgs {
         #[inline]
@@ -1298,11 +1284,11 @@ pub mod host_response {
         }
     }
 
-    pub struct ContractResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ContractResponseBuilder<'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> ContractResponseBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContractResponseBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_contract_response_type(&mut self, contract_response_type: ContractResponseType) {
             self.fbb_.push_slot::<ContractResponseType>(
@@ -1314,16 +1300,16 @@ pub mod host_response {
         #[inline]
         pub fn add_contract_response(
             &mut self,
-            contract_response: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            contract_response: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 ContractResponse::VT_CONTRACT_RESPONSE,
                 contract_response,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ContractResponseBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ContractResponseBuilder {
@@ -1332,19 +1318,19 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ContractResponse<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ContractResponse<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(
                 o,
                 ContractResponse::VT_CONTRACT_RESPONSE,
                 "contract_response",
             );
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ContractResponse<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContractResponse<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ContractResponse");
             ds.field("contract_response_type", &self.contract_response_type());
             match self.contract_response_type() {
@@ -1410,25 +1396,25 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct DelegateKey<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for DelegateKey<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for DelegateKey<'a> {
         type Inner = DelegateKey<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> DelegateKey<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_CODE_HASH: flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_CODE_HASH: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             DelegateKey { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1436,11 +1422,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args DelegateKeyArgs<'args>,
-        ) -> flatbuffers::WIPOffset<DelegateKey<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<DelegateKey<'bldr>> {
             let mut builder = DelegateKeyBuilder::new(_fbb);
             if let Some(x) = args.code_hash {
                 builder.add_code_hash(x);
@@ -1452,13 +1438,13 @@ pub mod host_response {
         }
 
         #[inline]
-        pub fn key(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn key(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         DelegateKey::VT_KEY,
                         None,
                     )
@@ -1466,13 +1452,13 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn code_hash(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn code_hash(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         DelegateKey::VT_CODE_HASH,
                         None,
                     )
@@ -1481,20 +1467,19 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for DelegateKey<'_> {
+    impl ::flatbuffers::Verifiable for DelegateKey<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "code_hash",
                     Self::VT_CODE_HASH,
                     true,
@@ -1504,8 +1489,8 @@ pub mod host_response {
         }
     }
     pub struct DelegateKeyArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
-        pub code_hash: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub key: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
+        pub code_hash: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for DelegateKeyArgs<'a> {
         #[inline]
@@ -1517,29 +1502,29 @@ pub mod host_response {
         }
     }
 
-    pub struct DelegateKeyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct DelegateKeyBuilder<'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> DelegateKeyBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateKeyBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(DelegateKey::VT_KEY, key);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(DelegateKey::VT_KEY, key);
         }
         #[inline]
         pub fn add_code_hash(
             &mut self,
-            code_hash: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            code_hash: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 DelegateKey::VT_CODE_HASH,
                 code_hash,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> DelegateKeyBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             DelegateKeyBuilder {
@@ -1548,17 +1533,17 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<DelegateKey<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<DelegateKey<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, DelegateKey::VT_KEY, "key");
             self.fbb_
                 .required(o, DelegateKey::VT_CODE_HASH, "code_hash");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for DelegateKey<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DelegateKey<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("DelegateKey");
             ds.field("key", &self.key());
             ds.field("code_hash", &self.code_hash());
@@ -1569,26 +1554,26 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct UserInputRequest<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for UserInputRequest<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for UserInputRequest<'a> {
         type Inner = UserInputRequest<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> UserInputRequest<'a> {
-        pub const VT_REQUEST_ID: flatbuffers::VOffsetT = 4;
-        pub const VT_MESSAGE: flatbuffers::VOffsetT = 6;
-        pub const VT_RESPONSES: flatbuffers::VOffsetT = 8;
+        pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 4;
+        pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 6;
+        pub const VT_RESPONSES: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             UserInputRequest { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1596,11 +1581,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args UserInputRequestArgs<'args>,
-        ) -> flatbuffers::WIPOffset<UserInputRequest<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<UserInputRequest<'bldr>> {
             let mut builder = UserInputRequestBuilder::new(_fbb);
             if let Some(x) = args.responses {
                 builder.add_responses(x);
@@ -1624,13 +1609,13 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn message(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn message(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         UserInputRequest::VT_MESSAGE,
                         None,
                     )
@@ -1640,36 +1625,35 @@ pub mod host_response {
         #[inline]
         pub fn responses(
             &self,
-        ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ClientResponse<'a>>> {
+        ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ClientResponse<'a>>> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<
-                        flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ClientResponse>>,
+                    .get::<::flatbuffers::ForwardsUOffset<
+                        ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ClientResponse>>,
                     >>(UserInputRequest::VT_RESPONSES, None)
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for UserInputRequest<'_> {
+    impl ::flatbuffers::Verifiable for UserInputRequest<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
                 .visit_field::<u32>("request_id", Self::VT_REQUEST_ID, false)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "message",
                     Self::VT_MESSAGE,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<
-                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ClientResponse>>,
+                .visit_field::<::flatbuffers::ForwardsUOffset<
+                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ClientResponse>>,
                 >>("responses", Self::VT_RESPONSES, true)?
                 .finish();
             Ok(())
@@ -1677,10 +1661,10 @@ pub mod host_response {
     }
     pub struct UserInputRequestArgs<'a> {
         pub request_id: u32,
-        pub message: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub message: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
         pub responses: Option<
-            flatbuffers::WIPOffset<
-                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ClientResponse<'a>>>,
+            ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ClientResponse<'a>>>,
             >,
         >,
     }
@@ -1695,11 +1679,11 @@ pub mod host_response {
         }
     }
 
-    pub struct UserInputRequestBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct UserInputRequestBuilder<'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> UserInputRequestBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UserInputRequestBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_request_id(&mut self, request_id: u32) {
             self.fbb_
@@ -1708,9 +1692,9 @@ pub mod host_response {
         #[inline]
         pub fn add_message(
             &mut self,
-            message: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            message: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 UserInputRequest::VT_MESSAGE,
                 message,
             );
@@ -1718,18 +1702,18 @@ pub mod host_response {
         #[inline]
         pub fn add_responses(
             &mut self,
-            responses: flatbuffers::WIPOffset<
-                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<ClientResponse<'b>>>,
+            responses: ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ClientResponse<'b>>>,
             >,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 UserInputRequest::VT_RESPONSES,
                 responses,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> UserInputRequestBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             UserInputRequestBuilder {
@@ -1738,18 +1722,18 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<UserInputRequest<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<UserInputRequest<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, UserInputRequest::VT_MESSAGE, "message");
             self.fbb_
                 .required(o, UserInputRequest::VT_RESPONSES, "responses");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for UserInputRequest<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for UserInputRequest<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("UserInputRequest");
             ds.field("request_id", &self.request_id());
             ds.field("message", &self.message());
@@ -1761,24 +1745,24 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ClientResponse<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ClientResponse<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ClientResponse<'a> {
         type Inner = ClientResponse<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ClientResponse<'a> {
-        pub const VT_DATA: flatbuffers::VOffsetT = 4;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ClientResponse { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1786,11 +1770,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ClientResponseArgs<'args>,
-        ) -> flatbuffers::WIPOffset<ClientResponse<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ClientResponse<'bldr>> {
             let mut builder = ClientResponseBuilder::new(_fbb);
             if let Some(x) = args.data {
                 builder.add_data(x);
@@ -1799,13 +1783,13 @@ pub mod host_response {
         }
 
         #[inline]
-        pub fn data(&self) -> Option<flatbuffers::Vector<'a, u8>> {
+        pub fn data(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ClientResponse::VT_DATA,
                         None,
                     )
@@ -1813,15 +1797,14 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for ClientResponse<'_> {
+    impl ::flatbuffers::Verifiable for ClientResponse<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "data",
                     Self::VT_DATA,
                     false,
@@ -1831,7 +1814,7 @@ pub mod host_response {
         }
     }
     pub struct ClientResponseArgs<'a> {
-        pub data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for ClientResponseArgs<'a> {
         #[inline]
@@ -1840,19 +1823,19 @@ pub mod host_response {
         }
     }
 
-    pub struct ClientResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ClientResponseBuilder<'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> ClientResponseBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ClientResponseBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(ClientResponse::VT_DATA, data);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(ClientResponse::VT_DATA, data);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ClientResponseBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ClientResponseBuilder {
@@ -1861,14 +1844,14 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ClientResponse<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ClientResponse<'a>> {
             let o = self.fbb_.end_table(self.start_);
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ClientResponse<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ClientResponse<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ClientResponse");
             ds.field("data", &self.data());
             ds.finish()
@@ -1878,26 +1861,26 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct RequestUserInput<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for RequestUserInput<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for RequestUserInput<'a> {
         type Inner = RequestUserInput<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> RequestUserInput<'a> {
-        pub const VT_REQUEST_ID: flatbuffers::VOffsetT = 4;
-        pub const VT_MESSAGE: flatbuffers::VOffsetT = 6;
-        pub const VT_RESPONSES: flatbuffers::VOffsetT = 8;
+        pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 4;
+        pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 6;
+        pub const VT_RESPONSES: ::flatbuffers::VOffsetT = 8;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             RequestUserInput { _tab: table }
         }
         #[allow(unused_mut)]
@@ -1905,11 +1888,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args RequestUserInputArgs<'args>,
-        ) -> flatbuffers::WIPOffset<RequestUserInput<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<RequestUserInput<'bldr>> {
             let mut builder = RequestUserInputBuilder::new(_fbb);
             if let Some(x) = args.responses {
                 builder.add_responses(x);
@@ -1933,13 +1916,13 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn message(&self) -> Option<flatbuffers::Vector<'a, u8>> {
+        pub fn message(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         RequestUserInput::VT_MESSAGE,
                         None,
                     )
@@ -1948,36 +1931,35 @@ pub mod host_response {
         #[inline]
         pub fn responses(
             &self,
-        ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ClientResponse<'a>>> {
+        ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ClientResponse<'a>>> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<
-                        flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ClientResponse>>,
+                    .get::<::flatbuffers::ForwardsUOffset<
+                        ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ClientResponse>>,
                     >>(RequestUserInput::VT_RESPONSES, None)
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for RequestUserInput<'_> {
+    impl ::flatbuffers::Verifiable for RequestUserInput<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
                 .visit_field::<u32>("request_id", Self::VT_REQUEST_ID, false)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "message",
                     Self::VT_MESSAGE,
                     false,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<
-                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ClientResponse>>,
+                .visit_field::<::flatbuffers::ForwardsUOffset<
+                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ClientResponse>>,
                 >>("responses", Self::VT_RESPONSES, true)?
                 .finish();
             Ok(())
@@ -1985,10 +1967,10 @@ pub mod host_response {
     }
     pub struct RequestUserInputArgs<'a> {
         pub request_id: u32,
-        pub message: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub message: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
         pub responses: Option<
-            flatbuffers::WIPOffset<
-                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ClientResponse<'a>>>,
+            ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ClientResponse<'a>>>,
             >,
         >,
     }
@@ -2003,11 +1985,11 @@ pub mod host_response {
         }
     }
 
-    pub struct RequestUserInputBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct RequestUserInputBuilder<'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> RequestUserInputBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RequestUserInputBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_request_id(&mut self, request_id: u32) {
             self.fbb_
@@ -2016,9 +1998,9 @@ pub mod host_response {
         #[inline]
         pub fn add_message(
             &mut self,
-            message: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            message: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 RequestUserInput::VT_MESSAGE,
                 message,
             );
@@ -2026,18 +2008,18 @@ pub mod host_response {
         #[inline]
         pub fn add_responses(
             &mut self,
-            responses: flatbuffers::WIPOffset<
-                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<ClientResponse<'b>>>,
+            responses: ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ClientResponse<'b>>>,
             >,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 RequestUserInput::VT_RESPONSES,
                 responses,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> RequestUserInputBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             RequestUserInputBuilder {
@@ -2046,16 +2028,16 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<RequestUserInput<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<RequestUserInput<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, RequestUserInput::VT_RESPONSES, "responses");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for RequestUserInput<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for RequestUserInput<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("RequestUserInput");
             ds.field("request_id", &self.request_id());
             ds.field("message", &self.message());
@@ -2067,24 +2049,24 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct ContextUpdated<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for ContextUpdated<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for ContextUpdated<'a> {
         type Inner = ContextUpdated<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> ContextUpdated<'a> {
-        pub const VT_CONTEXT: flatbuffers::VOffsetT = 4;
+        pub const VT_CONTEXT: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             ContextUpdated { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2092,11 +2074,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ContextUpdatedArgs<'args>,
-        ) -> flatbuffers::WIPOffset<ContextUpdated<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<ContextUpdated<'bldr>> {
             let mut builder = ContextUpdatedBuilder::new(_fbb);
             if let Some(x) = args.context {
                 builder.add_context(x);
@@ -2105,13 +2087,13 @@ pub mod host_response {
         }
 
         #[inline]
-        pub fn context(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn context(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         ContextUpdated::VT_CONTEXT,
                         None,
                     )
@@ -2120,15 +2102,14 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for ContextUpdated<'_> {
+    impl ::flatbuffers::Verifiable for ContextUpdated<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "context",
                     Self::VT_CONTEXT,
                     true,
@@ -2138,7 +2119,7 @@ pub mod host_response {
         }
     }
     pub struct ContextUpdatedArgs<'a> {
-        pub context: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub context: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for ContextUpdatedArgs<'a> {
         #[inline]
@@ -2149,22 +2130,24 @@ pub mod host_response {
         }
     }
 
-    pub struct ContextUpdatedBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ContextUpdatedBuilder<'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> ContextUpdatedBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ContextUpdatedBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_context(
             &mut self,
-            context: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            context: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(ContextUpdated::VT_CONTEXT, context);
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
+                ContextUpdated::VT_CONTEXT,
+                context,
+            );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> ContextUpdatedBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ContextUpdatedBuilder {
@@ -2173,15 +2156,15 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<ContextUpdated<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<ContextUpdated<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, ContextUpdated::VT_CONTEXT, "context");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for ContextUpdated<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for ContextUpdated<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("ContextUpdated");
             ds.field("context", &self.context());
             ds.finish()
@@ -2191,25 +2174,25 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct OutboundDelegateMsg<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for OutboundDelegateMsg<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for OutboundDelegateMsg<'a> {
         type Inner = OutboundDelegateMsg<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> OutboundDelegateMsg<'a> {
-        pub const VT_INBOUND_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_INBOUND: flatbuffers::VOffsetT = 6;
+        pub const VT_INBOUND_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_INBOUND: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             OutboundDelegateMsg { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2217,11 +2200,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args OutboundDelegateMsgArgs,
-        ) -> flatbuffers::WIPOffset<OutboundDelegateMsg<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<OutboundDelegateMsg<'bldr>> {
             let mut builder = OutboundDelegateMsgBuilder::new(_fbb);
             if let Some(x) = args.inbound {
                 builder.add_inbound(x);
@@ -2245,13 +2228,13 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn inbound(&self) -> flatbuffers::Table<'a> {
+        pub fn inbound(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         OutboundDelegateMsg::VT_INBOUND,
                         None,
                     )
@@ -2303,19 +2286,18 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for OutboundDelegateMsg<'_> {
+    impl ::flatbuffers::Verifiable for OutboundDelegateMsg<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
      .visit_union::<OutboundDelegateMsgType, _>("inbound_type", Self::VT_INBOUND_TYPE, "inbound", Self::VT_INBOUND, true, |key, v, pos| {
         match key {
-          OutboundDelegateMsgType::common_ApplicationMessage => v.verify_union_variant::<flatbuffers::ForwardsUOffset<super::common::ApplicationMessage>>("OutboundDelegateMsgType::common_ApplicationMessage", pos),
-          OutboundDelegateMsgType::RequestUserInput => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RequestUserInput>>("OutboundDelegateMsgType::RequestUserInput", pos),
-          OutboundDelegateMsgType::ContextUpdated => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ContextUpdated>>("OutboundDelegateMsgType::ContextUpdated", pos),
+          OutboundDelegateMsgType::common_ApplicationMessage => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<super::common::ApplicationMessage>>("OutboundDelegateMsgType::common_ApplicationMessage", pos),
+          OutboundDelegateMsgType::RequestUserInput => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RequestUserInput>>("OutboundDelegateMsgType::RequestUserInput", pos),
+          OutboundDelegateMsgType::ContextUpdated => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ContextUpdated>>("OutboundDelegateMsgType::ContextUpdated", pos),
           _ => Ok(()),
         }
      })?
@@ -2325,7 +2307,7 @@ pub mod host_response {
     }
     pub struct OutboundDelegateMsgArgs {
         pub inbound_type: OutboundDelegateMsgType,
-        pub inbound: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub inbound: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for OutboundDelegateMsgArgs {
         #[inline]
@@ -2337,11 +2319,11 @@ pub mod host_response {
         }
     }
 
-    pub struct OutboundDelegateMsgBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct OutboundDelegateMsgBuilder<'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> OutboundDelegateMsgBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> OutboundDelegateMsgBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_inbound_type(&mut self, inbound_type: OutboundDelegateMsgType) {
             self.fbb_.push_slot::<OutboundDelegateMsgType>(
@@ -2353,16 +2335,16 @@ pub mod host_response {
         #[inline]
         pub fn add_inbound(
             &mut self,
-            inbound: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            inbound: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 OutboundDelegateMsg::VT_INBOUND,
                 inbound,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> OutboundDelegateMsgBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             OutboundDelegateMsgBuilder {
@@ -2371,16 +2353,16 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<OutboundDelegateMsg<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<OutboundDelegateMsg<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, OutboundDelegateMsg::VT_INBOUND, "inbound");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for OutboundDelegateMsg<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for OutboundDelegateMsg<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("OutboundDelegateMsg");
             ds.field("inbound_type", &self.inbound_type());
             match self.inbound_type() {
@@ -2426,25 +2408,25 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct DelegateResponse<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for DelegateResponse<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for DelegateResponse<'a> {
         type Inner = DelegateResponse<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> DelegateResponse<'a> {
-        pub const VT_KEY: flatbuffers::VOffsetT = 4;
-        pub const VT_VALUES: flatbuffers::VOffsetT = 6;
+        pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+        pub const VT_VALUES: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             DelegateResponse { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2452,11 +2434,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args DelegateResponseArgs<'args>,
-        ) -> flatbuffers::WIPOffset<DelegateResponse<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<DelegateResponse<'bldr>> {
             let mut builder = DelegateResponseBuilder::new(_fbb);
             if let Some(x) = args.values {
                 builder.add_values(x);
@@ -2474,7 +2456,7 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<DelegateKey>>(
+                    .get::<::flatbuffers::ForwardsUOffset<DelegateKey>>(
                         DelegateResponse::VT_KEY,
                         None,
                     )
@@ -2484,46 +2466,48 @@ pub mod host_response {
         #[inline]
         pub fn values(
             &self,
-        ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<OutboundDelegateMsg<'a>>>
+        ) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<OutboundDelegateMsg<'a>>>
         {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<
-                        flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<OutboundDelegateMsg>>,
+                    .get::<::flatbuffers::ForwardsUOffset<
+                        ::flatbuffers::Vector<
+                            'a,
+                            ::flatbuffers::ForwardsUOffset<OutboundDelegateMsg>,
+                        >,
                     >>(DelegateResponse::VT_VALUES, None)
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for DelegateResponse<'_> {
+    impl ::flatbuffers::Verifiable for DelegateResponse<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<DelegateKey>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<DelegateKey>>(
                     "key",
                     Self::VT_KEY,
                     true,
                 )?
-                .visit_field::<flatbuffers::ForwardsUOffset<
-                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<OutboundDelegateMsg>>,
+                .visit_field::<::flatbuffers::ForwardsUOffset<
+                    ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<OutboundDelegateMsg>>,
                 >>("values", Self::VT_VALUES, true)?
                 .finish();
             Ok(())
         }
     }
     pub struct DelegateResponseArgs<'a> {
-        pub key: Option<flatbuffers::WIPOffset<DelegateKey<'a>>>,
+        pub key: Option<::flatbuffers::WIPOffset<DelegateKey<'a>>>,
         pub values: Option<
-            flatbuffers::WIPOffset<
-                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<OutboundDelegateMsg<'a>>>,
+            ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<OutboundDelegateMsg<'a>>>,
             >,
         >,
     }
@@ -2537,15 +2521,15 @@ pub mod host_response {
         }
     }
 
-    pub struct DelegateResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct DelegateResponseBuilder<'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> DelegateResponseBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DelegateResponseBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_key(&mut self, key: flatbuffers::WIPOffset<DelegateKey<'b>>) {
+        pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<DelegateKey<'b>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<DelegateKey>>(
+                .push_slot_always::<::flatbuffers::WIPOffset<DelegateKey>>(
                     DelegateResponse::VT_KEY,
                     key,
                 );
@@ -2553,16 +2537,18 @@ pub mod host_response {
         #[inline]
         pub fn add_values(
             &mut self,
-            values: flatbuffers::WIPOffset<
-                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<OutboundDelegateMsg<'b>>>,
+            values: ::flatbuffers::WIPOffset<
+                ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<OutboundDelegateMsg<'b>>>,
             >,
         ) {
-            self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(DelegateResponse::VT_VALUES, values);
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
+                DelegateResponse::VT_VALUES,
+                values,
+            );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> DelegateResponseBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             DelegateResponseBuilder {
@@ -2571,16 +2557,16 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<DelegateResponse<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<DelegateResponse<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, DelegateResponse::VT_KEY, "key");
             self.fbb_.required(o, DelegateResponse::VT_VALUES, "values");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for DelegateResponse<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for DelegateResponse<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("DelegateResponse");
             ds.field("key", &self.key());
             ds.field("values", &self.values());
@@ -2591,24 +2577,24 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct GenerateRandData<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for GenerateRandData<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for GenerateRandData<'a> {
         type Inner = GenerateRandData<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> GenerateRandData<'a> {
-        pub const VT_WRAPPED_STATE: flatbuffers::VOffsetT = 4;
+        pub const VT_WRAPPED_STATE: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             GenerateRandData { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2616,11 +2602,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args GenerateRandDataArgs<'args>,
-        ) -> flatbuffers::WIPOffset<GenerateRandData<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<GenerateRandData<'bldr>> {
             let mut builder = GenerateRandDataBuilder::new(_fbb);
             if let Some(x) = args.wrapped_state {
                 builder.add_wrapped_state(x);
@@ -2629,13 +2615,13 @@ pub mod host_response {
         }
 
         #[inline]
-        pub fn wrapped_state(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn wrapped_state(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         GenerateRandData::VT_WRAPPED_STATE,
                         None,
                     )
@@ -2644,15 +2630,14 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for GenerateRandData<'_> {
+    impl ::flatbuffers::Verifiable for GenerateRandData<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "wrapped_state",
                     Self::VT_WRAPPED_STATE,
                     true,
@@ -2662,7 +2647,7 @@ pub mod host_response {
         }
     }
     pub struct GenerateRandDataArgs<'a> {
-        pub wrapped_state: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub wrapped_state: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for GenerateRandDataArgs<'a> {
         #[inline]
@@ -2673,24 +2658,24 @@ pub mod host_response {
         }
     }
 
-    pub struct GenerateRandDataBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct GenerateRandDataBuilder<'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> GenerateRandDataBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GenerateRandDataBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_wrapped_state(
             &mut self,
-            wrapped_state: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>,
+            wrapped_state: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
         ) {
-            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                 GenerateRandData::VT_WRAPPED_STATE,
                 wrapped_state,
             );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> GenerateRandDataBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             GenerateRandDataBuilder {
@@ -2699,16 +2684,16 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<GenerateRandData<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<GenerateRandData<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_
                 .required(o, GenerateRandData::VT_WRAPPED_STATE, "wrapped_state");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for GenerateRandData<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for GenerateRandData<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("GenerateRandData");
             ds.field("wrapped_state", &self.wrapped_state());
             ds.finish()
@@ -2718,27 +2703,27 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct StreamChunk<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for StreamChunk<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for StreamChunk<'a> {
         type Inner = StreamChunk<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> StreamChunk<'a> {
-        pub const VT_STREAM_ID: flatbuffers::VOffsetT = 4;
-        pub const VT_INDEX: flatbuffers::VOffsetT = 6;
-        pub const VT_TOTAL: flatbuffers::VOffsetT = 8;
-        pub const VT_DATA: flatbuffers::VOffsetT = 10;
+        pub const VT_STREAM_ID: ::flatbuffers::VOffsetT = 4;
+        pub const VT_INDEX: ::flatbuffers::VOffsetT = 6;
+        pub const VT_TOTAL: ::flatbuffers::VOffsetT = 8;
+        pub const VT_DATA: ::flatbuffers::VOffsetT = 10;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             StreamChunk { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2746,11 +2731,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args StreamChunkArgs<'args>,
-        ) -> flatbuffers::WIPOffset<StreamChunk<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<StreamChunk<'bldr>> {
             let mut builder = StreamChunkBuilder::new(_fbb);
             if let Some(x) = args.data {
                 builder.add_data(x);
@@ -2795,13 +2780,13 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn data(&self) -> flatbuffers::Vector<'a, u8> {
+        pub fn data(&self) -> ::flatbuffers::Vector<'a, u8> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                         StreamChunk::VT_DATA,
                         None,
                     )
@@ -2810,18 +2795,17 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for StreamChunk<'_> {
+    impl ::flatbuffers::Verifiable for StreamChunk<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
                 .visit_field::<u32>("stream_id", Self::VT_STREAM_ID, false)?
                 .visit_field::<u32>("index", Self::VT_INDEX, false)?
                 .visit_field::<u32>("total", Self::VT_TOTAL, false)?
-                .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(
+                .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                     "data",
                     Self::VT_DATA,
                     true,
@@ -2834,7 +2818,7 @@ pub mod host_response {
         pub stream_id: u32,
         pub index: u32,
         pub total: u32,
-        pub data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
+        pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
     }
     impl<'a> Default for StreamChunkArgs<'a> {
         #[inline]
@@ -2848,11 +2832,11 @@ pub mod host_response {
         }
     }
 
-    pub struct StreamChunkBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct StreamChunkBuilder<'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> StreamChunkBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> StreamChunkBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_stream_id(&mut self, stream_id: u32) {
             self.fbb_
@@ -2867,13 +2851,13 @@ pub mod host_response {
             self.fbb_.push_slot::<u32>(StreamChunk::VT_TOTAL, total, 0);
         }
         #[inline]
-        pub fn add_data(&mut self, data: flatbuffers::WIPOffset<flatbuffers::Vector<'b, u8>>) {
+        pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(StreamChunk::VT_DATA, data);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(StreamChunk::VT_DATA, data);
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> StreamChunkBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             StreamChunkBuilder {
@@ -2882,15 +2866,15 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<StreamChunk<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<StreamChunk<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, StreamChunk::VT_DATA, "data");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for StreamChunk<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for StreamChunk<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("StreamChunk");
             ds.field("stream_id", &self.stream_id());
             ds.field("index", &self.index());
@@ -2903,24 +2887,24 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct Ok<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for Ok<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for Ok<'a> {
         type Inner = Ok<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> Ok<'a> {
-        pub const VT_MSG: flatbuffers::VOffsetT = 4;
+        pub const VT_MSG: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             Ok { _tab: table }
         }
         #[allow(unused_mut)]
@@ -2928,11 +2912,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args OkArgs<'args>,
-        ) -> flatbuffers::WIPOffset<Ok<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<Ok<'bldr>> {
             let mut builder = OkBuilder::new(_fbb);
             if let Some(x) = args.msg {
                 builder.add_msg(x);
@@ -2947,27 +2931,26 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Ok::VT_MSG, None)
+                    .get::<::flatbuffers::ForwardsUOffset<&str>>(Ok::VT_MSG, None)
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for Ok<'_> {
+    impl ::flatbuffers::Verifiable for Ok<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>("msg", Self::VT_MSG, true)?
+                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("msg", Self::VT_MSG, true)?
                 .finish();
             Ok(())
         }
     }
     pub struct OkArgs<'a> {
-        pub msg: Option<flatbuffers::WIPOffset<&'a str>>,
+        pub msg: Option<::flatbuffers::WIPOffset<&'a str>>,
     }
     impl<'a> Default for OkArgs<'a> {
         #[inline]
@@ -2978,18 +2961,18 @@ pub mod host_response {
         }
     }
 
-    pub struct OkBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct OkBuilder<'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> OkBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> OkBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_msg(&mut self, msg: flatbuffers::WIPOffset<&'b str>) {
+        pub fn add_msg(&mut self, msg: ::flatbuffers::WIPOffset<&'b str>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(Ok::VT_MSG, msg);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(Ok::VT_MSG, msg);
         }
         #[inline]
-        pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> OkBuilder<'a, 'b, A> {
+        pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> OkBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             OkBuilder {
                 fbb_: _fbb,
@@ -2997,15 +2980,15 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<Ok<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<Ok<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, Ok::VT_MSG, "msg");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for Ok<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for Ok<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("Ok");
             ds.field("msg", &self.msg());
             ds.finish()
@@ -3015,24 +2998,24 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct Error<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for Error<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for Error<'a> {
         type Inner = Error<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> Error<'a> {
-        pub const VT_MSG: flatbuffers::VOffsetT = 4;
+        pub const VT_MSG: ::flatbuffers::VOffsetT = 4;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             Error { _tab: table }
         }
         #[allow(unused_mut)]
@@ -3040,11 +3023,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args ErrorArgs<'args>,
-        ) -> flatbuffers::WIPOffset<Error<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<Error<'bldr>> {
             let mut builder = ErrorBuilder::new(_fbb);
             if let Some(x) = args.msg {
                 builder.add_msg(x);
@@ -3059,27 +3042,26 @@ pub mod host_response {
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<&str>>(Error::VT_MSG, None)
+                    .get::<::flatbuffers::ForwardsUOffset<&str>>(Error::VT_MSG, None)
                     .unwrap()
             }
         }
     }
 
-    impl flatbuffers::Verifiable for Error<'_> {
+    impl ::flatbuffers::Verifiable for Error<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_field::<flatbuffers::ForwardsUOffset<&str>>("msg", Self::VT_MSG, true)?
+                .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("msg", Self::VT_MSG, true)?
                 .finish();
             Ok(())
         }
     }
     pub struct ErrorArgs<'a> {
-        pub msg: Option<flatbuffers::WIPOffset<&'a str>>,
+        pub msg: Option<::flatbuffers::WIPOffset<&'a str>>,
     }
     impl<'a> Default for ErrorArgs<'a> {
         #[inline]
@@ -3090,18 +3072,20 @@ pub mod host_response {
         }
     }
 
-    pub struct ErrorBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct ErrorBuilder<'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> ErrorBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ErrorBuilder<'a, 'b, A> {
         #[inline]
-        pub fn add_msg(&mut self, msg: flatbuffers::WIPOffset<&'b str>) {
+        pub fn add_msg(&mut self, msg: ::flatbuffers::WIPOffset<&'b str>) {
             self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(Error::VT_MSG, msg);
+                .push_slot_always::<::flatbuffers::WIPOffset<_>>(Error::VT_MSG, msg);
         }
         #[inline]
-        pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ErrorBuilder<'a, 'b, A> {
+        pub fn new(
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+        ) -> ErrorBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             ErrorBuilder {
                 fbb_: _fbb,
@@ -3109,15 +3093,15 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<Error<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<Error<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, Error::VT_MSG, "msg");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for Error<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for Error<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("Error");
             ds.field("msg", &self.msg());
             ds.finish()
@@ -3127,25 +3111,25 @@ pub mod host_response {
     #[derive(Copy, Clone, PartialEq)]
 
     pub struct HostResponse<'a> {
-        pub _tab: flatbuffers::Table<'a>,
+        pub _tab: ::flatbuffers::Table<'a>,
     }
 
-    impl<'a> flatbuffers::Follow<'a> for HostResponse<'a> {
+    impl<'a> ::flatbuffers::Follow<'a> for HostResponse<'a> {
         type Inner = HostResponse<'a>;
         #[inline]
         unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
             Self {
-                _tab: flatbuffers::Table::new(buf, loc),
+                _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
             }
         }
     }
 
     impl<'a> HostResponse<'a> {
-        pub const VT_RESPONSE_TYPE: flatbuffers::VOffsetT = 4;
-        pub const VT_RESPONSE: flatbuffers::VOffsetT = 6;
+        pub const VT_RESPONSE_TYPE: ::flatbuffers::VOffsetT = 4;
+        pub const VT_RESPONSE: ::flatbuffers::VOffsetT = 6;
 
         #[inline]
-        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
             HostResponse { _tab: table }
         }
         #[allow(unused_mut)]
@@ -3153,11 +3137,11 @@ pub mod host_response {
             'bldr: 'args,
             'args: 'mut_bldr,
             'mut_bldr,
-            A: flatbuffers::Allocator + 'bldr,
+            A: ::flatbuffers::Allocator + 'bldr,
         >(
-            _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+            _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
             args: &'args HostResponseArgs,
-        ) -> flatbuffers::WIPOffset<HostResponse<'bldr>> {
+        ) -> ::flatbuffers::WIPOffset<HostResponse<'bldr>> {
             let mut builder = HostResponseBuilder::new(_fbb);
             if let Some(x) = args.response {
                 builder.add_response(x);
@@ -3181,13 +3165,13 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn response(&self) -> flatbuffers::Table<'a> {
+        pub fn response(&self) -> ::flatbuffers::Table<'a> {
             // Safety:
             // Created from valid Table for this object
             // which contains a valid value in this slot
             unsafe {
                 self._tab
-                    .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(
                         HostResponse::VT_RESPONSE,
                         None,
                     )
@@ -3279,61 +3263,31 @@ pub mod host_response {
         }
     }
 
-    impl flatbuffers::Verifiable for HostResponse<'_> {
+    impl ::flatbuffers::Verifiable for HostResponse<'_> {
         #[inline]
         fn run_verifier(
-            v: &mut flatbuffers::Verifier,
+            v: &mut ::flatbuffers::Verifier,
             pos: usize,
-        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-            use self::flatbuffers::Verifiable;
+        ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
             v.visit_table(pos)?
-                .visit_union::<HostResponseType, _>(
-                    "response_type",
-                    Self::VT_RESPONSE_TYPE,
-                    "response",
-                    Self::VT_RESPONSE,
-                    true,
-                    |key, v, pos| match key {
-                        HostResponseType::ContractResponse => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<ContractResponse>>(
-                                "HostResponseType::ContractResponse",
-                                pos,
-                            ),
-                        HostResponseType::DelegateResponse => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<DelegateResponse>>(
-                                "HostResponseType::DelegateResponse",
-                                pos,
-                            ),
-                        HostResponseType::GenerateRandData => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<GenerateRandData>>(
-                                "HostResponseType::GenerateRandData",
-                                pos,
-                            ),
-                        HostResponseType::Ok => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<Ok>>(
-                                "HostResponseType::Ok",
-                                pos,
-                            ),
-                        HostResponseType::Error => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<Error>>(
-                                "HostResponseType::Error",
-                                pos,
-                            ),
-                        HostResponseType::StreamChunk => v
-                            .verify_union_variant::<flatbuffers::ForwardsUOffset<StreamChunk>>(
-                                "HostResponseType::StreamChunk",
-                                pos,
-                            ),
-                        _ => Ok(()),
-                    },
-                )?
-                .finish();
+     .visit_union::<HostResponseType, _>("response_type", Self::VT_RESPONSE_TYPE, "response", Self::VT_RESPONSE, true, |key, v, pos| {
+        match key {
+          HostResponseType::ContractResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ContractResponse>>("HostResponseType::ContractResponse", pos),
+          HostResponseType::DelegateResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<DelegateResponse>>("HostResponseType::DelegateResponse", pos),
+          HostResponseType::GenerateRandData => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GenerateRandData>>("HostResponseType::GenerateRandData", pos),
+          HostResponseType::Ok => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Ok>>("HostResponseType::Ok", pos),
+          HostResponseType::Error => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Error>>("HostResponseType::Error", pos),
+          HostResponseType::StreamChunk => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<StreamChunk>>("HostResponseType::StreamChunk", pos),
+          _ => Ok(()),
+        }
+     })?
+     .finish();
             Ok(())
         }
     }
     pub struct HostResponseArgs {
         pub response_type: HostResponseType,
-        pub response: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+        pub response: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     }
     impl<'a> Default for HostResponseArgs {
         #[inline]
@@ -3345,11 +3299,11 @@ pub mod host_response {
         }
     }
 
-    pub struct HostResponseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-        fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+    pub struct HostResponseBuilder<'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> HostResponseBuilder<'a, 'b, A> {
+    impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HostResponseBuilder<'a, 'b, A> {
         #[inline]
         pub fn add_response_type(&mut self, response_type: HostResponseType) {
             self.fbb_.push_slot::<HostResponseType>(
@@ -3361,14 +3315,16 @@ pub mod host_response {
         #[inline]
         pub fn add_response(
             &mut self,
-            response: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
+            response: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>,
         ) {
-            self.fbb_
-                .push_slot_always::<flatbuffers::WIPOffset<_>>(HostResponse::VT_RESPONSE, response);
+            self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
+                HostResponse::VT_RESPONSE,
+                response,
+            );
         }
         #[inline]
         pub fn new(
-            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+            _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
         ) -> HostResponseBuilder<'a, 'b, A> {
             let start = _fbb.start_table();
             HostResponseBuilder {
@@ -3377,15 +3333,15 @@ pub mod host_response {
             }
         }
         #[inline]
-        pub fn finish(self) -> flatbuffers::WIPOffset<HostResponse<'a>> {
+        pub fn finish(self) -> ::flatbuffers::WIPOffset<HostResponse<'a>> {
             let o = self.fbb_.end_table(self.start_);
             self.fbb_.required(o, HostResponse::VT_RESPONSE, "response");
-            flatbuffers::WIPOffset::new(o.value())
+            ::flatbuffers::WIPOffset::new(o.value())
         }
     }
 
-    impl core::fmt::Debug for HostResponse<'_> {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    impl ::core::fmt::Debug for HostResponse<'_> {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
             let mut ds = f.debug_struct("HostResponse");
             ds.field("response_type", &self.response_type());
             match self.response_type() {
@@ -3466,8 +3422,8 @@ pub mod host_response {
     /// `root_as_host_response_unchecked`.
     pub fn root_as_host_response(
         buf: &[u8],
-    ) -> Result<HostResponse, flatbuffers::InvalidFlatbuffer> {
-        flatbuffers::root::<HostResponse>(buf)
+    ) -> Result<HostResponse<'_>, ::flatbuffers::InvalidFlatbuffer> {
+        ::flatbuffers::root::<HostResponse>(buf)
     }
     #[inline]
     /// Verifies that a buffer of bytes contains a size prefixed
@@ -3478,8 +3434,8 @@ 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> {
-        flatbuffers::size_prefixed_root::<HostResponse>(buf)
+    ) -> Result<HostResponse<'_>, ::flatbuffers::InvalidFlatbuffer> {
+        ::flatbuffers::size_prefixed_root::<HostResponse>(buf)
     }
     #[inline]
     /// Verifies, with the given options, that a buffer of bytes
@@ -3489,10 +3445,10 @@ pub mod host_response {
     /// previous, unchecked, behavior use
     /// `root_as_host_response_unchecked`.
     pub fn root_as_host_response_with_opts<'b, 'o>(
-        opts: &'o flatbuffers::VerifierOptions,
+        opts: &'o ::flatbuffers::VerifierOptions,
         buf: &'b [u8],
-    ) -> Result<HostResponse<'b>, flatbuffers::InvalidFlatbuffer> {
-        flatbuffers::root_with_opts::<HostResponse<'b>>(opts, buf)
+    ) -> Result<HostResponse<'b>, ::flatbuffers::InvalidFlatbuffer> {
+        ::flatbuffers::root_with_opts::<HostResponse<'b>>(opts, buf)
     }
     #[inline]
     /// Verifies, with the given verifier options, that a buffer of
@@ -3502,37 +3458,37 @@ pub mod host_response {
     /// previous, unchecked, behavior use
     /// `root_as_host_response_unchecked`.
     pub fn size_prefixed_root_as_host_response_with_opts<'b, 'o>(
-        opts: &'o flatbuffers::VerifierOptions,
+        opts: &'o ::flatbuffers::VerifierOptions,
         buf: &'b [u8],
-    ) -> Result<HostResponse<'b>, flatbuffers::InvalidFlatbuffer> {
-        flatbuffers::size_prefixed_root_with_opts::<HostResponse<'b>>(opts, buf)
+    ) -> Result<HostResponse<'b>, ::flatbuffers::InvalidFlatbuffer> {
+        ::flatbuffers::size_prefixed_root_with_opts::<HostResponse<'b>>(opts, buf)
     }
     #[inline]
     /// 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 {
-        flatbuffers::root_unchecked::<HostResponse>(buf)
+    pub unsafe fn root_as_host_response_unchecked(buf: &[u8]) -> HostResponse<'_> {
+        unsafe { ::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 {
-        flatbuffers::size_prefixed_root_unchecked::<HostResponse>(buf)
+    pub unsafe fn size_prefixed_root_as_host_response_unchecked(buf: &[u8]) -> HostResponse<'_> {
+        unsafe { ::flatbuffers::size_prefixed_root_unchecked::<HostResponse>(buf) }
     }
     #[inline]
-    pub fn finish_host_response_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
-        fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        root: flatbuffers::WIPOffset<HostResponse<'a>>,
+    pub fn finish_host_response_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+        fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+        root: ::flatbuffers::WIPOffset<HostResponse<'a>>,
     ) {
         fbb.finish(root, None);
     }
 
     #[inline]
-    pub fn finish_size_prefixed_host_response_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
-        fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-        root: flatbuffers::WIPOffset<HostResponse<'a>>,
+    pub fn finish_size_prefixed_host_response_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+        fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+        root: ::flatbuffers::WIPOffset<HostResponse<'a>>,
     ) {
         fbb.finish_size_prefixed(root, None);
     }
diff --git a/schemas/flatbuffers/common.fbs b/schemas/flatbuffers/common.fbs
index 7d20eaf..582a077 100644
--- a/schemas/flatbuffers/common.fbs
+++ b/schemas/flatbuffers/common.fbs
@@ -20,7 +20,6 @@ table ContractCode {
 }
 
 table ApplicationMessage {
-    app: ContractInstanceId(required);
     payload: [ubyte](required);
     context: [ubyte](required);
     processed: bool;