@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/esm/akash/provider/v1beta4/query.js

@@ -0,0 +1,295 @@
+//@ts-nocheck
+import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
+import { Provider } from "./provider";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseQueryProvidersRequest() {
+    return {
+        pagination: undefined
+    };
+}
+/**
+ * QueryProvidersRequest is request type for the Query/Providers RPC method
+ * @name QueryProvidersRequest
+ * @package akash.provider.v1beta4
+ * @see proto type: akash.provider.v1beta4.QueryProvidersRequest
+ */
+export const QueryProvidersRequest = {
+    typeUrl: "/akash.provider.v1beta4.QueryProvidersRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryProvidersRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryProvidersRequest();
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryProvidersRequest();
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryProvidersRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryProvidersRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryProvidersRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.provider.v1beta4.QueryProvidersRequest",
+            value: QueryProvidersRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryProvidersResponse() {
+    return {
+        providers: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryProvidersResponse is response type for the Query/Providers RPC method
+ * @name QueryProvidersResponse
+ * @package akash.provider.v1beta4
+ * @see proto type: akash.provider.v1beta4.QueryProvidersResponse
+ */
+export const QueryProvidersResponse = {
+    typeUrl: "/akash.provider.v1beta4.QueryProvidersResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.providers) {
+            Provider.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.pagination !== undefined) {
+            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryProvidersResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.providers.push(Provider.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryProvidersResponse();
+        message.providers = object.providers?.map(e => Provider.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryProvidersResponse();
+        message.providers = object.providers?.map(e => Provider.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.providers) {
+            obj.providers = message.providers.map(e => e ? Provider.toAmino(e) : undefined);
+        }
+        else {
+            obj.providers = message.providers;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryProvidersResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryProvidersResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryProvidersResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.provider.v1beta4.QueryProvidersResponse",
+            value: QueryProvidersResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryProviderRequest() {
+    return {
+        owner: ""
+    };
+}
+/**
+ * QueryProviderRequest is request type for the Query/Provider RPC method
+ * @name QueryProviderRequest
+ * @package akash.provider.v1beta4
+ * @see proto type: akash.provider.v1beta4.QueryProviderRequest
+ */
+export const QueryProviderRequest = {
+    typeUrl: "/akash.provider.v1beta4.QueryProviderRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryProviderRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryProviderRequest();
+        message.owner = object.owner ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryProviderRequest();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner === "" ? undefined : message.owner;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryProviderRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryProviderRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryProviderRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.provider.v1beta4.QueryProviderRequest",
+            value: QueryProviderRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryProviderResponse() {
+    return {
+        provider: Provider.fromPartial({})
+    };
+}
+/**
+ * QueryProviderResponse is response type for the Query/Provider RPC method.
+ * @name QueryProviderResponse
+ * @package akash.provider.v1beta4
+ * @see proto type: akash.provider.v1beta4.QueryProviderResponse
+ */
+export const QueryProviderResponse = {
+    typeUrl: "/akash.provider.v1beta4.QueryProviderResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.provider !== undefined) {
+            Provider.encode(message.provider, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryProviderResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.provider = Provider.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryProviderResponse();
+        message.provider = object.provider !== undefined && object.provider !== null ? Provider.fromPartial(object.provider) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryProviderResponse();
+        if (object.provider !== undefined && object.provider !== null) {
+            message.provider = Provider.fromAmino(object.provider);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.provider = message.provider ? Provider.toAmino(message.provider) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryProviderResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryProviderResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryProviderResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.provider.v1beta4.QueryProviderResponse",
+            value: QueryProviderResponse.encode(message).finish()
+        };
+    }
+};

package/esm/akash/provider/v1beta4/query.lcd.js

@@ -0,0 +1,26 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Providers queries providers */
+    providers = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `akash/provider/v1beta4/providers`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Provider queries provider details */
+    provider = async (params) => {
+        const endpoint = `akash/provider/v1beta4/providers/${params.owner}`;
+        return await this.req.get(endpoint);
+    };
+}

package/esm/akash/provider/v1beta4/query.rpc.Query.js

@@ -0,0 +1,35 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryProvidersRequest, QueryProvidersResponse, QueryProviderRequest, QueryProviderResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Providers queries providers */
+    providers = async (request = {
+        pagination: undefined
+    }) => {
+        const data = QueryProvidersRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.provider.v1beta4.Query", "Providers", data);
+        return promise.then(data => QueryProvidersResponse.decode(new BinaryReader(data)));
+    };
+    /* Provider queries provider details */
+    provider = async (request) => {
+        const data = QueryProviderRequest.encode(request).finish();
+        const promise = this.rpc.request("akash.provider.v1beta4.Query", "Provider", data);
+        return promise.then(data => QueryProviderResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        providers(request) {
+            return queryService.providers(request);
+        },
+        provider(request) {
+            return queryService.provider(request);
+        }
+    };
+};

package/esm/akash/provider/v1beta4/service.amino.js

@@ -0,0 +1,19 @@
+//@ts-nocheck
+import { MsgCreateProvider, MsgUpdateProvider, MsgDeleteProvider } from "./msg";
+export const AminoConverter = {
+    "/akash.provider.v1beta4.MsgCreateProvider": {
+        aminoType: "/akash.provider.v1beta4.MsgCreateProvider",
+        toAmino: MsgCreateProvider.toAmino,
+        fromAmino: MsgCreateProvider.fromAmino
+    },
+    "/akash.provider.v1beta4.MsgUpdateProvider": {
+        aminoType: "/akash.provider.v1beta4.MsgUpdateProvider",
+        toAmino: MsgUpdateProvider.toAmino,
+        fromAmino: MsgUpdateProvider.fromAmino
+    },
+    "/akash.provider.v1beta4.MsgDeleteProvider": {
+        aminoType: "/akash.provider.v1beta4.MsgDeleteProvider",
+        toAmino: MsgDeleteProvider.toAmino,
+        fromAmino: MsgDeleteProvider.fromAmino
+    }
+};

package/esm/akash/provider/v1beta4/service.js

@@ -0,0 +1 @@
+export {};

package/esm/akash/provider/v1beta4/service.registry.js

@@ -0,0 +1,69 @@
+import { MsgCreateProvider, MsgUpdateProvider, MsgDeleteProvider } from "./msg";
+export const registry = [["/akash.provider.v1beta4.MsgCreateProvider", MsgCreateProvider], ["/akash.provider.v1beta4.MsgUpdateProvider", MsgUpdateProvider], ["/akash.provider.v1beta4.MsgDeleteProvider", MsgDeleteProvider]];
+export const load = (protoRegistry) => {
+    registry.forEach(([typeUrl, mod]) => {
+        protoRegistry.register(typeUrl, mod);
+    });
+};
+export const MessageComposer = {
+    encoded: {
+        createProvider(value) {
+            return {
+                typeUrl: "/akash.provider.v1beta4.MsgCreateProvider",
+                value: MsgCreateProvider.encode(value).finish()
+            };
+        },
+        updateProvider(value) {
+            return {
+                typeUrl: "/akash.provider.v1beta4.MsgUpdateProvider",
+                value: MsgUpdateProvider.encode(value).finish()
+            };
+        },
+        deleteProvider(value) {
+            return {
+                typeUrl: "/akash.provider.v1beta4.MsgDeleteProvider",
+                value: MsgDeleteProvider.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        createProvider(value) {
+            return {
+                typeUrl: "/akash.provider.v1beta4.MsgCreateProvider",
+                value
+            };
+        },
+        updateProvider(value) {
+            return {
+                typeUrl: "/akash.provider.v1beta4.MsgUpdateProvider",
+                value
+            };
+        },
+        deleteProvider(value) {
+            return {
+                typeUrl: "/akash.provider.v1beta4.MsgDeleteProvider",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        createProvider(value) {
+            return {
+                typeUrl: "/akash.provider.v1beta4.MsgCreateProvider",
+                value: MsgCreateProvider.fromPartial(value)
+            };
+        },
+        updateProvider(value) {
+            return {
+                typeUrl: "/akash.provider.v1beta4.MsgUpdateProvider",
+                value: MsgUpdateProvider.fromPartial(value)
+            };
+        },
+        deleteProvider(value) {
+            return {
+                typeUrl: "/akash.provider.v1beta4.MsgDeleteProvider",
+                value: MsgDeleteProvider.fromPartial(value)
+            };
+        }
+    }
+};

package/esm/akash/provider/v1beta4/service.rpc.msg.js

@@ -0,0 +1,29 @@
+import { BinaryReader } from "../../../binary";
+import { MsgCreateProvider, MsgCreateProviderResponse, MsgUpdateProvider, MsgUpdateProviderResponse, MsgDeleteProvider, MsgDeleteProviderResponse } from "./msg";
+export class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* CreateProvider defines a method that creates a provider given the proper inputs. */
+    createProvider = async (request) => {
+        const data = MsgCreateProvider.encode(request).finish();
+        const promise = this.rpc.request("akash.provider.v1beta4.Msg", "CreateProvider", data);
+        return promise.then(data => MsgCreateProviderResponse.decode(new BinaryReader(data)));
+    };
+    /* UpdateProvider defines a method that updates a provider given the proper inputs. */
+    updateProvider = async (request) => {
+        const data = MsgUpdateProvider.encode(request).finish();
+        const promise = this.rpc.request("akash.provider.v1beta4.Msg", "UpdateProvider", data);
+        return promise.then(data => MsgUpdateProviderResponse.decode(new BinaryReader(data)));
+    };
+    /* DeleteProvider defines a method that deletes a provider given the proper inputs. */
+    deleteProvider = async (request) => {
+        const data = MsgDeleteProvider.encode(request).finish();
+        const promise = this.rpc.request("akash.provider.v1beta4.Msg", "DeleteProvider", data);
+        return promise.then(data => MsgDeleteProviderResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};

package/esm/akash/rpc.query.js

@@ -0,0 +1,98 @@
+//@ts-nocheck
+import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
+import { QueryClient } from "@cosmjs/stargate";
+export const createRPCQueryClient = async ({ rpcEndpoint }) => {
+    const tmClient = await Tendermint34Client.connect(rpcEndpoint);
+    const client = new QueryClient(tmClient);
+    return {
+        akash: {
+            audit: {
+                v1: (await import("./audit/v1/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta3: (await import("./audit/v1beta3/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            cert: {
+                v1: (await import("./cert/v1/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta3: (await import("./cert/v1beta3/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            deployment: {
+                v1beta3: (await import("./deployment/v1beta3/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta4: (await import("./deployment/v1beta4/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            escrow: {
+                v1: (await import("./escrow/v1/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta3: (await import("./escrow/v1beta3/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            market: {
+                v1beta4: (await import("./market/v1beta4/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta5: (await import("./market/v1beta5/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            provider: {
+                v1beta3: (await import("./provider/v1beta3/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta4: (await import("./provider/v1beta4/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            take: {
+                v1: (await import("./take/v1/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta3: (await import("./take/v1beta3/query.rpc.Query")).createRpcQueryExtension(client)
+            }
+        },
+        cosmos: {
+            auth: {
+                v1beta1: (await import("../cosmos/auth/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            authz: {
+                v1beta1: (await import("../cosmos/authz/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            bank: {
+                v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            base: {
+                node: {
+                    v1beta1: (await import("../cosmos/base/node/v1beta1/query.rpc.Service")).createRpcQueryExtension(client)
+                }
+            },
+            circuit: {
+                v1: (await import("../cosmos/circuit/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            consensus: {
+                v1: (await import("../cosmos/consensus/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            counter: {
+                v1: (await import("../cosmos/counter/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            distribution: {
+                v1beta1: (await import("../cosmos/distribution/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            epochs: {
+                v1beta1: (await import("../cosmos/epochs/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            feegrant: {
+                v1beta1: (await import("../cosmos/feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            gov: {
+                v1: (await import("../cosmos/gov/v1/query.rpc.Query")).createRpcQueryExtension(client),
+                v1beta1: (await import("../cosmos/gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            group: {
+                v1: (await import("../cosmos/group/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            mint: {
+                v1beta1: (await import("../cosmos/mint/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            params: {
+                v1beta1: (await import("../cosmos/params/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            protocolpool: {
+                v1: (await import("../cosmos/protocolpool/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            staking: {
+                v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            tx: {
+                v1beta1: (await import("../cosmos/tx/v1beta1/service.rpc.Service")).createRpcQueryExtension(client)
+            },
+            upgrade: {
+                v1beta1: (await import("../cosmos/upgrade/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            }
+        }
+    };
+};

package/esm/akash/rpc.tx.js

@@ -0,0 +1,78 @@
+export const createRPCMsgClient = async ({ rpc }) => ({
+    akash: {
+        audit: {
+            v1: new (await import("./audit/v1/service.rpc.msg")).MsgClientImpl(rpc),
+            v1beta3: new (await import("./audit/v1beta3/audit.rpc.msg")).MsgClientImpl(rpc)
+        },
+        cert: {
+            v1: new (await import("./cert/v1/service.rpc.msg")).MsgClientImpl(rpc),
+            v1beta3: new (await import("./cert/v1beta3/cert.rpc.msg")).MsgClientImpl(rpc)
+        },
+        deployment: {
+            v1beta3: new (await import("./deployment/v1beta3/service.rpc.msg")).MsgClientImpl(rpc),
+            v1beta4: new (await import("./deployment/v1beta4/service.rpc.msg")).MsgClientImpl(rpc)
+        },
+        market: {
+            v1beta4: new (await import("./market/v1beta4/service.rpc.msg")).MsgClientImpl(rpc),
+            v1beta5: new (await import("./market/v1beta5/service.rpc.msg")).MsgClientImpl(rpc)
+        },
+        provider: {
+            v1beta3: new (await import("./provider/v1beta3/provider.rpc.msg")).MsgClientImpl(rpc),
+            v1beta4: new (await import("./provider/v1beta4/service.rpc.msg")).MsgClientImpl(rpc)
+        },
+        take: {
+            v1: new (await import("./take/v1/service.rpc.msg")).MsgClientImpl(rpc)
+        }
+    },
+    cosmos: {
+        auth: {
+            v1beta1: new (await import("../cosmos/auth/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        authz: {
+            v1beta1: new (await import("../cosmos/authz/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        bank: {
+            v1beta1: new (await import("../cosmos/bank/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        benchmark: {
+            v1: new (await import("../cosmos/benchmark/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        circuit: {
+            v1: new (await import("../cosmos/circuit/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        consensus: {
+            v1: new (await import("../cosmos/consensus/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        counter: {
+            v1: new (await import("../cosmos/counter/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        distribution: {
+            v1beta1: new (await import("../cosmos/distribution/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        feegrant: {
+            v1beta1: new (await import("../cosmos/feegrant/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        gov: {
+            v1: new (await import("../cosmos/gov/v1/tx.rpc.msg")).MsgClientImpl(rpc),
+            v1beta1: new (await import("../cosmos/gov/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        group: {
+            v1: new (await import("../cosmos/group/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        mint: {
+            v1beta1: new (await import("../cosmos/mint/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        protocolpool: {
+            v1: new (await import("../cosmos/protocolpool/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        staking: {
+            v1beta1: new (await import("../cosmos/staking/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        upgrade: {
+            v1beta1: new (await import("../cosmos/upgrade/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        },
+        vesting: {
+            v1beta1: new (await import("../cosmos/vesting/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+        }
+    }
+});