chore: update submodule

src/gen/haqq.dao.v1.rs

@@ -187,6 +187,24 @@ pub struct MsgFund {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MsgFundResponse {
 }
+/// MsgTransferOwnership allows an account transfer the ownership of shares to another account.
+#[derive(::derive_builder::Builder)]
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgTransferOwnership {
+    /// owner is a current owner of the shares in dao.
+    #[prost(string, tag="1")]
+    pub owner: ::prost::alloc::string::String,
+    /// new_owner is a new owner of the shares in dao.
+    #[prost(string, tag="2")]
+    pub new_owner: ::prost::alloc::string::String,
+}
+/// MsgTransferOwnershipResponse defines the Msg/TransferOwnership response type.
+#[derive(::derive_builder::Builder)]
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MsgTransferOwnershipResponse {
+}
 include!("haqq.dao.v1.serde.rs");
 include!("haqq.dao.v1.tonic.rs");
 // @@protoc_insertion_point(module)

src/gen/haqq.dao.v1.serde.rs

@@ -596,6 +596,186 @@ impl<'de> serde::Deserialize<'de> for MsgFundResponse {
         deserializer.deserialize_struct("haqq.dao.v1.MsgFundResponse", FIELDS, GeneratedVisitor)
     }
 }
+impl serde::Serialize for MsgTransferOwnership {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.owner.is_empty() {
+            len += 1;
+        }
+        if !self.new_owner.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("haqq.dao.v1.MsgTransferOwnership", len)?;
+        if !self.owner.is_empty() {
+            struct_ser.serialize_field("owner", &self.owner)?;
+        }
+        if !self.new_owner.is_empty() {
+            struct_ser.serialize_field("newOwner", &self.new_owner)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for MsgTransferOwnership {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "owner",
+            "new_owner",
+            "newOwner",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Owner,
+            NewOwner,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "owner" => Ok(GeneratedField::Owner),
+                            "newOwner" | "new_owner" => Ok(GeneratedField::NewOwner),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgTransferOwnership;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct haqq.dao.v1.MsgTransferOwnership")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgTransferOwnership, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut owner__ = None;
+                let mut new_owner__ = None;
+                while let Some(k) = map_.next_key()? {
+                    match k {
+                        GeneratedField::Owner => {
+                            if owner__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("owner"));
+                            }
+                            owner__ = Some(map_.next_value()?);
+                        }
+                        GeneratedField::NewOwner => {
+                            if new_owner__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("newOwner"));
+                            }
+                            new_owner__ = Some(map_.next_value()?);
+                        }
+                    }
+                }
+                Ok(MsgTransferOwnership {
+                    owner: owner__.unwrap_or_default(),
+                    new_owner: new_owner__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("haqq.dao.v1.MsgTransferOwnership", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for MsgTransferOwnershipResponse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer.serialize_struct("haqq.dao.v1.MsgTransferOwnershipResponse", len)?;
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for MsgTransferOwnershipResponse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                            Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MsgTransferOwnershipResponse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct haqq.dao.v1.MsgTransferOwnershipResponse")
+            }
+
+            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MsgTransferOwnershipResponse, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(MsgTransferOwnershipResponse {
+                })
+            }
+        }
+        deserializer.deserialize_struct("haqq.dao.v1.MsgTransferOwnershipResponse", FIELDS, GeneratedVisitor)
+    }
+}
 impl serde::Serialize for Params {
     #[allow(deprecated)]
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>

src/gen/haqq.dao.v1.tonic.rs

@@ -291,5 +291,30 @@ pub mod msg_client {
             req.extensions_mut().insert(GrpcMethod::new("haqq.dao.v1.Msg", "Fund"));
             self.inner.unary(req, path, codec).await
         }
+        pub async fn transfer_ownership(
+            &mut self,
+            request: impl tonic::IntoRequest<super::MsgTransferOwnership>,
+        ) -> std::result::Result<
+            tonic::Response<super::MsgTransferOwnershipResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/haqq.dao.v1.Msg/TransferOwnership",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("haqq.dao.v1.Msg", "TransferOwnership"));
+            self.inner.unary(req, path, codec).await
+        }
     }
 }

web/gen/proto/connect-web/haqq/dao/v1/tx_connect.ts

@@ -3,7 +3,7 @@
 /* eslint-disable */
 // @ts-nocheck
 
-import { MsgFund, MsgFundResponse } from "./tx_pb.js";
+import { MsgFund, MsgFundResponse, MsgTransferOwnership, MsgTransferOwnershipResponse } from "./tx_pb.js";
 import { MethodKind } from "@bufbuild/protobuf";
 
 /**
@@ -25,6 +25,17 @@ export const Msg = {
       O: MsgFundResponse,
       kind: MethodKind.Unary,
     },
+    /**
+     * TransferOwnership defines a method to allow an account to transfer the ownership of shares to another account.
+     *
+     * @generated from rpc haqq.dao.v1.Msg.TransferOwnership
+     */
+    transferOwnership: {
+      name: "TransferOwnership",
+      I: MsgTransferOwnership,
+      O: MsgTransferOwnershipResponse,
+      kind: MethodKind.Unary,
+    },
   }
 } as const;
 

web/gen/proto/connect-web/haqq/dao/v1/tx_pb.ts

@@ -85,3 +85,85 @@ export class MsgFundResponse extends Message<MsgFundResponse> {
   }
 }
 
+/**
+ * MsgTransferOwnership allows an account transfer the ownership of shares to another account.
+ *
+ * @generated from message haqq.dao.v1.MsgTransferOwnership
+ */
+export class MsgTransferOwnership extends Message<MsgTransferOwnership> {
+  /**
+   * owner is a current owner of the shares in dao.
+   *
+   * @generated from field: string owner = 1;
+   */
+  owner = "";
+
+  /**
+   * new_owner is a new owner of the shares in dao.
+   *
+   * @generated from field: string new_owner = 2;
+   */
+  newOwner = "";
+
+  constructor(data?: PartialMessage<MsgTransferOwnership>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "haqq.dao.v1.MsgTransferOwnership";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: "owner", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: "new_owner", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgTransferOwnership {
+    return new MsgTransferOwnership().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgTransferOwnership {
+    return new MsgTransferOwnership().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgTransferOwnership {
+    return new MsgTransferOwnership().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MsgTransferOwnership | PlainMessage<MsgTransferOwnership> | undefined, b: MsgTransferOwnership | PlainMessage<MsgTransferOwnership> | undefined): boolean {
+    return proto3.util.equals(MsgTransferOwnership, a, b);
+  }
+}
+
+/**
+ * MsgTransferOwnershipResponse defines the Msg/TransferOwnership response type.
+ *
+ * @generated from message haqq.dao.v1.MsgTransferOwnershipResponse
+ */
+export class MsgTransferOwnershipResponse extends Message<MsgTransferOwnershipResponse> {
+  constructor(data?: PartialMessage<MsgTransferOwnershipResponse>) {
+    super();
+    proto3.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto3 = proto3;
+  static readonly typeName = "haqq.dao.v1.MsgTransferOwnershipResponse";
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgTransferOwnershipResponse {
+    return new MsgTransferOwnershipResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgTransferOwnershipResponse {
+    return new MsgTransferOwnershipResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgTransferOwnershipResponse {
+    return new MsgTransferOwnershipResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: MsgTransferOwnershipResponse | PlainMessage<MsgTransferOwnershipResponse> | undefined, b: MsgTransferOwnershipResponse | PlainMessage<MsgTransferOwnershipResponse> | undefined): boolean {
+    return proto3.util.equals(MsgTransferOwnershipResponse, a, b);
+  }
+}
+