@sparkdreamnft/sparkdreamjs 0.0.2 → 0.0.4

package/sparkdream/blog/tx.rpc.msg.js

@@ -1,36 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MsgClientImpl = void 0;
+exports.createClientImpl = exports.MsgClientImpl = void 0;
 const binary_1 = require("../../binary");
 const tx_1 = require("./tx");
 class MsgClientImpl {
     rpc;
     constructor(rpc) {
         this.rpc = rpc;
-        this.updateParams = this.updateParams.bind(this);
-        this.createPost = this.createPost.bind(this);
-        this.updatePost = this.updatePost.bind(this);
-        this.deletePost = this.deletePost.bind(this);
     }
-    updateParams(request) {
+    /* UpdateParams defines a (governance) operation for updating the module
+     parameters. The authority defaults to the x/gov module account. */
+    updateParams = async (request) => {
         const data = tx_1.MsgUpdateParams.encode(request).finish();
         const promise = this.rpc.request("sparkdream.blog.Msg", "UpdateParams", data);
         return promise.then(data => tx_1.MsgUpdateParamsResponse.decode(new binary_1.BinaryReader(data)));
-    }
-    createPost(request) {
+    };
+    /* CreatePost */
+    createPost = async (request) => {
         const data = tx_1.MsgCreatePost.encode(request).finish();
         const promise = this.rpc.request("sparkdream.blog.Msg", "CreatePost", data);
         return promise.then(data => tx_1.MsgCreatePostResponse.decode(new binary_1.BinaryReader(data)));
-    }
-    updatePost(request) {
+    };
+    /* UpdatePost */
+    updatePost = async (request) => {
         const data = tx_1.MsgUpdatePost.encode(request).finish();
         const promise = this.rpc.request("sparkdream.blog.Msg", "UpdatePost", data);
         return promise.then(data => tx_1.MsgUpdatePostResponse.decode(new binary_1.BinaryReader(data)));
-    }
-    deletePost(request) {
+    };
+    /* DeletePost */
+    deletePost = async (request) => {
         const data = tx_1.MsgDeletePost.encode(request).finish();
         const promise = this.rpc.request("sparkdream.blog.Msg", "DeletePost", data);
         return promise.then(data => tx_1.MsgDeletePostResponse.decode(new binary_1.BinaryReader(data)));
-    }
+    };
 }
 exports.MsgClientImpl = MsgClientImpl;
+const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+exports.createClientImpl = createClientImpl;

package/sparkdream/bundle.d.ts

