@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.32

package/esm/akash/deployment/{v1beta3 → v1beta5}/service.registry.js

@@ -1,6 +1,7 @@
-import { MsgCreateDeployment, MsgDepositDeployment, MsgUpdateDeployment, MsgCloseDeployment } from "./deploymentmsg";
+import { MsgCreateDeployment, MsgUpdateDeployment, MsgCloseDeployment } from "./deploymentmsg";
 import { MsgCloseGroup, MsgPauseGroup, MsgStartGroup } from "./groupmsg";
-export const registry = [["/akash.deployment.v1beta3.MsgCreateDeployment", MsgCreateDeployment], ["/akash.deployment.v1beta3.MsgDepositDeployment", MsgDepositDeployment], ["/akash.deployment.v1beta3.MsgUpdateDeployment", MsgUpdateDeployment], ["/akash.deployment.v1beta3.MsgCloseDeployment", MsgCloseDeployment], ["/akash.deployment.v1beta3.MsgCloseGroup", MsgCloseGroup], ["/akash.deployment.v1beta3.MsgPauseGroup", MsgPauseGroup], ["/akash.deployment.v1beta3.MsgStartGroup", MsgStartGroup]];
+import { MsgUpdateParams } from "./paramsmsg";
+export const registry = [["/akash.deployment.v1beta5.MsgCreateDeployment", MsgCreateDeployment], ["/akash.deployment.v1beta5.MsgUpdateDeployment", MsgUpdateDeployment], ["/akash.deployment.v1beta5.MsgCloseDeployment", MsgCloseDeployment], ["/akash.deployment.v1beta5.MsgCloseGroup", MsgCloseGroup], ["/akash.deployment.v1beta5.MsgPauseGroup", MsgPauseGroup], ["/akash.deployment.v1beta5.MsgStartGroup", MsgStartGroup], ["/akash.deployment.v1beta5.MsgUpdateParams", MsgUpdateParams]];
 export const load = (protoRegistry) => {
     registry.forEach(([typeUrl, mod]) => {
         protoRegistry.register(typeUrl, mod);
@@ -10,87 +11,87 @@ export const MessageComposer = {
     encoded: {
         createDeployment(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgCreateDeployment",
+                typeUrl: "/akash.deployment.v1beta5.MsgCreateDeployment",
                 value: MsgCreateDeployment.encode(value).finish()
             };
         },
-        depositDeployment(value) {
-            return {
-                typeUrl: "/akash.deployment.v1beta3.MsgDepositDeployment",
-                value: MsgDepositDeployment.encode(value).finish()
-            };
-        },
         updateDeployment(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgUpdateDeployment",
+                typeUrl: "/akash.deployment.v1beta5.MsgUpdateDeployment",
                 value: MsgUpdateDeployment.encode(value).finish()
             };
         },
         closeDeployment(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgCloseDeployment",
+                typeUrl: "/akash.deployment.v1beta5.MsgCloseDeployment",
                 value: MsgCloseDeployment.encode(value).finish()
             };
         },
         closeGroup(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgCloseGroup",
+                typeUrl: "/akash.deployment.v1beta5.MsgCloseGroup",
                 value: MsgCloseGroup.encode(value).finish()
             };
         },
         pauseGroup(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgPauseGroup",
+                typeUrl: "/akash.deployment.v1beta5.MsgPauseGroup",
                 value: MsgPauseGroup.encode(value).finish()
             };
         },
         startGroup(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgStartGroup",
+                typeUrl: "/akash.deployment.v1beta5.MsgStartGroup",
                 value: MsgStartGroup.encode(value).finish()
             };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/akash.deployment.v1beta5.MsgUpdateParams",