@@ -16,6 +16,7 @@ import * as _335 from "./sparkdream/tx.rpc.msg";
 export declare namespace sparkdream {
     const blog: {
         MsgClientImpl: typeof _334.MsgClientImpl;
+        createClientImpl: (rpc: import("..").TxRpc) => _334.MsgClientImpl;
         QueryClientImpl: typeof _332.QueryClientImpl;
         createRpcQueryExtension: (base: QueryClient) => {
             params(request?: _176.QueryParamsRequest): Promise<_176.QueryParamsResponse>;
@@ -23,64 +24,7 @@ export declare namespace sparkdream {
             listPost(request?: _176.QueryListPostRequest): Promise<_176.QueryListPostResponse>;
         };
         LCDQueryClient: typeof _330.LCDQueryClient;
-        registry: ReadonlyArray<[string, GeneratedType]>;
-        load: (protoRegistry: Registry) => void;
-        MessageComposer: {
-            encoded: {
-                updateParams(value: _177.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
-                };
-                createPost(value: _177.MsgCreatePost): {
-                    typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
-                };
-                updatePost(value: _177.MsgUpdatePost): {
-                    typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
-                };
-                deletePost(value: _177.MsgDeletePost): {
-                    typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
-                };
-            };
-            withTypeUrl: {
-                updateParams(value: _177.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: _177.MsgUpdateParams;
-                };
-                createPost(value: _177.MsgCreatePost): {
-                    typeUrl: string;
-                    value: _177.MsgCreatePost;
-                };
-                updatePost(value: _177.MsgUpdatePost): {
-                    typeUrl: string;
-                    value: _177.MsgUpdatePost;
-                };
-                deletePost(value: _177.MsgDeletePost): {
-                    typeUrl: string;
-                    value: _177.MsgDeletePost;
-                };
-            };
-            fromPartial: {
-                updateParams(value: _177.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: _177.MsgUpdateParams;
-                };
-                createPost(value: _177.MsgCreatePost): {
-                    typeUrl: string;
-                    value: _177.MsgCreatePost;
-                };
-                updatePost(value: _177.MsgUpdatePost): {
-                    typeUrl: string;
-                    value: _177.MsgUpdatePost;
-                };
-                deletePost(value: _177.MsgDeletePost): {
-                    typeUrl: string;
-                    value: _177.MsgDeletePost;
-                };
-            };
-        };
+        registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
         AminoConverter: {
             "/sparkdream.blog.MsgUpdateParams": {
                 aminoType: string;
@@ -105,9 +49,10 @@ export declare namespace sparkdream {
         };
         MsgUpdateParams: {
             typeUrl: string;
+            aminoType: string;
             encode(message: _177.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgUpdateParams;
-            fromPartial(object: Partial<_177.MsgUpdateParams>): _177.MsgUpdateParams;
+            fromPartial(object: import("../helpers").DeepPartial<_177.MsgUpdateParams>): _177.MsgUpdateParams;
             fromAmino(object: _177.MsgUpdateParamsAmino): _177.MsgUpdateParams;
             toAmino(message: _177.MsgUpdateParams): _177.MsgUpdateParamsAmino;
             fromAminoMsg(object: _177.MsgUpdateParamsAminoMsg): _177.MsgUpdateParams;
@@ -120,7 +65,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(_: _177.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgUpdateParamsResponse;
-            fromPartial(_: Partial<_177.MsgUpdateParamsResponse>): _177.MsgUpdateParamsResponse;
+            fromPartial(_: import("../helpers").DeepPartial<_177.MsgUpdateParamsResponse>): _177.MsgUpdateParamsResponse;
             fromAmino(_: _177.MsgUpdateParamsResponseAmino): _177.MsgUpdateParamsResponse;
             toAmino(_: _177.MsgUpdateParamsResponse): _177.MsgUpdateParamsResponseAmino;
             fromAminoMsg(object: _177.MsgUpdateParamsResponseAminoMsg): _177.MsgUpdateParamsResponse;
@@ -132,7 +77,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _177.MsgCreatePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgCreatePost;
-            fromPartial(object: Partial<_177.MsgCreatePost>): _177.MsgCreatePost;
+            fromPartial(object: import("../helpers").DeepPartial<_177.MsgCreatePost>): _177.MsgCreatePost;
             fromAmino(object: _177.MsgCreatePostAmino): _177.MsgCreatePost;
             toAmino(message: _177.MsgCreatePost): _177.MsgCreatePostAmino;
             fromAminoMsg(object: _177.MsgCreatePostAminoMsg): _177.MsgCreatePost;
@@ -144,7 +89,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _177.MsgCreatePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgCreatePostResponse;
-            fromPartial(object: Partial<_177.MsgCreatePostResponse>): _177.MsgCreatePostResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_177.MsgCreatePostResponse>): _177.MsgCreatePostResponse;
             fromAmino(object: _177.MsgCreatePostResponseAmino): _177.MsgCreatePostResponse;
             toAmino(message: _177.MsgCreatePostResponse): _177.MsgCreatePostResponseAmino;
             fromAminoMsg(object: _177.MsgCreatePostResponseAminoMsg): _177.MsgCreatePostResponse;
@@ -156,7 +101,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _177.MsgUpdatePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgUpdatePost;
-            fromPartial(object: Partial<_177.MsgUpdatePost>): _177.MsgUpdatePost;
+            fromPartial(object: import("../helpers").DeepPartial<_177.MsgUpdatePost>): _177.MsgUpdatePost;
             fromAmino(object: _177.MsgUpdatePostAmino): _177.MsgUpdatePost;
             toAmino(message: _177.MsgUpdatePost): _177.MsgUpdatePostAmino;
             fromAminoMsg(object: _177.MsgUpdatePostAminoMsg): _177.MsgUpdatePost;
@@ -168,7 +113,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(_: _177.MsgUpdatePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgUpdatePostResponse;
-            fromPartial(_: Partial<_177.MsgUpdatePostResponse>): _177.MsgUpdatePostResponse;
+            fromPartial(_: import("../helpers").DeepPartial<_177.MsgUpdatePostResponse>): _177.MsgUpdatePostResponse;
             fromAmino(_: _177.MsgUpdatePostResponseAmino): _177.MsgUpdatePostResponse;
             toAmino(_: _177.MsgUpdatePostResponse): _177.MsgUpdatePostResponseAmino;
             fromAminoMsg(object: _177.MsgUpdatePostResponseAminoMsg): _177.MsgUpdatePostResponse;
@@ -180,7 +125,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _177.MsgDeletePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgDeletePost;
-            fromPartial(object: Partial<_177.MsgDeletePost>): _177.MsgDeletePost;
+            fromPartial(object: import("../helpers").DeepPartial<_177.MsgDeletePost>): _177.MsgDeletePost;
             fromAmino(object: _177.MsgDeletePostAmino): _177.MsgDeletePost;
             toAmino(message: _177.MsgDeletePost): _177.MsgDeletePostAmino;
             fromAminoMsg(object: _177.MsgDeletePostAminoMsg): _177.MsgDeletePost;
@@ -192,7 +137,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(_: _177.MsgDeletePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgDeletePostResponse;
-            fromPartial(_: Partial<_177.MsgDeletePostResponse>): _177.MsgDeletePostResponse;
+            fromPartial(_: import("../helpers").DeepPartial<_177.MsgDeletePostResponse>): _177.MsgDeletePostResponse;
             fromAmino(_: _177.MsgDeletePostResponseAmino): _177.MsgDeletePostResponse;
             toAmino(_: _177.MsgDeletePostResponse): _177.MsgDeletePostResponseAmino;
             fromAminoMsg(object: _177.MsgDeletePostResponseAminoMsg): _177.MsgDeletePostResponse;
@@ -204,7 +149,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(_: _176.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryParamsRequest;
-            fromPartial(_: Partial<_176.QueryParamsRequest>): _176.QueryParamsRequest;
+            fromPartial(_: import("../helpers").DeepPartial<_176.QueryParamsRequest>): _176.QueryParamsRequest;
             fromAmino(_: _176.QueryParamsRequestAmino): _176.QueryParamsRequest;
             toAmino(_: _176.QueryParamsRequest): _176.QueryParamsRequestAmino;
             fromAminoMsg(object: _176.QueryParamsRequestAminoMsg): _176.QueryParamsRequest;
@@ -216,7 +161,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _176.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryParamsResponse;
-            fromPartial(object: Partial<_176.QueryParamsResponse>): _176.QueryParamsResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_176.QueryParamsResponse>): _176.QueryParamsResponse;
             fromAmino(object: _176.QueryParamsResponseAmino): _176.QueryParamsResponse;
             toAmino(message: _176.QueryParamsResponse): _176.QueryParamsResponseAmino;
             fromAminoMsg(object: _176.QueryParamsResponseAminoMsg): _176.QueryParamsResponse;
@@ -228,7 +173,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _176.QueryShowPostRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryShowPostRequest;
-            fromPartial(object: Partial<_176.QueryShowPostRequest>): _176.QueryShowPostRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_176.QueryShowPostRequest>): _176.QueryShowPostRequest;
             fromAmino(object: _176.QueryShowPostRequestAmino): _176.QueryShowPostRequest;
             toAmino(message: _176.QueryShowPostRequest): _176.QueryShowPostRequestAmino;
             fromAminoMsg(object: _176.QueryShowPostRequestAminoMsg): _176.QueryShowPostRequest;
@@ -240,7 +185,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _176.QueryShowPostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryShowPostResponse;
-            fromPartial(object: Partial<_176.QueryShowPostResponse>): _176.QueryShowPostResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_176.QueryShowPostResponse>): _176.QueryShowPostResponse;
             fromAmino(object: _176.QueryShowPostResponseAmino): _176.QueryShowPostResponse;
             toAmino(message: _176.QueryShowPostResponse): _176.QueryShowPostResponseAmino;
             fromAminoMsg(object: _176.QueryShowPostResponseAminoMsg): _176.QueryShowPostResponse;
@@ -252,7 +197,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _176.QueryListPostRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryListPostRequest;
-            fromPartial(object: Partial<_176.QueryListPostRequest>): _176.QueryListPostRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_176.QueryListPostRequest>): _176.QueryListPostRequest;
             fromAmino(object: _176.QueryListPostRequestAmino): _176.QueryListPostRequest;
             toAmino(message: _176.QueryListPostRequest): _176.QueryListPostRequestAmino;
             fromAminoMsg(object: _176.QueryListPostRequestAminoMsg): _176.QueryListPostRequest;
@@ -264,7 +209,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _176.QueryListPostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryListPostResponse;
-            fromPartial(object: Partial<_176.QueryListPostResponse>): _176.QueryListPostResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_176.QueryListPostResponse>): _176.QueryListPostResponse;
             fromAmino(object: _176.QueryListPostResponseAmino): _176.QueryListPostResponse;
             toAmino(message: _176.QueryListPostResponse): _176.QueryListPostResponseAmino;
             fromAminoMsg(object: _176.QueryListPostResponseAminoMsg): _176.QueryListPostResponse;
@@ -276,7 +221,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _175.Post, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _175.Post;
-            fromPartial(object: Partial<_175.Post>): _175.Post;
+            fromPartial(object: import("../helpers").DeepPartial<_175.Post>): _175.Post;
             fromAmino(object: _175.PostAmino): _175.Post;
             toAmino(message: _175.Post): _175.PostAmino;
             fromAminoMsg(object: _175.PostAminoMsg): _175.Post;
@@ -286,9 +231,10 @@ export declare namespace sparkdream {
         };
         Params: {
             typeUrl: string;
+            aminoType: string;
             encode(_: _174.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _174.Params;
-            fromPartial(_: Partial<_174.Params>): _174.Params;
+            fromPartial(_: import("../helpers").DeepPartial<_174.Params>): _174.Params;
             fromAmino(_: _174.ParamsAmino): _174.Params;
             toAmino(_: _174.Params): _174.ParamsAmino;
             fromAminoMsg(object: _174.ParamsAminoMsg): _174.Params;
@@ -301,7 +247,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _173.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _173.GenesisState;
-            fromPartial(object: Partial<_173.GenesisState>): _173.GenesisState;
+            fromPartial(object: import("../helpers").DeepPartial<_173.GenesisState>): _173.GenesisState;
             fromAmino(object: _173.GenesisStateAmino): _173.GenesisState;
             toAmino(message: _173.GenesisState): _173.GenesisStateAmino;
             fromAminoMsg(object: _173.GenesisStateAminoMsg): _173.GenesisState;
@@ -312,33 +258,13 @@ export declare namespace sparkdream {
     };
     const sparkdream: {
         MsgClientImpl: typeof _335.MsgClientImpl;
+        createClientImpl: (rpc: import("..").TxRpc) => _335.MsgClientImpl;
         QueryClientImpl: typeof _333.QueryClientImpl;
         createRpcQueryExtension: (base: QueryClient) => {
             params(request?: _180.QueryParamsRequest): Promise<_180.QueryParamsResponse>;
         };
         LCDQueryClient: typeof _331.LCDQueryClient;
-        registry: ReadonlyArray<[string, GeneratedType]>;
-        load: (protoRegistry: Registry) => void;
-        MessageComposer: {
-            encoded: {
-                updateParams(value: _181.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
-                };
-            };
-            withTypeUrl: {
-                updateParams(value: _181.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: _181.MsgUpdateParams;
-                };
-            };
-            fromPartial: {
-                updateParams(value: _181.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: _181.MsgUpdateParams;
-                };
-            };
-        };
+        registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
         AminoConverter: {
             "/sparkdream.sparkdream.MsgUpdateParams": {
                 aminoType: string;
@@ -348,9 +274,10 @@ export declare namespace sparkdream {
         };
         MsgUpdateParams: {
             typeUrl: string;
+            aminoType: string;
             encode(message: _181.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _181.MsgUpdateParams;
-            fromPartial(object: Partial<_181.MsgUpdateParams>): _181.MsgUpdateParams;
+            fromPartial(object: import("../helpers").DeepPartial<_181.MsgUpdateParams>): _181.MsgUpdateParams;
             fromAmino(object: _181.MsgUpdateParamsAmino): _181.MsgUpdateParams;
             toAmino(message: _181.MsgUpdateParams): _181.MsgUpdateParamsAmino;
             fromAminoMsg(object: _181.MsgUpdateParamsAminoMsg): _181.MsgUpdateParams;
@@ -363,7 +290,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(_: _181.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _181.MsgUpdateParamsResponse;
-            fromPartial(_: Partial<_181.MsgUpdateParamsResponse>): _181.MsgUpdateParamsResponse;
+            fromPartial(_: import("../helpers").DeepPartial<_181.MsgUpdateParamsResponse>): _181.MsgUpdateParamsResponse;
             fromAmino(_: _181.MsgUpdateParamsResponseAmino): _181.MsgUpdateParamsResponse;
             toAmino(_: _181.MsgUpdateParamsResponse): _181.MsgUpdateParamsResponseAmino;
             fromAminoMsg(object: _181.MsgUpdateParamsResponseAminoMsg): _181.MsgUpdateParamsResponse;
@@ -375,7 +302,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(_: _180.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.QueryParamsRequest;
-            fromPartial(_: Partial<_180.QueryParamsRequest>): _180.QueryParamsRequest;
+            fromPartial(_: import("../helpers").DeepPartial<_180.QueryParamsRequest>): _180.QueryParamsRequest;
             fromAmino(_: _180.QueryParamsRequestAmino): _180.QueryParamsRequest;
             toAmino(_: _180.QueryParamsRequest): _180.QueryParamsRequestAmino;
             fromAminoMsg(object: _180.QueryParamsRequestAminoMsg): _180.QueryParamsRequest;
@@ -387,7 +314,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _180.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.QueryParamsResponse;
-            fromPartial(object: Partial<_180.QueryParamsResponse>): _180.QueryParamsResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_180.QueryParamsResponse>): _180.QueryParamsResponse;
             fromAmino(object: _180.QueryParamsResponseAmino): _180.QueryParamsResponse;
             toAmino(message: _180.QueryParamsResponse): _180.QueryParamsResponseAmino;
             fromAminoMsg(object: _180.QueryParamsResponseAminoMsg): _180.QueryParamsResponse;
@@ -397,9 +324,10 @@ export declare namespace sparkdream {
         };
         Params: {
             typeUrl: string;
+            aminoType: string;
             encode(_: _179.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _179.Params;
-            fromPartial(_: Partial<_179.Params>): _179.Params;
+            fromPartial(_: import("../helpers").DeepPartial<_179.Params>): _179.Params;
             fromAmino(_: _179.ParamsAmino): _179.Params;
             toAmino(_: _179.Params): _179.ParamsAmino;
             fromAminoMsg(object: _179.ParamsAminoMsg): _179.Params;
@@ -412,7 +340,7 @@ export declare namespace sparkdream {
             typeUrl: string;
             encode(message: _178.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
             decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.GenesisState;
-            fromPartial(object: Partial<_178.GenesisState>): _178.GenesisState;
+            fromPartial(object: import("../helpers").DeepPartial<_178.GenesisState>): _178.GenesisState;
             fromAmino(object: _178.GenesisStateAmino): _178.GenesisState;
             toAmino(message: _178.GenesisState): _178.GenesisStateAmino;
             fromAminoMsg(object: _178.GenesisStateAminoMsg): _178.GenesisState;

package/sparkdream/sparkdream/genesis.d.ts

@@ -1,5 +1,6 @@
-import { Params, ParamsAmino, ParamsSDKType } from "./params";
+import { Params, ParamsAmino } from "./params";
 import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
 /** GenesisState defines the sparkdream module's genesis state. */
 export interface GenesisState {
     /** params defines all the parameters of the module. */
@@ -18,15 +19,11 @@ export interface GenesisStateAminoMsg {
     type: "/sparkdream.sparkdream.GenesisState";
     value: GenesisStateAmino;
 }
-/** GenesisState defines the sparkdream module's genesis state. */
-export interface GenesisStateSDKType {
-    params: ParamsSDKType;
-}
 export declare const GenesisState: {
     typeUrl: string;
     encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
-    fromPartial(object: Partial<GenesisState>): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
     fromAmino(object: GenesisStateAmino): GenesisState;
     toAmino(message: GenesisState): GenesisStateAmino;
     fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;

package/sparkdream/sparkdream/module/module.d.ts

@@ -1,4 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
 /** Module is the config object for the module. */
 export interface Module {
     /** authority defines the custom module authority. If not set, defaults to the governance module. */
@@ -17,15 +18,11 @@ export interface ModuleAminoMsg {
     type: "/sparkdream.sparkdream.module.Module";
     value: ModuleAmino;
 }
-/** Module is the config object for the module. */
-export interface ModuleSDKType {
-    authority: string;
-}
 export declare const Module: {
     typeUrl: string;
     encode(message: Module, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): Module;
-    fromPartial(object: Partial<Module>): Module;
+    fromPartial(object: DeepPartial<Module>): Module;
     fromAmino(object: ModuleAmino): Module;
     toAmino(message: Module): ModuleAmino;
     fromAminoMsg(object: ModuleAminoMsg): Module;

package/sparkdream/sparkdream/params.d.ts

@@ -1,4 +1,5 @@
 import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
 /** Params defines the parameters for the module. */
 export interface Params {
 }
@@ -13,14 +14,12 @@ export interface ParamsAminoMsg {
     type: "sparkdream/x/sparkdream/Params";
     value: ParamsAmino;
 }
-/** Params defines the parameters for the module. */
-export interface ParamsSDKType {
-}
 export declare const Params: {
     typeUrl: string;
+    aminoType: string;
     encode(_: Params, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): Params;
-    fromPartial(_: Partial<Params>): Params;
+    fromPartial(_: DeepPartial<Params>): Params;
     fromAmino(_: ParamsAmino): Params;
     toAmino(_: Params): ParamsAmino;
     fromAminoMsg(object: ParamsAminoMsg): Params;

package/sparkdream/sparkdream/params.js

@@ -8,6 +8,7 @@ function createBaseParams() {
 }
 exports.Params = {
     typeUrl: "/sparkdream.sparkdream.Params",
+    aminoType: "sparkdream/x/sparkdream/Params",
     encode(_, writer = binary_1.BinaryWriter.create()) {
         return writer;
     },

package/sparkdream/sparkdream/query.d.ts

@@ -1,5 +1,6 @@
-import { Params, ParamsAmino, ParamsSDKType } from "./params";
+import { Params, ParamsAmino } from "./params";
 import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
 /** QueryParamsRequest is request type for the Query/Params RPC method. */
 export interface QueryParamsRequest {
 }
@@ -14,9 +15,6 @@ export interface QueryParamsRequestAminoMsg {
     type: "/sparkdream.sparkdream.QueryParamsRequest";
     value: QueryParamsRequestAmino;
 }
-/** QueryParamsRequest is request type for the Query/Params RPC method. */
-export interface QueryParamsRequestSDKType {
-}
 /** QueryParamsResponse is response type for the Query/Params RPC method. */
 export interface QueryParamsResponse {
     /** params holds all the parameters of this module. */
@@ -35,15 +33,11 @@ export interface QueryParamsResponseAminoMsg {
     type: "/sparkdream.sparkdream.QueryParamsResponse";
     value: QueryParamsResponseAmino;
 }
-/** QueryParamsResponse is response type for the Query/Params RPC method. */
-export interface QueryParamsResponseSDKType {
-    params: ParamsSDKType;
-}
 export declare const QueryParamsRequest: {
     typeUrl: string;
     encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
-    fromPartial(_: Partial<QueryParamsRequest>): QueryParamsRequest;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
     fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
     toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
     fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
@@ -55,7 +49,7 @@ export declare const QueryParamsResponse: {
     typeUrl: string;
     encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
-    fromPartial(object: Partial<QueryParamsResponse>): QueryParamsResponse;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
     fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
     toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
     fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;

package/sparkdream/sparkdream/query.lcd.d.ts

@@ -1,9 +1,9 @@
 import { LCDClient } from "@cosmology/lcd";
-import { QueryParamsRequest, QueryParamsResponseSDKType } from "./query";
+import { QueryParamsRequest, QueryParamsResponse } from "./query";
 export declare class LCDQueryClient {
     req: LCDClient;
     constructor({ requestClient }: {
         requestClient: LCDClient;
     });
-    params(_params?: QueryParamsRequest): Promise<QueryParamsResponseSDKType>;
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
 }

package/sparkdream/sparkdream/query.lcd.js

@@ -5,12 +5,11 @@ class LCDQueryClient {
     req;
     constructor({ requestClient }) {
         this.req = requestClient;
-        this.params = this.params.bind(this);
     }
     /* Parameters queries the parameters of the module. */
-    async params(_params = {}) {
+    params = async (_params = {}) => {
         const endpoint = `sparkdream/sparkdream/params`;
         return await this.req.get(endpoint);
-    }
+    };
 }
 exports.LCDQueryClient = LCDQueryClient;

package/sparkdream/sparkdream/query.rpc.Query.d.ts

@@ -1,4 +1,4 @@
-import { Rpc } from "../../helpers";
+import { TxRpc } from "../../types";
 import { QueryClient } from "@cosmjs/stargate";
 import { QueryParamsRequest, QueryParamsResponse } from "./query";
 /** Query defines the gRPC querier service. */
@@ -8,8 +8,8 @@ export interface Query {
 }
 export declare class QueryClientImpl implements Query {
     private readonly rpc;
-    constructor(rpc: Rpc);
-    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    constructor(rpc: TxRpc);
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
 }
 export declare const createRpcQueryExtension: (base: QueryClient) => {
     params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;

package/sparkdream/sparkdream/query.rpc.Query.js

@@ -8,13 +8,13 @@ class QueryClientImpl {
     rpc;
     constructor(rpc) {
         this.rpc = rpc;
-        this.params = this.params.bind(this);
     }
-    params(request = {}) {
+    /* Parameters queries the parameters of the module. */
+    params = async (request = {}) => {
         const data = query_1.QueryParamsRequest.encode(request).finish();
         const promise = this.rpc.request("sparkdream.sparkdream.Query", "Params", data);
         return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
-    }
+    };
 }
 exports.QueryClientImpl = QueryClientImpl;
 const createRpcQueryExtension = (base) => {

package/sparkdream/sparkdream/tx.d.ts

@@ -1,5 +1,6 @@
-import { Params, ParamsAmino, ParamsSDKType } from "./params";
+import { Params, ParamsAmino } from "./params";
 import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
 /** MsgUpdateParams is the Msg/UpdateParams request type. */
 export interface MsgUpdateParams {
     /** authority is the address that controls the module (defaults to x/gov unless overwritten). */
@@ -30,11 +31,6 @@ export interface MsgUpdateParamsAminoMsg {
     type: "sparkdream/x/sparkdream/MsgUpdateParams";
     value: MsgUpdateParamsAmino;
 }
-/** MsgUpdateParams is the Msg/UpdateParams request type. */
-export interface MsgUpdateParamsSDKType {
-    authority: string;
-    params: ParamsSDKType;
-}
 /**
  * MsgUpdateParamsResponse defines the response structure for executing a
  * MsgUpdateParams message.
@@ -55,17 +51,12 @@ export interface MsgUpdateParamsResponseAminoMsg {
     type: "/sparkdream.sparkdream.MsgUpdateParamsResponse";
     value: MsgUpdateParamsResponseAmino;
 }
-/**
- * MsgUpdateParamsResponse defines the response structure for executing a
- * MsgUpdateParams message.
- */
-export interface MsgUpdateParamsResponseSDKType {
-}
 export declare const MsgUpdateParams: {
     typeUrl: string;
+    aminoType: string;
     encode(message: MsgUpdateParams, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParams;
-    fromPartial(object: Partial<MsgUpdateParams>): MsgUpdateParams;
+    fromPartial(object: DeepPartial<MsgUpdateParams>): MsgUpdateParams;
     fromAmino(object: MsgUpdateParamsAmino): MsgUpdateParams;
     toAmino(message: MsgUpdateParams): MsgUpdateParamsAmino;
     fromAminoMsg(object: MsgUpdateParamsAminoMsg): MsgUpdateParams;
@@ -78,7 +69,7 @@ export declare const MsgUpdateParamsResponse: {
     typeUrl: string;
     encode(_: MsgUpdateParamsResponse, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParamsResponse;
-    fromPartial(_: Partial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse;
+    fromPartial(_: DeepPartial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse;
     fromAmino(_: MsgUpdateParamsResponseAmino): MsgUpdateParamsResponse;
     toAmino(_: MsgUpdateParamsResponse): MsgUpdateParamsResponseAmino;
     fromAminoMsg(object: MsgUpdateParamsResponseAminoMsg): MsgUpdateParamsResponse;

package/sparkdream/sparkdream/tx.js

@@ -12,6 +12,7 @@ function createBaseMsgUpdateParams() {
 }
 exports.MsgUpdateParams = {
     typeUrl: "/sparkdream.sparkdream.MsgUpdateParams",
+    aminoType: "sparkdream/x/sparkdream/MsgUpdateParams",
     encode(message, writer = binary_1.BinaryWriter.create()) {
         if (message.authority !== "") {
             writer.uint32(10).string(message.authority);