+                value: MsgUpdateParams.encode(value).finish()
+            };
         }
     },
     withTypeUrl: {
         createDeployment(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgCreateDeployment",
-                value
-            };
-        },
-        depositDeployment(value) {
-            return {
-                typeUrl: "/akash.deployment.v1beta3.MsgDepositDeployment",
+                typeUrl: "/akash.deployment.v1beta5.MsgCreateDeployment",
                 value
             };
         },
         updateDeployment(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgUpdateDeployment",
+                typeUrl: "/akash.deployment.v1beta5.MsgUpdateDeployment",
                 value
             };
         },
         closeDeployment(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgCloseDeployment",
+                typeUrl: "/akash.deployment.v1beta5.MsgCloseDeployment",
                 value
             };
         },
         closeGroup(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgCloseGroup",
+                typeUrl: "/akash.deployment.v1beta5.MsgCloseGroup",
                 value
             };
         },
         pauseGroup(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgPauseGroup",
+                typeUrl: "/akash.deployment.v1beta5.MsgPauseGroup",
                 value
             };
         },
         startGroup(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgStartGroup",
+                typeUrl: "/akash.deployment.v1beta5.MsgStartGroup",
+                value
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/akash.deployment.v1beta5.MsgUpdateParams",
                 value
             };
         }
@@ -98,45 +99,45 @@ export const MessageComposer = {
     fromPartial: {
         createDeployment(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgCreateDeployment",
+                typeUrl: "/akash.deployment.v1beta5.MsgCreateDeployment",
                 value: MsgCreateDeployment.fromPartial(value)
             };
         },
-        depositDeployment(value) {
-            return {
-                typeUrl: "/akash.deployment.v1beta3.MsgDepositDeployment",
-                value: MsgDepositDeployment.fromPartial(value)
-            };
-        },
         updateDeployment(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgUpdateDeployment",
+                typeUrl: "/akash.deployment.v1beta5.MsgUpdateDeployment",
                 value: MsgUpdateDeployment.fromPartial(value)
             };
         },
         closeDeployment(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgCloseDeployment",
+                typeUrl: "/akash.deployment.v1beta5.MsgCloseDeployment",
                 value: MsgCloseDeployment.fromPartial(value)
             };
         },
         closeGroup(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgCloseGroup",
+                typeUrl: "/akash.deployment.v1beta5.MsgCloseGroup",
                 value: MsgCloseGroup.fromPartial(value)
             };
         },
         pauseGroup(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgPauseGroup",
+                typeUrl: "/akash.deployment.v1beta5.MsgPauseGroup",
                 value: MsgPauseGroup.fromPartial(value)
             };
         },
         startGroup(value) {
             return {
-                typeUrl: "/akash.deployment.v1beta3.MsgStartGroup",
+                typeUrl: "/akash.deployment.v1beta5.MsgStartGroup",
                 value: MsgStartGroup.fromPartial(value)
             };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/akash.deployment.v1beta5.MsgUpdateParams",
+                value: MsgUpdateParams.fromPartial(value)
+            };
         }
     }
 };

package/esm/akash/deployment/{v1beta3 → v1beta5}/service.rpc.msg.js

@@ -1,6 +1,7 @@
 import { BinaryReader } from "../../../binary";
-import { MsgCreateDeployment, MsgCreateDeploymentResponse, MsgDepositDeployment, MsgDepositDeploymentResponse, MsgUpdateDeployment, MsgUpdateDeploymentResponse, MsgCloseDeployment, MsgCloseDeploymentResponse } from "./deploymentmsg";
+import { MsgCreateDeployment, MsgCreateDeploymentResponse, MsgUpdateDeployment, MsgUpdateDeploymentResponse, MsgCloseDeployment, MsgCloseDeploymentResponse } from "./deploymentmsg";
 import { MsgCloseGroup, MsgCloseGroupResponse, MsgPauseGroup, MsgPauseGroupResponse, MsgStartGroup, MsgStartGroupResponse } from "./groupmsg";
+import { MsgUpdateParams, MsgUpdateParamsResponse } from "./paramsmsg";
 export class MsgClientImpl {
     rpc;
     constructor(rpc) {
@@ -9,45 +10,48 @@ export class MsgClientImpl {
     /* CreateDeployment defines a method to create new deployment given proper inputs. */
     createDeployment = async (request) => {
         const data = MsgCreateDeployment.encode(request).finish();
-        const promise = this.rpc.request("akash.deployment.v1beta3.Msg", "CreateDeployment", data);
+        const promise = this.rpc.request("akash.deployment.v1beta5.Msg", "CreateDeployment", data);
         return promise.then(data => MsgCreateDeploymentResponse.decode(new BinaryReader(data)));
     };
-    /* DepositDeployment deposits more funds into the deployment account */
-    depositDeployment = async (request) => {
-        const data = MsgDepositDeployment.encode(request).finish();
-        const promise = this.rpc.request("akash.deployment.v1beta3.Msg", "DepositDeployment", data);
-        return promise.then(data => MsgDepositDeploymentResponse.decode(new BinaryReader(data)));
-    };
     /* UpdateDeployment defines a method to update a deployment given proper inputs. */
     updateDeployment = async (request) => {
         const data = MsgUpdateDeployment.encode(request).finish();
-        const promise = this.rpc.request("akash.deployment.v1beta3.Msg", "UpdateDeployment", data);
+        const promise = this.rpc.request("akash.deployment.v1beta5.Msg", "UpdateDeployment", data);
         return promise.then(data => MsgUpdateDeploymentResponse.decode(new BinaryReader(data)));
     };
     /* CloseDeployment defines a method to close a deployment given proper inputs. */
     closeDeployment = async (request) => {
         const data = MsgCloseDeployment.encode(request).finish();
-        const promise = this.rpc.request("akash.deployment.v1beta3.Msg", "CloseDeployment", data);
+        const promise = this.rpc.request("akash.deployment.v1beta5.Msg", "CloseDeployment", data);
         return promise.then(data => MsgCloseDeploymentResponse.decode(new BinaryReader(data)));
     };
     /* CloseGroup defines a method to close a group of a deployment given proper inputs. */
     closeGroup = async (request) => {
         const data = MsgCloseGroup.encode(request).finish();
-        const promise = this.rpc.request("akash.deployment.v1beta3.Msg", "CloseGroup", data);
+        const promise = this.rpc.request("akash.deployment.v1beta5.Msg", "CloseGroup", data);
         return promise.then(data => MsgCloseGroupResponse.decode(new BinaryReader(data)));
     };
-    /* PauseGroup defines a method to close a group of a deployment given proper inputs. */
+    /* PauseGroup defines a method to pause a group of a deployment given proper inputs. */
     pauseGroup = async (request) => {
         const data = MsgPauseGroup.encode(request).finish();
-        const promise = this.rpc.request("akash.deployment.v1beta3.Msg", "PauseGroup", data);
+        const promise = this.rpc.request("akash.deployment.v1beta5.Msg", "PauseGroup", data);
         return promise.then(data => MsgPauseGroupResponse.decode(new BinaryReader(data)));
     };
-    /* StartGroup defines a method to close a group of a deployment given proper inputs. */
+    /* StartGroup defines a method to start a group of a deployment given proper inputs. */
     startGroup = async (request) => {
         const data = MsgStartGroup.encode(request).finish();
-        const promise = this.rpc.request("akash.deployment.v1beta3.Msg", "StartGroup", data);
+        const promise = this.rpc.request("akash.deployment.v1beta5.Msg", "StartGroup", data);
         return promise.then(data => MsgStartGroupResponse.decode(new BinaryReader(data)));
     };
+    /* UpdateParams defines a governance operation for updating the x/deployment module
+     parameters. The authority is hard-coded to the x/gov module account.
+    
+     Since: akash v1.0.0 */
+    updateParams = async (request) => {
+        const data = MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("akash.deployment.v1beta5.Msg", "UpdateParams", data);
+        return promise.then(data => MsgUpdateParamsResponse.decode(new BinaryReader(data)));
+    };
 }
 export const createClientImpl = (rpc) => {
     return new MsgClientImpl(rpc);

package/esm/akash/discovery/v1/akash.js

@@ -1,9 +1,13 @@
 //@ts-nocheck
-import { ClientInfo } from "./client_info";
+import { ClientInfo, VersionInfo } from "./client_info";
 import { BinaryReader, BinaryWriter } from "../../../binary";
 function createBaseAkash() {
     return {
-        clientInfo: undefined
+        clientInfo: ClientInfo.fromPartial({}),
+        supportedVersions: [],
+        chainId: "",
+        nodeVersion: "",
+        minClientVersion: ""
     };
 }
 /**
@@ -18,6 +22,18 @@ export const Akash = {
         if (message.clientInfo !== undefined) {
             ClientInfo.encode(message.clientInfo, writer.uint32(10).fork()).ldelim();
         }
+        for (const v of message.supportedVersions) {
+            VersionInfo.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.chainId !== "") {
+            writer.uint32(26).string(message.chainId);
+        }
+        if (message.nodeVersion !== "") {
+            writer.uint32(34).string(message.nodeVersion);
+        }
+        if (message.minClientVersion !== "") {
+            writer.uint32(42).string(message.minClientVersion);
+        }
         return writer;
     },
     decode(input, length) {
@@ -30,6 +46,18 @@ export const Akash = {
                 case 1:
                     message.clientInfo = ClientInfo.decode(reader, reader.uint32());
                     break;
+                case 2:
+                    message.supportedVersions.push(VersionInfo.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.chainId = reader.string();
+                    break;
+                case 4:
+                    message.nodeVersion = reader.string();
+                    break;
+                case 5:
+                    message.minClientVersion = reader.string();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -40,6 +68,10 @@ export const Akash = {
     fromPartial(object) {
         const message = createBaseAkash();
         message.clientInfo = object.clientInfo !== undefined && object.clientInfo !== null ? ClientInfo.fromPartial(object.clientInfo) : undefined;
+        message.supportedVersions = object.supportedVersions?.map(e => VersionInfo.fromPartial(e)) || [];
+        message.chainId = object.chainId ?? "";
+        message.nodeVersion = object.nodeVersion ?? "";
+        message.minClientVersion = object.minClientVersion ?? "";
         return message;
     },
     fromAmino(object) {
@@ -47,11 +79,30 @@ export const Akash = {
         if (object.client_info !== undefined && object.client_info !== null) {
             message.clientInfo = ClientInfo.fromAmino(object.client_info);
         }
+        message.supportedVersions = object.supported_versions?.map(e => VersionInfo.fromAmino(e)) || [];
+        if (object.chain_id !== undefined && object.chain_id !== null) {
+            message.chainId = object.chain_id;
+        }
+        if (object.node_version !== undefined && object.node_version !== null) {
+            message.nodeVersion = object.node_version;
+        }
+        if (object.min_client_version !== undefined && object.min_client_version !== null) {
+            message.minClientVersion = object.min_client_version;
+        }
         return message;
     },
     toAmino(message) {
         const obj = {};
         obj.client_info = message.clientInfo ? ClientInfo.toAmino(message.clientInfo) : ClientInfo.toAmino(ClientInfo.fromPartial({}));
+        if (message.supportedVersions) {
+            obj.supported_versions = message.supportedVersions.map(e => e ? VersionInfo.toAmino(e) : undefined);
+        }
+        else {
+            obj.supported_versions = message.supportedVersions;
+        }
+        obj.chain_id = message.chainId ?? "";
+        obj.node_version = message.nodeVersion ?? "";
+        obj.min_client_version = message.minClientVersion ?? "";
         return obj;
     },
     fromAminoMsg(object) {

package/esm/akash/discovery/v1/client_info.js

@@ -69,3 +69,183 @@ export const ClientInfo = {
         };
     }
 };
+function createBaseModuleVersion() {
+    return {
+        module: "",
+        version: ""
+    };
+}
+/**
+ * ModuleVersion describes a single module and its API version.
+ * @name ModuleVersion
+ * @package akash.discovery.v1
+ * @see proto type: akash.discovery.v1.ModuleVersion
+ */
+export const ModuleVersion = {
+    typeUrl: "/akash.discovery.v1.ModuleVersion",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.module !== "") {
+            writer.uint32(10).string(message.module);
+        }
+        if (message.version !== "") {
+            writer.uint32(18).string(message.version);
+        }
+        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 = createBaseModuleVersion();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.module = reader.string();
+                    break;
+                case 2:
+                    message.version = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseModuleVersion();
+        message.module = object.module ?? "";
+        message.version = object.version ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseModuleVersion();
+        if (object.module !== undefined && object.module !== null) {
+            message.module = object.module;
+        }
+        if (object.version !== undefined && object.version !== null) {
+            message.version = object.version;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.module = message.module ?? "";
+        obj.version = message.version ?? "";
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ModuleVersion.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ModuleVersion.decode(message.value);
+    },
+    toProto(message) {
+        return ModuleVersion.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.discovery.v1.ModuleVersion",
+            value: ModuleVersion.encode(message).finish()
+        };
+    }
+};
+function createBaseVersionInfo() {
+    return {
+        apiVersion: "",
+        modules: [],
+        features: []
+    };
+}
+/**
+ * VersionInfo describes a complete API version and its metadata.
+ * @name VersionInfo
+ * @package akash.discovery.v1
+ * @see proto type: akash.discovery.v1.VersionInfo
+ */
+export const VersionInfo = {
+    typeUrl: "/akash.discovery.v1.VersionInfo",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.apiVersion !== "") {
+            writer.uint32(10).string(message.apiVersion);
+        }
+        for (const v of message.modules) {
+            ModuleVersion.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.features) {
+            writer.uint32(26).string(v);
+        }
+        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 = createBaseVersionInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.apiVersion = reader.string();
+                    break;
+                case 2:
+                    message.modules.push(ModuleVersion.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.features.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseVersionInfo();
+        message.apiVersion = object.apiVersion ?? "";
+        message.modules = object.modules?.map(e => ModuleVersion.fromPartial(e)) || [];
+        message.features = object.features?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseVersionInfo();
+        if (object.api_version !== undefined && object.api_version !== null) {
+            message.apiVersion = object.api_version;
+        }
+        message.modules = object.modules?.map(e => ModuleVersion.fromAmino(e)) || [];
+        message.features = object.features?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.api_version = message.apiVersion ?? "";
+        if (message.modules) {
+            obj.modules = message.modules.map(e => e ? ModuleVersion.toAmino(e) : undefined);
+        }
+        else {
+            obj.modules = message.modules;
+        }
+        if (message.features) {
+            obj.features = message.features.map(e => e);
+        }
+        else {
+            obj.features = message.features;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return VersionInfo.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return VersionInfo.decode(message.value);
+    },
+    toProto(message) {
+        return VersionInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.discovery.v1.VersionInfo",
+            value: VersionInfo.encode(message).finish()
+        };
+    }
+};

package/esm/akash/discovery/v1/service.js

@@ -0,0 +1,128 @@
+//@ts-nocheck
+import { Akash } from "./akash";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGetInfoRequest() {
+    return {};
+}
+/**
+ * GetInfoRequest is the request type for the Discovery/GetInfo RPC method.
+ * @name GetInfoRequest
+ * @package akash.discovery.v1
+ * @see proto type: akash.discovery.v1.GetInfoRequest
+ */
+export const GetInfoRequest = {
+    typeUrl: "/akash.discovery.v1.GetInfoRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseGetInfoRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseGetInfoRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseGetInfoRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GetInfoRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GetInfoRequest.decode(message.value);
+    },
+    toProto(message) {
+        return GetInfoRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.discovery.v1.GetInfoRequest",
+            value: GetInfoRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseGetInfoResponse() {
+    return {
+        info: undefined
+    };
+}
+/**
+ * GetInfoResponse is the response type for the Discovery/GetInfo RPC method.
+ * @name GetInfoResponse
+ * @package akash.discovery.v1
+ * @see proto type: akash.discovery.v1.GetInfoResponse
+ */
+export const GetInfoResponse = {
+    typeUrl: "/akash.discovery.v1.GetInfoResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.info !== undefined) {
+            Akash.encode(message.info, 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 = createBaseGetInfoResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.info = Akash.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGetInfoResponse();
+        message.info = object.info !== undefined && object.info !== null ? Akash.fromPartial(object.info) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGetInfoResponse();
+        if (object.info !== undefined && object.info !== null) {
+            message.info = Akash.fromAmino(object.info);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.info = message.info ? Akash.toAmino(message.info) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GetInfoResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GetInfoResponse.decode(message.value);
+    },
+    toProto(message) {
+        return GetInfoResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.discovery.v1.GetInfoResponse",
+            value: GetInfoResponse.encode(message).finish()
+        };
+    }
+};